aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/X11/ImUtil.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/X11/ImUtil.c')
-rw-r--r--nx-X11/lib/X11/ImUtil.c1032
1 files changed, 1032 insertions, 0 deletions
diff --git a/nx-X11/lib/X11/ImUtil.c b/nx-X11/lib/X11/ImUtil.c
new file mode 100644
index 000000000..9e667bb9c
--- /dev/null
+++ b/nx-X11/lib/X11/ImUtil.c
@@ -0,0 +1,1032 @@
+/* $Xorg: ImUtil.c,v 1.4 2001/02/09 02:03:34 xorgcvs Exp $ */
+/*
+
+Copyright 1986, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/* $XFree86: xc/lib/X11/ImUtil.c,v 3.12 2003/04/15 22:10:06 herrb Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#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 };
+
+/* These two convenience routines return the scanline_pad and bits_per_pixel
+ associated with a specific depth of ZPixmap format image for a
+ display. */
+
+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;
+ }
+
+
+/*
+ * This module provides rudimentary manipulation routines for image data
+ * structures. The functions provided are:
+ *
+ * XCreateImage Creates a default XImage data structure
+ * _XDestroyImage Deletes an XImage data structure
+ * _XGetPixel Reads a pixel from an image data structure
+ * _XGetPixel32 Reads a pixel from a 32-bit Z image data structure
+ * _XGetPixel16 Reads a pixel from a 16-bit Z image data structure
+ * _XGetPixel8 Reads a pixel from an 8-bit Z image data structure
+ * _XGetPixel1 Reads a pixel from an 1-bit image data structure
+ * _XPutPixel Writes a pixel into an image data structure
+ * _XPutPixel32 Writes a pixel into a 32-bit Z image data structure
+ * _XPutPixel16 Writes a pixel into a 16-bit Z image data structure
+ * _XPutPixel8 Writes a pixel into an 8-bit Z image data structure
+ * _XPutPixel1 Writes a pixel into an 1-bit image data structure
+ * _XSubImage Clones a new (sub)image from an existing one
+ * _XSetImage Writes an image data pattern into another image
+ * _XAddPixel Adds a constant value to every pixel in an image
+ *
+ * The logic contained in these routines makes several assumptions about
+ * the image data structures, and at least for current implementations
+ * these assumptions are believed to be true. They are:
+ *
+ * For all formats, bits_per_pixel is less than or equal to 32.
+ * For XY formats, bitmap_unit is always less than or equal to bitmap_pad.
+ * For XY formats, bitmap_unit is 8, 16, or 32 bits.
+ * For Z format, bits_per_pixel is 1, 4, 8, 16, 24, or 32 bits.
+ */
+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, /* address of source bit string */
+ int dstoffset, /* bit offset into destination; range is 0-31 */
+ register int numbits,/* number of bits to copy to destination */
+ register char *dst) /* address of destination bit string */
+{
+ 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;
+ }
+}
+
+
+/*
+ * Macros
+ *
+ * The ROUNDUP macro rounds up a quantity to the specified boundary,
+ * then truncates to bytes.
+ *
+ * The XYNORMALIZE macro determines whether XY format data requires
+ * normalization and calls a routine to do so if needed. The logic in
+ * this module is designed for LSBFirst byte and bit order, so
+ * normalization is done as required to present the data in this order.
+ *
+ * The ZNORMALIZE macro performs byte and nibble order normalization if
+ * required for Z format data.
+ *
+ * The XYINDEX macro computes the index to the starting byte (char) boundary
+ * for a bitmap_unit containing a pixel with coordinates x and y for image
+ * data in XY format.
+ *
+ * The ZINDEX macro computes the index to the starting byte (char) boundary
+ * for a pixel with coordinates x and y for image data in ZPixmap format.
+ *
+ */
+
+#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)
+
+/*
+ * This routine initializes the image object function pointers. The
+ * intent is to provide native (i.e. fast) routines for native format images
+ * only using the generic (i.e. slow) routines when fast ones don't exist.
+ * However, with the current rather botched external interface, clients may
+ * have to mung image attributes after the image gets created, so the fast
+ * routines always have to check to make sure the optimization is still
+ * valid, and reinit the functions if not.
+ */
+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.set_image = _XSetImage;*/
+ image->f.add_pixel = _XAddPixel;
+}
+
+/*
+ * CreateImage
+ *
+ * Allocates the memory necessary for an XImage data structure.
+ * Initializes the structure with "default" values and returns XImage.
+ *
+ */
+
+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; /*How many pixels from the start of the data does the
+ picture to be transmitted start?*/
+
+ char *data;
+ unsigned int width;
+ unsigned int height;
+ int xpad;
+ int image_bytes_per_line;
+ /*How many bytes between a pixel on one line and the pixel with
+ the same X coordinate on the next line? 0 means
+ XCreateImage can calculate it.*/
+{
+ register XImage *image;
+ int bits_per_pixel = 1;
+ int min_bytes_per_line;
+
+ if (depth == 0 || depth > 32 ||
+ (format != XYBitmap && format != XYPixmap && format != ZPixmap) ||
+ (format == XYBitmap && depth != 1) ||
+ (xpad != 8 && xpad != 16 && xpad != 32) ||
+ offset < 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;
+ /*
+ * compute per line accelerator.
+ */
+ {
+ if (format == ZPixmap)
+ min_bytes_per_line =
+ ROUNDUP((bits_per_pixel * width), image->bitmap_pad);
+ else
+ min_bytes_per_line =
+ ROUNDUP((width + offset), image->bitmap_pad);
+ }
+ if (image_bytes_per_line == 0) {
+ image->bytes_per_line = min_bytes_per_line;
+ } else if (image_bytes_per_line < min_bytes_per_line) {
+ return 0;
+ } 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;
+{
+ int min_bytes_per_line;
+
+ if (image->depth == 0 || image->depth > 32 ||
+ image->bits_per_pixel > 32 || image->bitmap_unit > 32 ||
+ image->bits_per_pixel < 0 || image->bitmap_unit < 0 ||
+ (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)
+ return 0;
+
+ /*
+ * compute per line accelerator.
+ */
+ if (image->format == ZPixmap)
+ min_bytes_per_line =
+ ROUNDUP((image->bits_per_pixel * image->width),
+ image->bitmap_pad);
+ else
+ min_bytes_per_line =
+ ROUNDUP((image->width + image->xoffset), image->bitmap_pad);
+
+ if (image->bytes_per_line == 0) {
+ image->bytes_per_line = min_bytes_per_line;
+ } else if (image->bytes_per_line < min_bytes_per_line) {
+ return 0;
+ }
+
+ _XInitImageFuncPtrs (image);
+
+ return 1;
+}
+
+/*
+ * _DestroyImage
+ *
+ * Deallocates the memory associated with the ximage data structure.
+ * this version handles the case of the image data being malloc'd
+ * entirely by the library.
+ */
+
+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;
+}
+
+
+/*
+ * GetPixel
+ *
+ * Returns the specified pixel. The X and Y coordinates are relative to
+ * the origin (upper left [0,0]) of the image. The pixel value is returned
+ * in normalized format, i.e. the LSB of the long is the LSB of the pixel.
+ * The algorithm used is:
+ *
+ * copy the source bitmap_unit or Zpixel into temp
+ * normalize temp if needed
+ * extract the pixel bits into return value
+ *
+ */
+
+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; /* bad image */
+ }
+ 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);
+ }
+}
+
+/*
+ * PutPixel
+ *
+ * Overwrites the specified pixel. The X and Y coordinates are relative to
+ * the origin (upper left [0,0]) of the image. The input pixel value must be
+ * in normalized format, i.e. the LSB of the long is the LSB of the pixel.
+ * The algorithm used is:
+ *
+ * copy the destination bitmap_unit or Zpixel to temp
+ * normalize temp if needed
+ * copy the pixel bits into the temp
+ * renormalize temp if needed
+ * copy the temp back into the destination image data
+ *
+ */
+
+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); /* do least signif plane 1st */
+ 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; /* bad image */
+ }
+ 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);
+ }
+}
+
+/*
+ * SubImage
+ *
+ * Creates a new image that is a subsection of an existing one.
+ * Allocates the memory necessary for the new XImage data structure.
+ * Pointer to new image is returned. The algorithm used is repetitive
+ * calls to get and put pixel.
+ *
+ */
+
+static XImage *_XSubImage (ximage, x, y, width, height)
+ XImage *ximage;
+ register int x; /* starting x coordinate in existing image */
+ register int y; /* starting y coordinate in existing image */
+ unsigned int width; /* width in pixels of new subimage */
+ unsigned int height;/* height in pixels of new subimage */
+
+{
+ 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;
+ /*
+ * compute per line accelerator.
+ */
+ 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;
+
+ /*
+ * Test for cases where the new subimage is larger than the region
+ * that we are copying from the existing data. In those cases,
+ * copy the area of the existing image, and allow the "uncovered"
+ * area of new subimage to remain with zero filled pixels.
+ */
+ 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;
+}
+
+
+/*
+ * SetImage
+ *
+ * Overwrites a section of one image with all of the data from another.
+ * If the two images are not of the same format (i.e. XYPixmap and ZPixmap),
+ * the image data is converted to the destination format. The following
+ * restrictions apply:
+ *
+ * 1. The depths of the source and destination images must be equal.
+ *
+ * 2. If the height of the source image is too large to fit between
+ * the specified y starting point and the bottom of the image,
+ * then scanlines are truncated on the bottom.
+ *
+ * 3. If the width of the source image is too large to fit between
+ * the specified x starting point and the end of the scanline,
+ * then pixels are truncated on the right.
+ *
+ * The images need not have the same bitmap_bit_order, byte_order,
+ * bitmap_unit, bits_per_pixel, bitmap_pad, or xoffset.
+ *
+ */
+
+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;
+
+ /* this is slow, will do better later */
+ 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;
+}
+
+/*
+ * AddPixel
+ *
+ * Adds a constant value to every pixel in a pixmap.
+ *
+ */
+
+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) {
+ /* The only value that we can add here to an XYBitmap
+ * is one. Since 1 + value = ~value for one bit wide
+ * data, we do this quickly by taking the ones complement
+ * of the entire bitmap data (offset and pad included!).
+ * Note that we don't need to be concerned with bit or
+ * byte order at all.
+ */
+ 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;
+}
+