diff options
Diffstat (limited to 'debian/imlib/imlib-1.9.15/gdk_imlib/rend.c')
| -rw-r--r-- | debian/imlib/imlib-1.9.15/gdk_imlib/rend.c | 7062 |
1 files changed, 7062 insertions, 0 deletions
diff --git a/debian/imlib/imlib-1.9.15/gdk_imlib/rend.c b/debian/imlib/imlib-1.9.15/gdk_imlib/rend.c new file mode 100644 index 00000000..fa38e23b --- /dev/null +++ b/debian/imlib/imlib-1.9.15/gdk_imlib/rend.c @@ -0,0 +1,7062 @@ +#define _GNU_SOURCE +#include <config.h> +#include "gdk_imlib.h" +#define id _gdk_imlib_data +#include "gdk_imlib_private.h" + +GdkPixmap * +gdk_imlib_pixmap_foreign_new(gint width, gint height, + gint depth, Pixmap pmap) +{ + GdkPixmap *pixmap; + GdkWindowPrivate *private; + GdkWindowPrivate *window_private; + + private = g_new0(GdkWindowPrivate, 1); + pixmap = (GdkPixmap *) private; + + window_private = (GdkWindowPrivate *) id->x.gdk_win; + + private->xdisplay = window_private->xdisplay; + private->window_type = GDK_WINDOW_PIXMAP; + private->xwindow = pmap; + private->colormap = id->x.gdk_cmap; + private->children = NULL; + private->parent = NULL; + private->x = 0; + private->y = 0; + private->width = width; + private->height = height; + private->resize_count = 0; + private->ref_count = 1; + private->destroyed = 0; + + gdk_xid_table_insert(&private->xwindow, pixmap); + + return pixmap; +} + +gint +gdk_imlib_best_color_match(gint * r, gint * g, gint * b) +{ + int i; + int dif; + int dr, dg, db; + int col; + int mindif = 0x7fffffff; + + col = 0; + g_return_val_if_fail(id->x.disp, -1); + if ((id->render_type == RT_PLAIN_TRUECOL) || + (id->render_type == RT_DITHER_TRUECOL)) + { + dr = *r; + dg = *g; + db = *b; + switch (id->x.depth) + { + case 12: + *r = dr - (dr & 0xf0); + *g = dg - (dg & 0xf0); + *b = db - (db & 0xf0); + return ((dr & 0xf0) << 8) | ((dg & 0xf0) << 3) | ((db & 0xf0) >> 3); + break; + case 15: + *r = dr - (dr & 0xf8); + *g = dg - (dg & 0xf8); + *b = db - (db & 0xf8); + return ((dr & 0xf8) << 7) | ((dg & 0xf8) << 2) | ((db & 0xf8) >> 3); + break; + case 16: + *r = dr - (dr & 0xf8); + *g = dg - (dg & 0xfc); + *b = db - (db & 0xf8); + return ((dr & 0xf8) << 8) | ((dg & 0xfc) << 3) | ((db & 0xf8) >> 3); + break; + case 24: + case 32: + *r = 0; + *g = 0; + *b = 0; + switch (id->byte_order) + { + case BYTE_ORD_24_RGB: + return ((dr & 0xff) << 16) | ((dg & 0xff) << 8) | (db & 0xff); + break; + case BYTE_ORD_24_RBG: + return ((dr & 0xff) << 16) | ((db & 0xff) << 8) | (dg & 0xff); + break; + case BYTE_ORD_24_BRG: + return ((db & 0xff) << 16) | ((dr & 0xff) << 8) | (dg & 0xff); + break; + case BYTE_ORD_24_BGR: + return ((db & 0xff) << 16) | ((dg & 0xff) << 8) | (dr & 0xff); + break; + case BYTE_ORD_24_GRB: + return ((dg & 0xff) << 16) | ((dr & 0xff) << 8) | (db & 0xff); + break; + case BYTE_ORD_24_GBR: + return ((dg & 0xff) << 16) | ((db & 0xff) << 8) | (dr & 0xff); + break; + default: + return 0; + break; + } + break; + default: + return 0; + break; + } + return 0; + } + for (i = 0; i < id->num_colors; i++) + { + dr = *r - id->palette[i].r; + if (dr < 0) + dr = -dr; + dg = *g - id->palette[i].g; + if (dg < 0) + dg = -dg; + db = *b - id->palette[i].b; + if (db < 0) + db = -db; + dif = dr + dg + db; + if (dif < mindif) + { + mindif = dif; + col = i; + } + } + *r -= id->palette[col].r; + *g -= id->palette[col].g; + *b -= id->palette[col].b; + col = id->palette[col].pixel; + return col; +} + +gint +_gdk_imlib_index_best_color_match(gint * r, gint * g, gint * b) +{ + int i; + int dif; + int dr, dg, db; + int col; + int mindif = 0x7fffffff; + + col = 0; + g_return_val_if_fail(id->x.disp, -1); + if ((id->render_type == RT_PLAIN_TRUECOL) || + (id->render_type == RT_DITHER_TRUECOL)) + { + dr = *r; + dg = *g; + db = *b; + switch (id->x.depth) + { + case 12: + *r = dr - (dr & 0xf0); + *g = dg - (dg & 0xf0); + *b = db - (db & 0xf0); + return ((dr & 0xf0) << 8) | ((dg & 0xf0) << 3) | ((db & 0xf0) >> 3); + break; + case 15: + *r = dr - (dr & 0xf8); + *g = dg - (dg & 0xf8); + *b = db - (db & 0xf8); + return ((dr & 0xf8) << 7) | ((dg & 0xf8) << 2) | ((db & 0xf8) >> 3); + break; + case 16: + *r = dr - (dr & 0xf8); + *g = dg - (dg & 0xfc); + *b = db - (db & 0xf8); + return ((dr & 0xf8) << 8) | ((dg & 0xfc) << 3) | ((db & 0xf8) >> 3); + break; + case 24: + case 32: + *r = 0; + *g = 0; + *b = 0; + switch (id->byte_order) + { + case BYTE_ORD_24_RGB: + return ((dr & 0xff) << 16) | ((dg & 0xff) << 8) | (db & 0xff); + break; + case BYTE_ORD_24_RBG: + return ((dr & 0xff) << 16) | ((db & 0xff) << 8) | (dg & 0xff); + break; + case BYTE_ORD_24_BRG: + return ((db & 0xff) << 16) | ((dr & 0xff) << 8) | (dg & 0xff); + break; + case BYTE_ORD_24_BGR: + return ((db & 0xff) << 16) | ((dg & 0xff) << 8) | (dr & 0xff); + break; + case BYTE_ORD_24_GRB: + return ((dg & 0xff) << 16) | ((dr & 0xff) << 8) | (db & 0xff); + break; + case BYTE_ORD_24_GBR: + return ((dg & 0xff) << 16) | ((db & 0xff) << 8) | (dr & 0xff); + break; + default: + return 0; + break; + } + break; + default: + return 0; + break; + } + return 0; + } + for (i = 0; i < id->num_colors; i++) + { + dr = *r - id->palette[i].r; + if (dr < 0) + dr = -dr; + dg = *g - id->palette[i].g; + if (dg < 0) + dg = -dg; + db = *b - id->palette[i].b; + if (db < 0) + db = -db; + dif = dr + dg + db; + if (dif < mindif) + { + mindif = dif; + col = i; + } + } + *r -= id->palette[col].r; + *g -= id->palette[col].g; + *b -= id->palette[col].b; + return col; +} + +static void +grender_shaped_15_fast_dither(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x07; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_shaped_15_fast_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + + unsigned char dither[4][4] = + { + {0, 4, 1, 5}, + {6, 2, 7, 3}, + {1, 5, 0, 4}, + {7, 3, 6, 2} + }; + int dithy, dithx; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < eg) && (g < (256 - 8))) + g += 8; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_15_fast_dither(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x07; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_15_fast_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + + unsigned short *img; + int jmp; + + unsigned char dither[4][4] = + { + {0, 4, 1, 5}, + {6, 2, 7, 3}, + {1, 5, 0, 4}, + {7, 3, 6, 2} + }; + int dithy, dithx; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < eg) && (g < (256 - 8))) + g += 8; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_shaped_16_fast_dither(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x03; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_shaped_16_fast_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + + unsigned char dither[4][4] = + { + {0, 4, 1, 5}, + {6, 2, 7, 3}, + {1, 5, 0, 4}, + {7, 3, 6, 2} + }; + int dithy, dithx; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r & 0x07; + eg = g & 0x03; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4))) + g += 4; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_16_fast_dither(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x03; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_16_fast_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + + unsigned short *img; + int jmp; + + unsigned char dither[4][4] = + { + {0, 4, 1, 5}, + {6, 2, 7, 3}, + {1, 5, 0, 4}, + {7, 3, 6, 2} + }; + int dithy, dithx; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r & 0x07; + eg = g & 0x03; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4))) + g += 4; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_shaped_15_dither(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x07; + eb = eb & 0x07; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_shaped_15_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + + unsigned char dither[4][4] = + { + {0, 4, 1, 5}, + {6, 2, 7, 3}, + {1, 5, 0, 4}, + {7, 3, 6, 2} + }; + int dithy, dithx; + + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + } + else + { + XPutPixel(sxim, x, y, 1); + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < eg) && (g < (256 - 8))) + g += 8; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_15_dither(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x07; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_15_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < eg) && (g < (256 - 8))) + g += 8; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_16_dither(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x03; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_shaped_16_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + } + else + { + XPutPixel(sxim, x, y, 1); + er = r & 0x07; + eg = g & 0x03; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4))) + g += 4; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_16_dither(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x03; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_16_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r & 0x07; + eg = g & 0x03; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4))) + g += 4; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_15_fast(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_15_fast(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_shaped_16_fast(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_16_fast(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_shaped_24_fast(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, r, g, b; + unsigned char *ptr2; + unsigned char *img; + int jmp; + + jmp = (xim->bytes_per_line) - w * 3; + img = (unsigned char *)xim->data; + if (id->x.byte_order == MSBFirst) + { + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = r; + *img++ = g; + *img++ = b; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = r; + *img++ = b; + *img++ = g; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = b; + *img++ = r; + *img++ = g; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = b; + *img++ = g; + *img++ = r; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = g; + *img++ = r; + *img++ = b; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = g; + *img++ = b; + *img++ = r; + } + } + img += jmp; + } + } + } + else + { + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = b; + *img++ = g; + *img++ = r; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = g; + *img++ = b; + *img++ = r; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = g; + *img++ = r; + *img++ = b; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = r; + *img++ = g; + *img++ = b; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = b; + *img++ = r; + *img++ = g; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = r; + *img++ = b; + *img++ = g; + } + } + img += jmp; + } + } + } +} + +static void +grender_24_fast(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, r, g, b; + unsigned char *ptr2; + unsigned char *img; + int jmp; + + jmp = (xim->bytes_per_line) - w * 3; + img = (unsigned char *)xim->data; + + if (id->byte_order == MSBFirst) + { + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = r; + *img++ = g; + *img++ = b; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = r; + *img++ = b; + *img++ = g; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = b; + *img++ = r; + *img++ = g; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = b; + *img++ = g; + *img++ = r; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = g; + *img++ = r; + *img++ = b; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = g; + *img++ = b; + *img++ = r; + } + img += jmp; + } + } + } + else + { + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = b; + *img++ = g; + *img++ = r; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = g; + *img++ = b; + *img++ = r; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = g; + *img++ = r; + *img++ = b; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = r; + *img++ = g; + *img++ = b; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = b; + *img++ = r; + *img++ = g; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + *img++ = r; + *img++ = b; + *img++ = g; + } + img += jmp; + } + } + } +} + +static void +grender_shaped_32_fast(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned int *img; + int jmp; + + jmp = (xim->bytes_per_line >> 2) - w; + img = (unsigned int *)xim->data; + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = (r << 16) | (g << 8) | b; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = (r << 16) | (b << 8) | g; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = (b << 16) | (r << 8) | g; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = (b << 16) | (g << 8) | r; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = (g << 16) | (r << 8) | b; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = (g << 16) | (b << 8) | r; + *img++ = val; + } + } + img += jmp; + } + } +} + +static void +grender_32_fast(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned int *img; + int jmp; + + jmp = (xim->bytes_per_line >> 2) - w; + img = (unsigned int *)xim->data; + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (r << 16) | (g << 8) | b; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (r << 16) | (b << 8) | g; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (b << 16) | (r << 8) | g; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (b << 16) | (g << 8) | r; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (g << 16) | (r << 8) | b; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (g << 16) | (b << 8) | r; + *img++ = val; + } + img += jmp; + } + } +} + +static void +grender_shaped_15(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_15(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_16(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_16(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_12(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = ((r & 0xf0) << 8) | ((g & 0xf0) << 3) | ((b & 0xf0) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_12(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = ((r & 0xf0) << 8) | ((g & 0xf0) << 3) | ((b & 0xf0) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_24(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = (r << 16) | (g << 8) | b; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = (r << 16) | (b << 8) | g; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = (b << 16) | (r << 8) | g; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = (b << 16) | (g << 8) | r; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = (g << 16) | (r << 8) | b; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = (g << 16) | (b << 8) | r; + XPutPixel(xim, x, y, val); + } + } + } + } +} + +static void +grender_24(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (r << 16) | (g << 8) | b; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (r << 16) | (b << 8) | g; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (b << 16) | (r << 8) | g; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (b << 16) | (g << 8) | r; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (g << 16) | (r << 8) | b; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = (g << 16) | (b << 8) | r; + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_shaped(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray, int bpp) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned char *img; + int jmp; + + jmp = (xim->bytes_per_line) - w * (bpp >> 3); + img = (unsigned char *)xim->data; + switch (id->render_type) + { + case RT_PLAIN_PALETTE: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = gdk_imlib_best_color_match(&r, &g, &b); + *img++ = val; + } + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = gdk_imlib_best_color_match(&r, &g, &b); + XPutPixel(xim, x, y, val); + } + } + } + } + break; + case RT_PLAIN_PALETTE_FAST: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + val = COLOR_RGB(r >> 3, g >> 3, b >> 3); + *img++ = val; + } + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + val = COLOR_RGB(r >> 3, g >> 3, b >> 3); + XPutPixel(xim, x, y, val); + } + } + } + } + break; + case RT_DITHER_PALETTE: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + { + XPutPixel(sxim, x, y, 0); + img++; + } + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = gdk_imlib_best_color_match(&er, &eg, &eb); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = gdk_imlib_best_color_match(&er, &eg, &eb); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } + } + } + break; + case RT_DITHER_PALETTE_FAST: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + { + XPutPixel(sxim, x, y, 0); + img++; + } + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3); + er = ERROR_RED(er, val); + eg = ERROR_GRN(eg, val); + eb = ERROR_BLU(eb, val); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = COLOR_INDEX(val); + } + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3); + er = ERROR_RED(er, val); + eg = ERROR_GRN(eg, val); + eb = ERROR_BLU(eb, val); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, COLOR_INDEX(val)); + } + } + } + } + break; + default: + if (id->fastrend) + { + switch (bpp) + { + case 8: + break; + case 12: + printf("iPAQ1\n"); + break; + case 15: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_shaped_15_fast_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_15_fast_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_shaped_15_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 16: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_shaped_16_fast_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_16_fast_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_shaped_16_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 24: + case 32: + if (xim->bits_per_pixel == 24) + grender_shaped_24_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_32_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + default: + break; + } + } + else + { + switch (bpp) + { + case 8: + break; + case 12: + grender_shaped_12(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 15: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_shaped_15_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_15_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_shaped_15(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 16: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_shaped_16_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_16_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_shaped_16(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 24: + grender_shaped_24(im, w, h, xim, sxim, er1, er2, xarray, yarray); + case 32: + grender_shaped_24(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + default: + break; + } + } + break; + } +} + +static void +grender(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray, int bpp) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned char *img; + int jmp; + + jmp = (xim->bytes_per_line) - w * (bpp >> 3); + img = (unsigned char *)xim->data; + switch (id->render_type) + { + case RT_PLAIN_PALETTE: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = gdk_imlib_best_color_match(&r, &g, &b); + *img++ = val; + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = gdk_imlib_best_color_match(&r, &g, &b); + XPutPixel(xim, x, y, val); + } + } + } + break; + case RT_PLAIN_PALETTE_FAST: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = COLOR_RGB(r >> 3, g >> 3, b >> 3); + *img++ = val; + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + val = COLOR_RGB(r >> 3, g >> 3, b >> 3); + XPutPixel(xim, x, y, val); + } + } + } + break; + case RT_DITHER_PALETTE: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = gdk_imlib_best_color_match(&er, &eg, &eb); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = gdk_imlib_best_color_match(&er, &eg, &eb); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } + } + break; + case RT_DITHER_PALETTE_FAST: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3); + er = ERROR_RED(er, val); + eg = ERROR_GRN(eg, val); + eb = ERROR_BLU(eb, val); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = COLOR_INDEX(val); + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3); + er = ERROR_RED(er, val); + eg = ERROR_GRN(eg, val); + eb = ERROR_BLU(eb, val); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, COLOR_INDEX(val)); + } + } + } + break; + default: + if (id->fastrend) + { + switch (bpp) + { + case 8: + break; + case 12: + printf("iPAQ3\n"); + break; + case 15: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_15_fast_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_15_fast_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_15_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 16: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_16_fast_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_16_fast_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_16_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 24: + case 32: + if (xim->bits_per_pixel == 24) + grender_24_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_32_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + default: + break; + } + } + else + { + switch (bpp) + { + case 8: + break; + case 12: + grender_12(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 15: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_15_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_15_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_15(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 16: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_16_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_16_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_16(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 24: + grender_24(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 32: + grender_24(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + default: + break; + } + break; + } + } +} + +static void +grender_shaped_15_fast_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + ex += 3; + } + else + { + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + XPutPixel(sxim, x, y, 1); + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x07; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_shaped_15_fast_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + XPutPixel(sxim, x, y, 1); + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < eg) && (g < (256 - 8))) + g += 8; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_15_fast_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er = 0, eg = 0, eb = 0; + unsigned char *ptr2; + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x07; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_15_fast_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < eg) && (g < (256 - 8))) + g += 8; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_shaped_16_fast_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x03; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_shaped_16_fast_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + XPutPixel(sxim, x, y, 1); + er = r & 0x07; + eg = g & 0x03; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4))) + g += 4; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_16_fast_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x03; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_16_fast_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r & 0x07; + eg = g & 0x03; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4))) + g += 4; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_shaped_15_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + } + else + { + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + XPutPixel(sxim, x, y, 1); + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < eg) && (g < (256 - 8))) + g += 8; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_15_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < eg) && (g < (256 - 8))) + g += 8; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_16_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + } + else + { + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + XPutPixel(sxim, x, y, 1); + er = r & 0x07; + eg = g & 0x03; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4))) + g += 4; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_16_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, er, eg, eb; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + unsigned char dither[4][4] = + { + {0, 4, 6, 5}, + {6, 2, 7, 3}, + {2, 6, 1, 5}, + {7, 4, 7, 3} + }; + int dithy, dithx; + + for (y = 0; y < h; y++) + { + dithy = y & 0x3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r & 0x07; + eg = g & 0x03; + eb = b & 0x07; + dithx = x & 0x3; + if ((dither[dithy][dithx] < er) && (r < (256 - 8))) + r += 8; + if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4))) + g += 4; + if ((dither[dithy][dithx] < eb) && (b < (256 - 8))) + b += 8; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_15_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x07; + eb = eb & 0x07; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + er = r & 0x07; + eg = g & 0x07; + eb = b & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_15_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x07; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_16_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x03; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_16_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + if (eg > 255) + eg = 255; + if (eb > 255) + eb = 255; + val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3); + er = er & 0x07; + eg = eg & 0x03; + eb = eb & 0x07; + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_15_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_15_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_shaped_16_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned short *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + *img++ = val; + } + } + img += jmp; + } +} + +static void +grender_16_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + unsigned short *img; + int jmp; + + jmp = (xim->bytes_per_line >> 1) - w; + img = (unsigned short *)xim->data; + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + *img++ = val; + } + img += jmp; + } +} + +static void +grender_shaped_24_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, r, g, b; + unsigned char *ptr2; + unsigned char *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line) - w * 3; + img = (unsigned char *)xim->data; + if (id->x.byte_order == MSBFirst) + { + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = r; + *img++ = g; + *img++ = b; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = r; + *img++ = b; + *img++ = g; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = b; + *img++ = r; + *img++ = g; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = b; + *img++ = g; + *img++ = r; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = g; + *img++ = r; + *img++ = b; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = g; + *img++ = b; + *img++ = r; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + } + } + img += jmp; + } + } + } + else + { + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = b; + *img++ = g; + *img++ = r; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = g; + *img++ = b; + *img++ = r; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = g; + *img++ = r; + *img++ = b; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = r; + *img++ = g; + *img++ = b; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = b; + *img++ = r; + *img++ = g; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + *img++ = r; + *img++ = b; + *img++ = g; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + } + } + img += jmp; + } + } + } +} + +static void +grender_24_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, r, g, b; + unsigned char *ptr2; + unsigned char *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line) - w * 3; + img = (unsigned char *)xim->data; + + if (id->x.byte_order == MSBFirst) + { + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = r; + *img++ = g; + *img++ = b; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = r; + *img++ = b; + *img++ = g; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = b; + *img++ = r; + *img++ = g; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = b; + *img++ = g; + *img++ = r; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = g; + *img++ = r; + *img++ = b; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = g; + *img++ = b; + *img++ = r; + } + img += jmp; + } + } + } + else + { + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = b; + *img++ = g; + *img++ = r; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = g; + *img++ = b; + *img++ = r; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = g; + *img++ = r; + *img++ = b; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = r; + *img++ = g; + *img++ = b; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = b; + *img++ = r; + *img++ = g; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + *img++ = r; + *img++ = b; + *img++ = g; + } + img += jmp; + } + } + } +} + +static void +grender_shaped_32_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned int *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 2) - w; + img = (unsigned int *)xim->data; + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (r << 16) | (g << 8) | b; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (r << 16) | (b << 8) | g; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (b << 16) | (r << 8) | g; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (b << 16) | (g << 8) | r; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (g << 16) | (r << 8) | b; + *img++ = val; + } + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (g << 16) | (b << 8) | r; + *img++ = val; + } + } + img += jmp; + } + } +} + +static void +grender_32_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + unsigned int *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line >> 2) - w; + img = (unsigned int *)xim->data; + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (r << 16) | (g << 8) | b; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (r << 16) | (b << 8) | g; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (b << 16) | (r << 8) | g; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (b << 16) | (g << 8) | r; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (g << 16) | (r << 8) | b; + *img++ = val; + } + img += jmp; + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (g << 16) | (b << 8) | r; + *img++ = val; + } + img += jmp; + } + } +} + +static void +grender_shaped_15_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_15_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_16_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_16_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_12_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = ((r & 0xf0) << 8) | ((g & 0xf0) << 3) | ((b & 0xf0) >> 3); + XPutPixel(xim, x, y, val); + } + } +} + +static void +grender_shaped_24_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (r << 16) | (g << 8) | b; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (r << 16) | (b << 8) | g; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (b << 16) | (r << 8) | g; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (b << 16) | (g << 8) | r; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (g << 16) | (r << 8) | b; + XPutPixel(xim, x, y, val); + } + } + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (g << 16) | (b << 8) | r; + XPutPixel(xim, x, y, val); + } + } + } + } +} + +static void +grender_24_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray) +{ + int x, y, val, r, g, b; + unsigned char *ptr2; + GdkImlibModifierMap *map = im->map; + + if (id->byte_order == BYTE_ORD_24_RGB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (r << 16) | (g << 8) | b; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_RBG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (r << 16) | (b << 8) | g; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_BRG) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (b << 16) | (r << 8) | g; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_BGR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (b << 16) | (g << 8) | r; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_GRB) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (g << 16) | (r << 8) | b; + XPutPixel(xim, x, y, val); + } + } + } + else if (id->byte_order == BYTE_ORD_24_GBR) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = (g << 16) | (b << 8) | r; + XPutPixel(xim, x, y, val); + } + } + } +} + +static void +grender_shaped_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray, int bpp) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned char *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line) - w * (bpp >> 3); + img = (unsigned char *)xim->data; + switch (id->render_type) + { + case RT_PLAIN_PALETTE: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = gdk_imlib_best_color_match(&r, &g, &b); + *img++ = val; + } + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = gdk_imlib_best_color_match(&r, &g, &b); + XPutPixel(xim, x, y, val); + } + } + } + } + break; + case RT_PLAIN_PALETTE_FAST: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + img++; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = COLOR_RGB(r >> 3, g >> 3, b >> 3); + *img++ = val; + } + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + XPutPixel(sxim, x, y, 0); + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = COLOR_RGB(r >> 3, g >> 3, b >> 3); + XPutPixel(xim, x, y, val); + } + } + } + } + break; + case RT_DITHER_PALETTE: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + { + XPutPixel(sxim, x, y, 0); + img++; + } + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = gdk_imlib_best_color_match(&er, &eg, &eb); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = gdk_imlib_best_color_match(&er, &eg, &eb); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } + } + } + break; + case RT_DITHER_PALETTE_FAST: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + { + XPutPixel(sxim, x, y, 0); + img++; + } + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3); + er = ERROR_RED(er, val); + eg = ERROR_GRN(eg, val); + eb = ERROR_BLU(eb, val); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = COLOR_INDEX(val); + } + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + if ((r == im->shape_color.r) && + (g == im->shape_color.g) && + (b == im->shape_color.b)) + { + XPutPixel(sxim, x, y, 0); + ex += 3; + } + else + { + XPutPixel(sxim, x, y, 1); + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3); + er = ERROR_RED(er, val); + eg = ERROR_GRN(eg, val); + eb = ERROR_BLU(eb, val); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, COLOR_INDEX(val)); + } + } + } + } + break; + default: + if (id->fastrend) + { + switch (bpp) + { + case 8: + break; + case 12: + printf("iPAQ5\n"); + break; + case 15: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_shaped_15_fast_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_15_fast_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_shaped_15_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 16: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_shaped_16_fast_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_16_fast_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_shaped_16_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 24: + case 32: + if (xim->bits_per_pixel == 24) + grender_shaped_24_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_32_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + default: + break; + } + } + else + { + switch (bpp) + { + case 8: + break; + case 12: + printf("iPAQ6\n"); + break; + case 15: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_shaped_15_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + grender_shaped_15_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_shaped_15_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 16: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_shaped_16_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_shaped_16_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_shaped_16_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 24: + grender_shaped_24_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + case 32: + grender_shaped_24_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + default: + break; + } + } + break; + } +} + +static void +grender_mod(GdkImlibImage * im, int w, int h, XImage * xim, + XImage * sxim, int *er1, int *er2, int *xarray, + unsigned char **yarray, int bpp) +{ + int x, y, val, r, g, b, *ter, ex, er, eg, eb; + unsigned char *ptr2; + unsigned char *img; + int jmp; + GdkImlibModifierMap *map = im->map; + + jmp = (xim->bytes_per_line) - w * (bpp >> 3); + img = (unsigned char *)xim->data; + switch (id->render_type) + { + case RT_PLAIN_PALETTE: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = gdk_imlib_best_color_match(&r, &g, &b); + *img++ = val; + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = gdk_imlib_best_color_match(&r, &g, &b); + XPutPixel(xim, x, y, val); + } + } + } + break; + case RT_PLAIN_PALETTE_FAST: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = COLOR_RGB(r >> 3, g >> 3, b >> 3); + *img++ = val; + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + val = COLOR_RGB(r >> 3, g >> 3, b >> 3); + XPutPixel(xim, x, y, val); + } + } + } + break; + case RT_DITHER_PALETTE: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = gdk_imlib_best_color_match(&er, &eg, &eb); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = val; + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = gdk_imlib_best_color_match(&er, &eg, &eb); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, val); + } + } + } + break; + case RT_DITHER_PALETTE_FAST: + if ((id->fastrend) && (xim->bits_per_pixel == 8)) + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3); + er = ERROR_RED(er, val); + eg = ERROR_GRN(eg, val); + eb = ERROR_BLU(eb, val); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + *img++ = COLOR_INDEX(val); + } + img += jmp; + } + } + else + { + for (y = 0; y < h; y++) + { + ter = er1; + er1 = er2; + er2 = ter; + for (ex = 0; ex < (w + 2) * 3; ex++) + er2[ex] = 0; + ex = 3; + for (x = 0; x < w; x++) + { + ptr2 = yarray[y] + xarray[x]; + r = (int)*ptr2++; + g = (int)*ptr2++; + b = (int)*ptr2; + r = map->rmap[r]; + g = map->gmap[g]; + b = map->bmap[b]; + er = r + er1[ex++]; + eg = g + er1[ex++]; + eb = b + er1[ex++]; + if (er > 255) + er = 255; + else if (er < 0) + er = 0; + if (eg > 255) + eg = 255; + else if (eg < 0) + eg = 0; + if (eb > 255) + eb = 255; + else if (eb < 0) + eb = 0; + val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3); + er = ERROR_RED(er, val); + eg = ERROR_GRN(eg, val); + eb = ERROR_BLU(eb, val); + DITHER_ERROR(er1, er2, ex, er, eg, eb); + XPutPixel(xim, x, y, COLOR_INDEX(val)); + } + } + } + break; + default: + if (id->fastrend) + { + switch (bpp) + { + case 8: + break; + case 12: + printf("iPAQ7\n"); + break; + case 15: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_15_fast_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_15_fast_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_15_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 16: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_16_fast_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_16_fast_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_16_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 24: + case 32: + if (xim->bits_per_pixel == 24) + grender_24_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_32_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + default: + break; + } + } + else + { + switch (bpp) + { + case 8: + break; + case 12: + grender_12_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 15: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_15_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_15_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_15_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 16: + if (id->render_type == RT_DITHER_TRUECOL) + { + if (id->ordered_dither) + grender_16_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray); + else + grender_16_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + } + else + grender_16_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 24: + grender_24_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + case 32: + grender_24_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray); + break; + default: + break; + } + break; + } + } +} + +gint +gdk_imlib_render(GdkImlibImage * im, gint w, gint h) +{ + XImage *xim, *sxim; + GC tgc, stgc; + XGCValues gcv; + unsigned char *tmp, *stmp, **yarray, *ptr22; + int w3, x, inc, pos, *error, *er1, *er2, *xarray, ex, bpp, + huge; + Pixmap pmap, mask; + GdkPixmap *pm, *mm; + int shared_pixmap, shared_image, ok; + + sxim = NULL; + xim = NULL; + tmp = NULL; + stmp = NULL; + pmap = 0; + mask = 0; + tgc = 0; + stgc = 0; + inc = 0; + if (!im) + return 0; + if (w <= 0) + return 0; + if (h <= 0) + return 0; + gcv.graphics_exposures = False; + +/* look for the pixmap in cache first */ + if (id->cache.on_pixmap) + { + pmap = 0; + _gdk_imlib_find_pixmap(im, w, h, &pm, &mm); + if (pm) + { + im->width = w; + im->height = h; + im->pixmap = pm; + if (mm) + im->shape_mask = mm; + else + im->shape_mask = NULL; + return 1; + } + } + if (im->pixmap) + _gdk_imlib_free_pixmappmap(im->pixmap); + im->pixmap = NULL; + im->shape_mask = NULL; +/* setup stuff */ + huge = 0; + if (id->x.depth <= 8) + bpp = 1; + else if (id->x.depth <= 16) + bpp = 2; + else if (id->x.depth <= 24) + bpp = 3; + else + bpp = 4; + if ((id->max_shm) && ((bpp * w * h) > id->max_shm)) + huge = 1; + im->width = w; + im->height = h; + +/* dithering array */ + error = (int *)malloc(sizeof(int) * (w + 2) * 2 * 3); + + if (!error) + { + fprintf(stderr, "ERROR: Cannot allocate RAM for image dither buffer\n"); + return 0; + } +/* setup pointers to point right */ + er1 = error; + er2 = error + ((w + 2) * 3); + w3 = im->rgb_width * 3; + ptr22 = im->rgb_data; + +/* setup coord-mapping array (specially for border scaling) */ + xarray = malloc(sizeof(int) * w); + + if (!xarray) + { + fprintf(stderr, "ERROR: Cannot allocate X co-ord buffer\n"); + free(error); + return 0; + } + yarray = malloc(sizeof(unsigned char *) * h); + + if (!yarray) + { + fprintf(stderr, "ERROR: Cannot allocate Y co-ord buffer\n"); + free(xarray); + free(error); + return 0; + } + for (ex = 0; ex < ((w + 2) * 3 * 2); ex++) + error[ex] = 0; + { + int l, r, m; + + if (w < im->border.left + im->border.right) + { + l = w >> 1; + r = w - l; + m = 0; + } + else + { + l = im->border.left; + r = im->border.right; + m = w - l - r; + } + if (m > 0) + inc = ((im->rgb_width - im->border.left - im->border.right) << 16) / m; + pos = 0; + if (l) + for (x = 0; x < l; x++) + { + xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16); + pos += 0x10000; + } + if (m) + { + for (x = l; x < l + m; x++) + { + xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16); + pos += inc; + } + } + pos = (im->rgb_width - r) << 16; + for (x = w - r; x < w; x++) + { + xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16); + pos += 0x10000; + } + + if (h < im->border.top + im->border.bottom) + { + l = h >> 1; + r = h - l; + m = 0; + } + else + { + l = im->border.top; + r = im->border.bottom; + m = h - l - r; + } + if (m > 0) + inc = ((im->rgb_height - im->border.top - im->border.bottom) << 16) / m; + pos = 0; + for (x = 0; x < l; x++) + { + yarray[x] = ptr22 + ((pos >> 16) * w3); + pos += 0x10000; + } + if (m) + { + for (x = l; x < l + m; x++) + { + yarray[x] = ptr22 + ((pos >> 16) * w3); + pos += inc; + } + } + pos = (im->rgb_height - r) << 16; + for (x = h - r; x < h; x++) + { + yarray[x] = ptr22 + ((pos >> 16) * w3); + pos += 0x10000; + } + } + +/* work out if we should use shared pixmap. images etc */ + shared_pixmap = 0; + shared_image = 0; + if ((id->x.shmp) && (id->x.shm) && (!huge)) + { + shared_pixmap = 1; + shared_image = 0; + } + else if ((id->x.shm) && (!huge)) + { + shared_pixmap = 0; + shared_image = 1; + } + else + { + shared_pixmap = 0; + shared_image = 0; + } + +/* init images and pixmaps */ + ok = 1; +#ifdef HAVE_SHM + if (shared_pixmap) + { + xim = XShmCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, NULL, &id->x.last_shminfo, w, h); + if (!xim) + { + fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create XImage for Shared Pixmap Wrapper\n"); + fprintf(stderr, " Falling back on Shared XImages\n"); + shared_pixmap = 0; + shared_image = 1; + ok = 0; + } + if (ok) + { + id->x.last_shminfo.shmid = shmget(IPC_PRIVATE, xim->bytes_per_line * xim->height, IPC_CREAT | 0777); + if (id->x.last_shminfo.shmid == -1) + { + fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared Pixmap Wrapper\n"); + fprintf(stderr, " Falling back on Shared XImages\n"); + XDestroyImage(xim); + shared_pixmap = 0; + shared_image = 1; + ok = 0; + } + if (ok) + { + id->x.last_shminfo.shmaddr = xim->data = shmat(id->x.last_shminfo.shmid, 0, 0); + if (xim->data == (char *)-1) + { + fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared Pixmap Wrapper\n"); + fprintf(stderr, " Falling back on Shared XImages\n"); + XDestroyImage(xim); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + shared_pixmap = 0; + shared_image = 1; + ok = 0; + } + if (ok) + { + id->x.last_shminfo.readOnly = False; + XShmAttach(id->x.disp, &id->x.last_shminfo); + tmp = (unsigned char *)xim->data; + id->x.last_xim = xim; + pmap = XShmCreatePixmap(id->x.disp, id->x.base_window, + id->x.last_shminfo.shmaddr, + &id->x.last_shminfo, w, h, id->x.depth); + tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv); + if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0)) + { + sxim = XShmCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, NULL, &id->x.last_sshminfo, w, h); + if (!sxim) + { + fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create XImage for Shared Pixmap mask Wrapper\n"); + fprintf(stderr, " Falling back on Shared XImages\n"); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(id->x.last_shminfo.shmaddr); + shared_pixmap = 0; + shared_image = 1; + ok = 0; + } + if (ok) + { + id->x.last_sshminfo.shmid = shmget(IPC_PRIVATE, sxim->bytes_per_line * sxim->height, IPC_CREAT | 0777); + if (id->x.last_sshminfo.shmid == -1) + { + fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared Pixmap mask Wrapper\n"); + fprintf(stderr, " Falling back on Shared XImages\n"); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(xim->data); + /* missing shmctl(RMID) */ + XDestroyImage(sxim); + shared_pixmap = 0; + shared_image = 1; + ok = 0; + } + if (ok) + { + id->x.last_sshminfo.shmaddr = sxim->data = shmat(id->x.last_sshminfo.shmid, 0, 0); + if (sxim->data == (char *)-1) + { + fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared Pixmap mask Wrapper\n"); + fprintf(stderr, " Falling back on Shared XImages\n"); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(xim->data); + /* missing shmctl(RMID) */ + XDestroyImage(sxim); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + shared_pixmap = 0; + shared_image = 1; + ok = 0; + } + if (ok) + { + id->x.last_sshminfo.readOnly = False; + XShmAttach(id->x.disp, &id->x.last_sshminfo); + stmp = (unsigned char *)sxim->data; + id->x.last_sxim = sxim; + mask = XShmCreatePixmap(id->x.disp, id->x.base_window, + id->x.last_sshminfo.shmaddr, + &id->x.last_sshminfo, w, h, 1); + stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv); + } + } + } + } + } + } + } + } + ok = 1; + if (shared_image) + { + xim = XShmCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, NULL, &id->x.last_shminfo, w, h); + if (!xim) + { + fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create Shared XImage\n"); + fprintf(stderr, " Falling back on XImages\n"); + shared_pixmap = 0; + shared_image = 0; + ok = 0; + } + if (ok) + { + id->x.last_shminfo.shmid = shmget(IPC_PRIVATE, xim->bytes_per_line * xim->height, IPC_CREAT | 0777); + if (id->x.last_shminfo.shmid == -1) + { + fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared XImage\n"); + fprintf(stderr, " Falling back on XImages\n"); + XDestroyImage(xim); + shared_pixmap = 0; + shared_image = 0; + ok = 0; + } + if (ok) + { + id->x.last_shminfo.shmaddr = xim->data = shmat(id->x.last_shminfo.shmid, 0, 0); + + if (xim->data == (char *)-1) + { + fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared XImage\n"); + fprintf(stderr, " Falling back on XImages\n"); + XDestroyImage(xim); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + shared_pixmap = 0; + shared_image = 0; + ok = 0; + } + if (ok) + { + id->x.last_shminfo.readOnly = False; + XShmAttach(id->x.disp, &id->x.last_shminfo); + tmp = (unsigned char *)xim->data; + id->x.last_xim = xim; + pmap = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth); + tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv); + if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0)) + { + sxim = XShmCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, NULL, &id->x.last_sshminfo, w, h); + if (!sxim) + { + fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create Shared XImage mask\n"); + fprintf(stderr, " Falling back on XImages\n"); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(id->x.last_shminfo.shmaddr); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + shared_pixmap = 0; + shared_image = 0; + ok = 0; + } + if (ok) + { + id->x.last_sshminfo.shmid = shmget(IPC_PRIVATE, sxim->bytes_per_line * sxim->height, IPC_CREAT | 0777); + if (id->x.last_sshminfo.shmid == -1) + { + fprintf(stderr, "Imlib ERROR: SHM can't get SHM Identifier for Shared XImage mask\n"); + fprintf(stderr, " Falling back on XImages\n"); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(xim->data); + /* missing shmctl(RMID) */ + XDestroyImage(sxim); + shared_pixmap = 0; + shared_image = 0; + ok = 0; + } + if (ok) + { + id->x.last_sshminfo.shmaddr = sxim->data = shmat(id->x.last_sshminfo.shmid, 0, 0); + if (sxim->data == (char *)-1) + { + fprintf(stderr, "Imlib ERROR: SHM can't attach SHM Segment for Shared XImage mask\n"); + fprintf(stderr, " Falling back on XImages\n"); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(xim->data); + /* missing shmctl(RMID) */ + XDestroyImage(sxim); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + shared_pixmap = 0; + shared_image = 0; + ok = 0; + } + + if (ok) + { + id->x.last_sshminfo.readOnly = False; + XShmAttach(id->x.disp, &id->x.last_sshminfo); + stmp = (unsigned char *)sxim->data; + id->x.last_sxim = sxim; + mask = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1); + stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv); + } + } + } + } + } + } + } + } + ok = 1; + if ((!shared_pixmap) && (!shared_image)) +#endif /* HAVE_SHM */ + { + tmp = (unsigned char *)malloc(w * h * bpp); + if (!tmp) + { + fprintf(stderr, "IMLIB ERROR: Cannot allocate RAM for XImage data\n"); + free(xarray); + free(yarray); + free(error); + return 0; + } + xim = XCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, 0, (char *)tmp, w, h, 8, 0); + if (!xim) + { + fprintf(stderr, "IMLIB ERROR: Cannot allocate XImage buffer\n"); + free(xarray); + free(yarray); + free(error); + free(tmp); + return 0; + } + if (xim->bits_per_pixel != bpp) + xim->data = realloc(xim->data, xim->bytes_per_line * xim->height); + pmap = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth); + if (!pmap) + { + fprintf(stderr, "IMLIB ERROR: Cannot create pixmap\n"); + free(xarray); + free(yarray); + free(error); + XDestroyImage(xim); + return 0; + } + tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv); + if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0)) + { + stmp = (unsigned char *)malloc(((w >> 3) + 8) * h); + if (!stmp) + { + fprintf(stderr, "IMLIB ERROR: Cannot allocate RAM for shape XImage data\n"); + free(xarray); + free(yarray); + free(error); + XDestroyImage(xim); + return 0; + } + sxim = XCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, 0, (char *)stmp, w, h, 8, 0); + if (!sxim) + { + fprintf(stderr, "IMLIB ERROR: Cannot allocate XImage shape buffer\n"); + free(xarray); + free(yarray); + free(error); + free(stmp); + XDestroyImage(xim); + return 0; + } + mask = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1); + if (!mask) + { + fprintf(stderr, "IMLIB ERROR: Cannot create shape pixmap\n"); + free(xarray); + free(yarray); + free(error); + XDestroyImage(sxim); + XDestroyImage(xim); + return 0; + } + stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv); + } + } +/* copy XImage to the pixmap, if not a shared pixmap */ + if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0)) + { + if (!im->map) + { + if (id->x.depth <= 8) + grender_shaped(im, w, h, xim, sxim, er1, er2, xarray, yarray, 8); + else + grender_shaped(im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth); + } + else + { + if (id->x.depth <= 8) + grender_shaped_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray, 8); + else + grender_shaped_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth); + } +#ifdef HAVE_SHM + if (shared_image) + { + XShmPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h, False); + XShmPutImage(id->x.disp, mask, stgc, sxim, 0, 0, 0, 0, w, h, False); + XSync(id->x.disp, False); + im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, pmap); + im->shape_mask = gdk_imlib_pixmap_foreign_new(w, h, 1, mask); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(id->x.last_shminfo.shmaddr); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + XShmDetach(id->x.disp, &id->x.last_sshminfo); + XDestroyImage(sxim); + shmdt(id->x.last_sshminfo.shmaddr); + shmctl(id->x.last_sshminfo.shmid, IPC_RMID, 0); + id->x.last_xim = NULL; + id->x.last_sxim = NULL; + xim = NULL; + sxim = NULL; + XFreeGC(id->x.disp, tgc); + XFreeGC(id->x.disp, stgc); + } + else if (shared_pixmap) + { + Pixmap p2, m2; + + p2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth); + m2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1); + XCopyArea(id->x.disp, pmap, p2, tgc, 0, 0, w, h, 0, 0); + XCopyArea(id->x.disp, mask, m2, stgc, 0, 0, w, h, 0, 0); + im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, p2); + im->shape_mask = gdk_imlib_pixmap_foreign_new(w, h, 1, m2); + XFreeGC(id->x.disp, tgc); + XFreeGC(id->x.disp, stgc); + XFreePixmap(id->x.disp, pmap); + XFreePixmap(id->x.disp, mask); + XSync(id->x.disp, False); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(id->x.last_shminfo.shmaddr); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + XShmDetach(id->x.disp, &id->x.last_sshminfo); + XDestroyImage(sxim); + shmdt(id->x.last_sshminfo.shmaddr); + shmctl(id->x.last_sshminfo.shmid, IPC_RMID, 0); + id->x.last_xim = NULL; + id->x.last_sxim = NULL; + xim = NULL; + sxim = NULL; + } + else +#endif /* HAVE_SHM */ + { + XPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h); + XPutImage(id->x.disp, mask, stgc, sxim, 0, 0, 0, 0, w, h); + im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, pmap); + im->shape_mask = gdk_imlib_pixmap_foreign_new(w, h, 1, mask); + XDestroyImage(xim); + XDestroyImage(sxim); + xim = NULL; + sxim = NULL; + XFreeGC(id->x.disp, tgc); + XFreeGC(id->x.disp, stgc); + } + } + else + { + if (!im->map) + { + if (id->x.depth <= 8) + grender(im, w, h, xim, sxim, er1, er2, xarray, yarray, 8); + else + grender(im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth); + } + else + { + if (id->x.depth <= 8) + grender_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray, 8); + else + grender_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth); + } +#ifdef HAVE_SHM + if (shared_image) + { + XShmPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h, False); + im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, pmap); + im->shape_mask = NULL; + XSync(id->x.disp, False); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(id->x.last_shminfo.shmaddr); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + id->x.last_xim = NULL; + xim = NULL; + sxim = NULL; + XFreeGC(id->x.disp, tgc); + } + else if (shared_pixmap) + { + Pixmap p2; + + p2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth); + XCopyArea(id->x.disp, pmap, p2, tgc, 0, 0, w, h, 0, 0); + im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, p2); + im->shape_mask = NULL; + XFreeGC(id->x.disp, tgc); + XFreePixmap(id->x.disp, pmap); + XSync(id->x.disp, False); + XShmDetach(id->x.disp, &id->x.last_shminfo); + XDestroyImage(xim); + shmdt(id->x.last_shminfo.shmaddr); + shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0); + id->x.last_xim = NULL; + xim = NULL; + sxim = NULL; + } + else +#endif /* HAVE_SHM */ + { + XPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h); + im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, pmap); + im->shape_mask = NULL; + XDestroyImage(xim); + xim = NULL; + sxim = NULL; + XFreeGC(id->x.disp, tgc); + } + } + +/* cleanup */ + XSync(id->x.disp, False); + free(error); + free(xarray); + free(yarray); + +/* add this pixmap to the cache */ + _gdk_imlib_add_pixmap(im, w, h, xim, sxim); + return 1; +} |