#include <X11/Xlibint.h>
#include <X11/Xutil.h>
#include <stdio.h>
#include "ImUtil.h"
static int _XDestroyImage(XImage *);
static unsigned long _XGetPixel(XImage *, int, int);
static unsigned long _XGetPixel1(XImage *, int, int);
static unsigned long _XGetPixel8(XImage *, int, int);
static unsigned long _XGetPixel16(XImage *, int, int);
static unsigned long _XGetPixel32(XImage *, int, int);
static int _XPutPixel(XImage *, int, int, unsigned long);
static int _XPutPixel1(XImage *, int, int, unsigned long);
static int _XPutPixel8(XImage *, int, int, unsigned long);
static int _XPutPixel16(XImage *, int, int, unsigned long);
static int _XPutPixel32(XImage *, int, int, unsigned long);
static XImage *_XSubImage(XImage *, int, int, unsigned int, unsigned int);
static int _XAddPixel(XImage *, long);
static unsigned char const _lomask[0x09] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
static unsigned char const _himask[0x09] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00 };
int
_XGetScanlinePad(
Display *dpy,
int depth)
{
register ScreenFormat *fmt = dpy->pixmap_format;
register int i;
for (i = dpy->nformats + 1; --i; ++fmt)
if (fmt->depth == depth)
return(fmt->scanline_pad);
return(dpy->bitmap_pad);
}
int
_XGetBitsPerPixel(
Display *dpy,
int depth)
{
register ScreenFormat *fmt = dpy->pixmap_format;
register int i;
for (i = dpy->nformats + 1; --i; ++fmt)
if (fmt->depth == depth)
return(fmt->bits_per_pixel);
if (depth <= 4)
return 4;
if (depth <= 8)
return 8;
if (depth <= 16)
return 16;
return 32;
}
static void _xynormalizeimagebits (
register unsigned char *bp,
register XImage *img)
{
register unsigned char c;
if (img->byte_order != img->bitmap_bit_order) {
switch (img->bitmap_unit) {
case 16:
c = *bp;
*bp = *(bp + 1);
*(bp + 1) = c;
break;
case 32:
c = *(bp + 3);
*(bp + 3) = *bp;
*bp = c;
c = *(bp + 2);
*(bp + 2) = *(bp + 1);
*(bp + 1) = c;
break;
}
}
if (img->bitmap_bit_order == MSBFirst)
_XReverse_Bytes (bp, img->bitmap_unit >> 3);
}
static void _znormalizeimagebits (
register unsigned char *bp,
register XImage *img)
{
register unsigned char c;
switch (img->bits_per_pixel) {
case 4:
*bp = ((*bp >> 4) & 0xF) | ((*bp << 4) & ~0xF);
break;
case 16:
c = *bp;
*bp = *(bp + 1);
*(bp + 1) = c;
break;
case 24:
c = *(bp + 2);
*(bp + 2) = *bp;
*bp = c;
break;
case 32:
c = *(bp + 3);
*(bp + 3) = *bp;
*bp = c;
c = *(bp + 2);
*(bp + 2) = *(bp + 1);
*(bp + 1) = c;
break;
}
}
static void _putbits(
register char *src,
int dstoffset,
register int numbits,
register char *dst)
{
register unsigned char chlo, chhi;
int hibits;
dst = dst + (dstoffset >> 3);
dstoffset = dstoffset & 7;
hibits = 8 - dstoffset;
chlo = *dst & _lomask[dstoffset];
for (;;) {
chhi = (*src << dstoffset) & _himask[dstoffset];
if (numbits <= hibits) {
chhi = chhi & _lomask[dstoffset + numbits];
*dst = (*dst & _himask[dstoffset + numbits]) | chlo | chhi;
break;
}
*dst = chhi | chlo;
dst++;
numbits = numbits - hibits;
chlo = (unsigned char) (*src & _himask[hibits]) >> hibits;
src++;
if (numbits <= dstoffset) {
chlo = chlo & _lomask[numbits];
*dst = (*dst & _himask[numbits]) | chlo;
break;
}
numbits = numbits - dstoffset;
}
}
#if defined(Lynx) && defined(ROUNDUP)
#undef ROUNDUP
#endif
#define ROUNDUP(nbytes, pad) ((((nbytes) + ((pad)-1)) / (pad)) * ((pad)>>3))
#define XYNORMALIZE(bp, img) \
if ((img->byte_order == MSBFirst) || (img->bitmap_bit_order == MSBFirst)) \
_xynormalizeimagebits((unsigned char *)(bp), img)
#define ZNORMALIZE(bp, img) \
if (img->byte_order == MSBFirst) \
_znormalizeimagebits((unsigned char *)(bp), img)
#define XYINDEX(x, y, img) \
((y) * img->bytes_per_line) + \
(((x) + img->xoffset) / img->bitmap_unit) * (img->bitmap_unit >> 3)
#define ZINDEX(x, y, img) ((y) * img->bytes_per_line) + \
(((x) * img->bits_per_pixel) >> 3)
void _XInitImageFuncPtrs (
register XImage *image)
{
image->f.create_image = XCreateImage;
image->f.destroy_image = _XDestroyImage;
if ((image->format == ZPixmap) && (image->bits_per_pixel == 8)) {
image->f.get_pixel = _XGetPixel8;
image->f.put_pixel = _XPutPixel8;
} else if (((image->bits_per_pixel | image->depth) == 1) &&
(image->byte_order == image->bitmap_bit_order)) {
image->f.get_pixel = _XGetPixel1;
image->f.put_pixel = _XPutPixel1;
} else if ((image->format == ZPixmap) &&
(image->bits_per_pixel == 32)) {
image->f.get_pixel = _XGetPixel32;
image->f.put_pixel = _XPutPixel32;
} else if ((image->format == ZPixmap) &&
(image->bits_per_pixel == 16)) {
image->f.get_pixel = _XGetPixel16;
image->f.put_pixel = _XPutPixel16;
} else {
image->f.get_pixel = _XGetPixel;
image->f.put_pixel = _XPutPixel;
}
image->f.sub_image = _XSubImage;
image->f.add_pixel = _XAddPixel;
}
XImage *XCreateImage (dpy, visual, depth, format, offset, data, width, height,
xpad, image_bytes_per_line)
register Display *dpy;
register Visual *visual;
unsigned int depth;
int format;
int offset;
char *data;
unsigned int width;
unsigned int height;
int xpad;
int image_bytes_per_line;
{
register XImage *image;
int bits_per_pixel = 1;
if (depth == 0 || depth > 32 ||
(format != XYBitmap && format != XYPixmap && format != ZPixmap) ||
(format == XYBitmap && depth != 1) ||
(xpad != 8 && xpad != 16 && xpad != 32) ||
offset < 0 || image_bytes_per_line < 0)
return (XImage *) NULL;
if ((image = (XImage *) Xcalloc(1, (unsigned) sizeof(XImage))) == NULL)
return (XImage *) NULL;
image->width = width;
image->height = height;
image->format = format;
image->byte_order = dpy->byte_order;
image->bitmap_unit = dpy->bitmap_unit;
image->bitmap_bit_order = dpy->bitmap_bit_order;
if (visual != NULL) {
image->red_mask = visual->red_mask;
image->green_mask = visual->green_mask;
image->blue_mask = visual->blue_mask;
}
else {
image->red_mask = image->green_mask = image->blue_mask = 0;
}
if (format == ZPixmap)
{
bits_per_pixel = _XGetBitsPerPixel(dpy, (int) depth);
}
image->xoffset = offset;
image->bitmap_pad = xpad;
image->depth = depth;
image->data = data;
if (image_bytes_per_line == 0)
{
if (format == ZPixmap)
image->bytes_per_line =
ROUNDUP((bits_per_pixel * width), image->bitmap_pad);
else
image->bytes_per_line =
ROUNDUP((width + offset), image->bitmap_pad);
}
else image->bytes_per_line = image_bytes_per_line;
image->bits_per_pixel = bits_per_pixel;
image->obdata = NULL;
_XInitImageFuncPtrs (image);
return image;
}
Status XInitImage (image)
XImage *image;
{
if (image->depth == 0 || image->depth > 32 ||
(image->format != XYBitmap &&
image->format != XYPixmap &&
image->format != ZPixmap) ||
(image->format == XYBitmap && image->depth != 1) ||
(image->bitmap_pad != 8 &&
image->bitmap_pad != 16 &&
image->bitmap_pad != 32) ||
image->xoffset < 0 || image->bytes_per_line < 0)
return 0;
if (image->bytes_per_line == 0)
{
if (image->format == ZPixmap)
image->bytes_per_line =
ROUNDUP((image->bits_per_pixel * image->width),
image->bitmap_pad);
else
image->bytes_per_line =
ROUNDUP((image->width + image->xoffset), image->bitmap_pad);
}
_XInitImageFuncPtrs (image);
return 1;
}
static int _XDestroyImage (ximage)
XImage *ximage;
{
if (ximage->data != NULL) Xfree((char *)ximage->data);
if (ximage->obdata != NULL) Xfree((char *)ximage->obdata);
Xfree((char *)ximage);
return 1;
}
static unsigned long const low_bits_table[] = {
0x00000000, 0x00000001, 0x00000003, 0x00000007,
0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
0xffffffff
};
static unsigned long _XGetPixel (ximage, x, y)
register XImage *ximage;
int x;
int y;
{
unsigned long pixel, px;
register char *src;
register char *dst;
register int i, j;
int bits, nbytes;
long plane;
if ((ximage->bits_per_pixel | ximage->depth) == 1) {
src = &ximage->data[XYINDEX(x, y, ximage)];
dst = (char *)&pixel;
pixel = 0;
for (i = ximage->bitmap_unit >> 3; --i >= 0; ) *dst++ = *src++;
XYNORMALIZE(&pixel, ximage);
bits = (x + ximage->xoffset) % ximage->bitmap_unit;
pixel = ((((char *)&pixel)[bits>>3])>>(bits&7)) & 1;
} else if (ximage->format == XYPixmap) {
pixel = 0;
plane = 0;
nbytes = ximage->bitmap_unit >> 3;
for (i = ximage->depth; --i >= 0; ) {
src = &ximage->data[XYINDEX(x, y, ximage)+ plane];
dst = (char *)&px;
px = 0;
for (j = nbytes; --j >= 0; ) *dst++ = *src++;
XYNORMALIZE(&px, ximage);
bits = (x + ximage->xoffset) % ximage->bitmap_unit;
pixel = (pixel << 1) |
(((((char *)&px)[bits>>3])>>(bits&7)) & 1);
plane = plane + (ximage->bytes_per_line * ximage->height);
}
} else if (ximage->format == ZPixmap) {
src = &ximage->data[ZINDEX(x, y, ximage)];
dst = (char *)&px;
px = 0;
for (i = (ximage->bits_per_pixel + 7) >> 3; --i >= 0; )
*dst++ = *src++;
ZNORMALIZE(&px, ximage);
pixel = 0;
for (i=sizeof(unsigned long); --i >= 0; )
pixel = (pixel << 8) | ((unsigned char *)&px)[i];
if (ximage->bits_per_pixel == 4) {
if (x & 1)
pixel >>= 4;
else
pixel &= 0xf;
}
} else {
return 0;
}
if (ximage->bits_per_pixel == ximage->depth)
return pixel;
else
return (pixel & low_bits_table[ximage->depth]);
}
#ifndef WORD64
static CARD32 const byteorderpixel = MSBFirst << 24;
#endif
static unsigned long _XGetPixel32 (ximage, x, y)
register XImage *ximage;
int x;
int y;
{
register unsigned char *addr;
unsigned long pixel;
if ((ximage->format == ZPixmap) && (ximage->bits_per_pixel == 32)) {
addr = &((unsigned char *)ximage->data)
[y * ximage->bytes_per_line + (x << 2)];
#ifndef WORD64
if (*((const char *)&byteorderpixel) == ximage->byte_order)
pixel = *((CARD32 *)addr);
else
#endif
if (ximage->byte_order == MSBFirst)
pixel = ((unsigned long)addr[0] << 24 |
(unsigned long)addr[1] << 16 |
(unsigned long)addr[2] << 8 |
addr[3]);
else
pixel = ((unsigned long)addr[3] << 24 |
(unsigned long)addr[2] << 16 |
(unsigned long)addr[1] << 8 |
addr[0]);
if (ximage->depth != 32)
pixel &= low_bits_table[ximage->depth];
return pixel;
} else {
_XInitImageFuncPtrs(ximage);
return XGetPixel(ximage, x, y);
}
}
static unsigned long _XGetPixel16 (ximage, x, y)
register XImage *ximage;
int x;
int y;
{
register unsigned char *addr;
unsigned long pixel;
if ((ximage->format == ZPixmap) && (ximage->bits_per_pixel == 16)) {
addr = &((unsigned char *)ximage->data)
[y * ximage->bytes_per_line + (x << 1)];
if (ximage->byte_order == MSBFirst)
pixel = addr[0] << 8 | addr[1];
else
pixel = addr[1] << 8 | addr[0];
if (ximage->depth != 16)
pixel &= low_bits_table[ximage->depth];
return pixel;
} else {
_XInitImageFuncPtrs(ximage);
return XGetPixel(ximage, x, y);
}
}
static unsigned long _XGetPixel8 (ximage, x, y)
register XImage *ximage;
int x;
int y;
{
unsigned char pixel;
if ((ximage->format == ZPixmap) && (ximage->bits_per_pixel == 8)) {
pixel = ((unsigned char *)ximage->data)
[y * ximage->bytes_per_line + x];
if (ximage->depth != 8)
pixel &= low_bits_table[ximage->depth];
return pixel;
} else {
_XInitImageFuncPtrs(ximage);
return XGetPixel(ximage, x, y);
}
}
static unsigned long _XGetPixel1 (ximage, x, y)
register XImage *ximage;
int x;
int y;
{
unsigned char bit;
int xoff, yoff;
if (((ximage->bits_per_pixel | ximage->depth) == 1) &&
(ximage->byte_order == ximage->bitmap_bit_order)) {
xoff = x + ximage->xoffset;
yoff = y * ximage->bytes_per_line + (xoff >> 3);
xoff &= 7;
if (ximage->bitmap_bit_order == MSBFirst)
bit = 0x80 >> xoff;
else
bit = 1 << xoff;
return (ximage->data[yoff] & bit) ? 1 : 0;
} else {
_XInitImageFuncPtrs(ximage);
return XGetPixel(ximage, x, y);
}
}
static int _XPutPixel (ximage, x, y, pixel)
register XImage *ximage;
int x;
int y;
unsigned long pixel;
{
unsigned long px, npixel;
register char *src;
register char *dst;
register int i;
int j, nbytes;
long plane;
if (ximage->depth == 4)
pixel &= 0xf;
npixel = pixel;
for (i=0, px=pixel; i<sizeof(unsigned long); i++, px>>=8)
((unsigned char *)&pixel)[i] = px;
if ((ximage->bits_per_pixel | ximage->depth) == 1) {
src = &ximage->data[XYINDEX(x, y, ximage)];
dst = (char *)&px;
px = 0;
nbytes = ximage->bitmap_unit >> 3;
for (i = nbytes; --i >= 0; ) *dst++ = *src++;
XYNORMALIZE(&px, ximage);
i = ((x + ximage->xoffset) % ximage->bitmap_unit);
_putbits ((char *)&pixel, i, 1, (char *)&px);
XYNORMALIZE(&px, ximage);
src = (char *) &px;
dst = &ximage->data[XYINDEX(x, y, ximage)];
for (i = nbytes; --i >= 0; ) *dst++ = *src++;
} else if (ximage->format == XYPixmap) {
plane = (ximage->bytes_per_line * ximage->height) *
(ximage->depth - 1);
nbytes = ximage->bitmap_unit >> 3;
for (j = ximage->depth; --j >= 0; ) {
src = &ximage->data[XYINDEX(x, y, ximage) + plane];
dst = (char *) &px;
px = 0;
for (i = nbytes; --i >= 0; ) *dst++ = *src++;
XYNORMALIZE(&px, ximage);
i = ((x + ximage->xoffset) % ximage->bitmap_unit);
_putbits ((char *)&pixel, i, 1, (char *)&px);
XYNORMALIZE(&px, ximage);
src = (char *)&px;
dst = &ximage->data[XYINDEX(x, y, ximage) + plane];
for (i = nbytes; --i >= 0; ) *dst++ = *src++;
npixel = npixel >> 1;
for (i=0, px=npixel; i<sizeof(unsigned long); i++, px>>=8)
((unsigned char *)&pixel)[i] = px;
plane = plane - (ximage->bytes_per_line * ximage->height);
}
} else if (ximage->format == ZPixmap) {
src = &ximage->data[ZINDEX(x, y, ximage)];
dst = (char *)&px;
px = 0;
nbytes = (ximage->bits_per_pixel + 7) >> 3;
for (i = nbytes; --i >= 0; ) *dst++ = *src++;
ZNORMALIZE(&px, ximage);
_putbits ((char *)&pixel,
(x * ximage->bits_per_pixel) & 7,
ximage->bits_per_pixel, (char *)&px);
ZNORMALIZE(&px, ximage);
src = (char *)&px;
dst = &ximage->data[ZINDEX(x, y, ximage)];
for (i = nbytes; --i >= 0; ) *dst++ = *src++;
} else {
return 0;
}
return 1;
}
static int _XPutPixel32 (ximage, x, y, pixel)
register XImage *ximage;
int x;
int y;
unsigned long pixel;
{
unsigned char *addr;
if ((ximage->format == ZPixmap) && (ximage->bits_per_pixel == 32)) {
addr = &((unsigned char *)ximage->data)
[y * ximage->bytes_per_line + (x << 2)];
#ifndef WORD64
if (*((const char *)&byteorderpixel) == ximage->byte_order)
*((CARD32 *)addr) = pixel;
else
#endif
if (ximage->byte_order == MSBFirst) {
addr[0] = pixel >> 24;
addr[1] = pixel >> 16;
addr[2] = pixel >> 8;
addr[3] = pixel;
} else {
addr[3] = pixel >> 24;
addr[2] = pixel >> 16;
addr[1] = pixel >> 8;
addr[0] = pixel;
}
return 1;
} else {
_XInitImageFuncPtrs(ximage);
return XPutPixel(ximage, x, y, pixel);
}
}
static int _XPutPixel16 (ximage, x, y, pixel)
register XImage *ximage;
int x;
int y;
unsigned long pixel;
{
unsigned char *addr;
if ((ximage->format == ZPixmap) && (ximage->bits_per_pixel == 16)) {
addr = &((unsigned char *)ximage->data)
[y * ximage->bytes_per_line + (x << 1)];
if (ximage->byte_order == MSBFirst) {
addr[0] = pixel >> 8;
addr[1] = pixel;
} else {
addr[1] = pixel >> 8;
addr[0] = pixel;
}
return 1;
} else {
_XInitImageFuncPtrs(ximage);
return XPutPixel(ximage, x, y, pixel);
}
}
static int _XPutPixel8 (ximage, x, y, pixel)
register XImage *ximage;
int x;
int y;
unsigned long pixel;
{
if ((ximage->format == ZPixmap) && (ximage->bits_per_pixel == 8)) {
ximage->data[y * ximage->bytes_per_line + x] = pixel;
return 1;
} else {
_XInitImageFuncPtrs(ximage);
return XPutPixel(ximage, x, y, pixel);
}
}
static int _XPutPixel1 (ximage, x, y, pixel)
register XImage *ximage;
int x;
int y;
unsigned long pixel;
{
unsigned char bit;
int xoff, yoff;
if (((ximage->bits_per_pixel | ximage->depth) == 1) &&
(ximage->byte_order == ximage->bitmap_bit_order)) {
xoff = x + ximage->xoffset;
yoff = y * ximage->bytes_per_line + (xoff >> 3);
xoff &= 7;
if (ximage->bitmap_bit_order == MSBFirst)
bit = 0x80 >> xoff;
else
bit = 1 << xoff;
if (pixel & 1)
ximage->data[yoff] |= bit;
else
ximage->data[yoff] &= ~bit;
return 1;
} else {
_XInitImageFuncPtrs(ximage);
return XPutPixel(ximage, x, y, pixel);
}
}
static XImage *_XSubImage (ximage, x, y, width, height)
XImage *ximage;
register int x;
register int y;
unsigned int width;
unsigned int height;
{
register XImage *subimage;
int dsize;
register int row, col;
register unsigned long pixel;
char *data;
if ((subimage = (XImage *) Xcalloc (1, sizeof (XImage))) == NULL)
return (XImage *) NULL;
subimage->width = width;
subimage->height = height;
subimage->xoffset = 0;
subimage->format = ximage->format;
subimage->byte_order = ximage->byte_order;
subimage->bitmap_unit = ximage->bitmap_unit;
subimage->bitmap_bit_order = ximage->bitmap_bit_order;
subimage->bitmap_pad = ximage->bitmap_pad;
subimage->bits_per_pixel = ximage->bits_per_pixel;
subimage->depth = ximage->depth;
if (subimage->format == ZPixmap)
subimage->bytes_per_line =
ROUNDUP(subimage->bits_per_pixel * width,
subimage->bitmap_pad);
else
subimage->bytes_per_line =
ROUNDUP(width, subimage->bitmap_pad);
subimage->obdata = NULL;
_XInitImageFuncPtrs (subimage);
dsize = subimage->bytes_per_line * height;
if (subimage->format == XYPixmap) dsize = dsize * subimage->depth;
if (((data = Xcalloc (1, (unsigned) dsize)) == NULL) && (dsize > 0)) {
Xfree((char *) subimage);
return (XImage *) NULL;
}
subimage->data = data;
if (height > ximage->height - y ) height = ximage->height - y;
if (width > ximage->width - x ) width = ximage->width - x;
for (row = y; row < (y + height); row++) {
for (col = x; col < (x + width); col++) {
pixel = XGetPixel(ximage, col, row);
XPutPixel(subimage, (col - x), (row - y), pixel);
}
}
return subimage;
}
int _XSetImage(
XImage *srcimg,
register XImage *dstimg,
register int x,
register int y)
{
register unsigned long pixel;
register int row, col;
int width, height, startrow, startcol;
if (x < 0) {
startcol = -x;
x = 0;
} else
startcol = 0;
if (y < 0) {
startrow = -y;
y = 0;
} else
startrow = 0;
width = dstimg->width - x;
if (srcimg->width < width)
width = srcimg->width;
height = dstimg->height - y;
if (srcimg->height < height)
height = srcimg->height;
for (row = startrow; row < height; row++) {
for (col = startcol; col < width; col++) {
pixel = XGetPixel(srcimg, col, row);
XPutPixel(dstimg, x + col, y + row, pixel);
}
}
return 1;
}
static int
_XAddPixel (ximage, value)
register XImage *ximage;
register long value;
{
register int x;
register int y;
if (!value)
return 0;
if ((ximage->bits_per_pixel | ximage->depth) == 1) {
register unsigned char *dp = (unsigned char *) ximage->data;
x = ximage->bytes_per_line * ximage->height;
while (--x >= 0) {
*dp = ~*dp;
dp++;
}
} else if ((ximage->format == ZPixmap) &&
(ximage->bits_per_pixel == 8)) {
register unsigned char *dp = (unsigned char *) ximage->data;
x = ximage->bytes_per_line * ximage->height;
while (--x >= 0)
*dp++ += value;
#ifndef WORD64
} else if ((ximage->format == ZPixmap) &&
(ximage->bits_per_pixel == 16) &&
(*((const char *)&byteorderpixel) == ximage->byte_order)) {
register unsigned short *dp = (unsigned short *) ximage->data;
x = (ximage->bytes_per_line >> 1) * ximage->height;
while (--x >= 0)
*dp++ += value;
} else if ((ximage->format == ZPixmap) &&
(ximage->bits_per_pixel == 32) &&
(*((const char *)&byteorderpixel) == ximage->byte_order)) {
register CARD32 *dp = (CARD32 *) ximage->data;
x = (ximage->bytes_per_line >> 2) * ximage->height;
while (--x >= 0)
*dp++ += value;
#endif
} else {
for (y = ximage->height; --y >= 0; ) {
for (x = ximage->width; --x >= 0; ) {
register unsigned long pixel = XGetPixel(ximage, x, y);
pixel = pixel + value;
XPutPixel(ximage, x, y, pixel);
}
}
}
return 0;
}