Initial commit of the built-in libgd based on GD-2.0.1

This initial checkin has no changes to any of the libgd code so it can
be used as a basis for diffs.  It also will not build currently because
of this.  The PHP gd checks need to be incorporated along with a bit of
other config magic.  It also shouldn't break the build and will only
take effect if you use --with-gd=php right now.

1 files changed, 2526 insertions, 0 deletions

diff --git a/ext/gd/libgd/gd.c b/ext/gd/libgd/gd.c
new file mode 100644
index 0000000000..36413512d6
--- /dev/null
+++ b/ext/gd/libgd/gd.c
@@ -0,0 +1,2526 @@
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include <zlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+#ifdef _OSD_POSIX		/* BS2000 uses the EBCDIC char set instead of ASCII */
+#define CHARSET_EBCDIC
+#define __attribute__(any)	/*nothing */
+#endif
+/*_OSD_POSIX*/
+
+#ifndef CHARSET_EBCDIC
+#define ASC(ch)  ch
+#else /*CHARSET_EBCDIC */
+#define ASC(ch) gd_toascii[(unsigned char)ch]
+static const unsigned char gd_toascii[256] =
+{
+/*00 */ 0x00, 0x01, 0x02, 0x03, 0x85, 0x09, 0x86, 0x7f,
+  0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,	/*................ */
+/*10 */ 0x10, 0x11, 0x12, 0x13, 0x8f, 0x0a, 0x08, 0x97,
+  0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f,	/*................ */
+/*20 */ 0x80, 0x81, 0x82, 0x83, 0x84, 0x92, 0x17, 0x1b,
+  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07,	/*................ */
+/*30 */ 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04,
+  0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a,	/*................ */
+/*40 */ 0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1, 0xe3, 0xe5,
+  0xe7, 0xf1, 0x60, 0x2e, 0x3c, 0x28, 0x2b, 0x7c,	/* .........`.<(+| */
+/*50 */ 0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef,
+  0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x9f,	/*&.........!$*);. */
+/*60 */ 0x2d, 0x2f, 0xc2, 0xc4, 0xc0, 0xc1, 0xc3, 0xc5,
+  0xc7, 0xd1, 0x5e, 0x2c, 0x25, 0x5f, 0x3e, 0x3f,
+/*-/........^,%_>?*/
+/*70 */ 0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf,
+  0xcc, 0xa8, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22,	/*..........:#@'=" */
+/*80 */ 0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+  0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1,	/*.abcdefghi...... */
+/*90 */ 0xb0, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
+  0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4,	/*.jklmnopqr...... */
+/*a0 */ 0xb5, 0xaf, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+  0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0xdd, 0xde, 0xae,	/*..stuvwxyz...... */
+/*b0 */ 0xa2, 0xa3, 0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc,
+  0xbd, 0xbe, 0xac, 0x5b, 0x5c, 0x5d, 0xb4, 0xd7,	/*...........[\].. */
+/*c0 */ 0xf9, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+  0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5,	/*.ABCDEFGHI...... */
+/*d0 */ 0xa6, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
+  0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xdb, 0xfa, 0xff,	/*.JKLMNOPQR...... */
+/*e0 */ 0xd9, 0xf7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+  0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5,	/*..STUVWXYZ...... */
+/*f0 */ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+  0x38, 0x39, 0xb3, 0x7b, 0xdc, 0x7d, 0xda, 0x7e	/*0123456789.{.}.~ */
+};
+#endif /*CHARSET_EBCDIC */
+
+extern int gdCosT[];
+extern int gdSinT[];
+
+static void gdImageBrushApply (gdImagePtr im, int x, int y);
+static void gdImageTileApply (gdImagePtr im, int x, int y);
+
+gdImagePtr
+gdImageCreate (int sx, int sy)
+{
+  int i;
+  gdImagePtr im;
+  im = (gdImage *) gdMalloc (sizeof (gdImage));
+  memset (im, 0, sizeof (gdImage));
+  /* Row-major ever since gd 1.3 */
+  im->pixels = (unsigned char **) gdMalloc (sizeof (unsigned char *) * sy);
+  im->polyInts = 0;
+  im->polyAllocated = 0;
+  im->brush = 0;
+  im->tile = 0;
+  im->style = 0;
+  for (i = 0; (i < sy); i++)
+    {
+      /* Row-major ever since gd 1.3 */
+      im->pixels[i] = (unsigned char *) gdCalloc (
+						sx, sizeof (unsigned char));
+    }
+  im->sx = sx;
+  im->sy = sy;
+  im->colorsTotal = 0;
+  im->transparent = (-1);
+  im->interlace = 0;
+  im->thick = 1;
+  for (i = 0; (i < gdMaxColors); i++)
+    {
+      im->open[i] = 1;
+      im->red[i] = 0;
+      im->green[i] = 0;
+      im->blue[i] = 0;
+    };
+  im->trueColor = 0;
+  im->tpixels = 0;
+  return im;
+}
+
+gdImagePtr
+gdImageCreateTrueColor (int sx, int sy)
+{
+  int i;
+  gdImagePtr im;
+  im = (gdImage *) gdMalloc (sizeof (gdImage));
+  memset (im, 0, sizeof (gdImage));
+  im->tpixels = (int **) gdMalloc (sizeof (int *) * sy);
+  im->polyInts = 0;
+  im->polyAllocated = 0;
+  im->brush = 0;
+  im->tile = 0;
+  im->style = 0;
+  for (i = 0; (i < sy); i++)
+    {
+      im->tpixels[i] = (int *) gdCalloc (
+					  sx, sizeof (int));
+    }
+  im->sx = sx;
+  im->sy = sy;
+  im->transparent = (-1);
+  im->interlace = 0;
+  im->trueColor = 1;
+  im->saveAlphaFlag = 1;
+  im->alphaBlendingFlag = 0;
+  im->thick = 1;
+  return im;
+}
+
+void
+gdImageDestroy (gdImagePtr im)
+{
+  int i;
+  if (im->pixels)
+    {
+      for (i = 0; (i < im->sy); i++)
+	{
+	  gdFree (im->pixels[i]);
+	}
+      gdFree (im->pixels);
+    }
+  if (im->tpixels)
+    {
+      for (i = 0; (i < im->sy); i++)
+	{
+	  gdFree (im->tpixels[i]);
+	}
+      gdFree (im->tpixels);
+    }
+  if (im->polyInts)
+    {
+      gdFree (im->polyInts);
+    }
+  if (im->style)
+    {
+      gdFree (im->style);
+    }
+  gdFree (im);
+}
+
+int
+gdImageColorClosest (gdImagePtr im, int r, int g, int b)
+{
+  return gdImageColorClosestAlpha (im, r, g, b, gdAlphaOpaque);
+}
+
+int
+gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a)
+{
+  int i;
+  long rd, gd, bd, ad;
+  int ct = (-1);
+  int first = 1;
+  long mindist = 0;
+  if (im->trueColor)
+    {
+      return gdTrueColorAlpha (r, g, b, a);
+    }
+  for (i = 0; (i < (im->colorsTotal)); i++)
+    {
+      long dist;
+      if (im->open[i])
+	{
+	  continue;
+	}
+      rd = (im->red[i] - r);
+      gd = (im->green[i] - g);
+      bd = (im->blue[i] - b);
+      ad = (im->blue[i] - b);
+      dist = rd * rd + gd * gd + bd * bd + ad * ad;
+      if (first || (dist < mindist))
+	{
+	  mindist = dist;
+	  ct = i;
+	  first = 0;
+	}
+    }
+  return ct;
+}
+
+/* This code is taken from http://www.acm.org/jgt/papers/SmithLyons96/hwb_rgb.html, an article
+ * on colour conversion to/from RBG and HWB colour systems. 
+ * It has been modified to return the converted value as a * parameter. 
+ */
+
+#define RETURN_HWB(h, w, b) {HWB->H = h; HWB->W = w; HWB->B = b; return HWB;}
+#define RETURN_RGB(r, g, b) {RGB->R = r; RGB->G = g; RGB->B = b; return RGB;}
+#define HWB_UNDEFINED -1
+#define SETUP_RGB(s, r, g, b) {s.R = r/255.0; s.G = g/255.0; s.B = b/255.0;}
+
+#define MIN(a,b) ((a)<(b)?(a):(b))
+#define MIN3(a,b,c) ((a)<(b)?(MIN(a,c)):(MIN(b,c)))
+#define MAX(a,b) ((a)<(b)?(b):(a))
+#define MAX3(a,b,c) ((a)<(b)?(MAX(b,c)):(MAX(a,c)))
+
+
+/*
+ * Theoretically, hue 0 (pure red) is identical to hue 6 in these transforms. Pure 
+ * red always maps to 6 in this implementation. Therefore UNDEFINED can be 
+ * defined as 0 in situations where only unsigned numbers are desired.
+ */
+typedef struct
+{
+  float R, G, B;
+}
+RGBType;
+typedef struct
+  {
+    float H, W, B;
+  }
+HWBType;
+
+static HWBType *
+RGB_to_HWB (RGBType RGB, HWBType * HWB)
+{
+
+  /*
+   * RGB are each on [0, 1]. W and B are returned on [0, 1] and H is  
+   * returned on [0, 6]. Exception: H is returned UNDEFINED if W == 1 - B.  
+   */
+
+  float R = RGB.R, G = RGB.G, B = RGB.B, w, v, b, f;
+  int i;
+
+  w = MIN3 (R, G, B);
+  v = MAX3 (R, G, B);
+  b = 1 - v;
+  if (v == w)
+    RETURN_HWB (HWB_UNDEFINED, w, b);
+  f = (R == w) ? G - B : ((G == w) ? B - R : R - G);
+  i = (R == w) ? 3 : ((G == w) ? 5 : 1);
+  RETURN_HWB (i - f / (v - w), w, b);
+
+}
+
+static float
+HWB_Diff (int r1, int g1, int b1, int r2, int g2, int b2)
+{
+  RGBType RGB1, RGB2;
+  HWBType HWB1, HWB2;
+  float diff;
+
+  SETUP_RGB (RGB1, r1, g1, b1);
+  SETUP_RGB (RGB2, r2, g2, b2);
+
+  RGB_to_HWB (RGB1, &HWB1);
+  RGB_to_HWB (RGB2, &HWB2);
+
+  /*
+   * I made this bit up; it seems to produce OK results, and it is certainly
+   * more visually correct than the current RGB metric. (PJW)
+   */
+
+  if ((HWB1.H == HWB_UNDEFINED) || (HWB2.H == HWB_UNDEFINED))
+    {
+      diff = 0;			/* Undefined hues always match... */
+    }
+  else
+    {
+      diff = abs (HWB1.H - HWB2.H);
+      if (diff > 3)
+	{
+	  diff = 6 - diff;	/* Remember, it's a colour circle */
+	}
+    }
+
+  diff = diff * diff + (HWB1.W - HWB2.W) * (HWB1.W - HWB2.W) + (HWB1.B - HWB2.B) * (HWB1.B - HWB2.B);
+
+  return diff;
+}
+
+
+/*
+ * This is not actually used, but is here for completeness, in case someone wants to
+ * use the HWB stuff for anything else...
+ */
+static RGBType *
+HWB_to_RGB (HWBType HWB, RGBType * RGB)
+{
+
+  /* 
+   * H is given on [0, 6] or UNDEFINED. W and B are given on [0, 1].  
+   * RGB are each returned on [0, 1]. 
+   */
+
+  float h = HWB.H, w = HWB.W, b = HWB.B, v, n, f;
+  int i;
+
+  v = 1 - b;
+  if (h == HWB_UNDEFINED)
+    RETURN_RGB (v, v, v);
+  i = floor (h);
+  f = h - i;
+  if (i & 1)
+    f = 1 - f;			/* if i is odd */
+  n = w + f * (v - w);		/* linear interpolation between w and v */
+  switch (i)
+    {
+    case 6:
+    case 0:
+      RETURN_RGB (v, n, w);
+    case 1:
+      RETURN_RGB (n, v, w);
+    case 2:
+      RETURN_RGB (w, v, n);
+    case 3:
+      RETURN_RGB (w, n, v);
+    case 4:
+      RETURN_RGB (n, w, v);
+    case 5:
+      RETURN_RGB (v, w, n);
+    }
+
+  return RGB;
+
+}
+
+int
+gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b)
+{
+  int i;
+  /* long rd, gd, bd; */
+  int ct = (-1);
+  int first = 1;
+  float mindist = 0;
+  if (im->trueColor)
+    {
+      return gdTrueColor (r, g, b);
+    }
+  for (i = 0; (i < (im->colorsTotal)); i++)
+    {
+      float dist;
+      if (im->open[i])
+	{
+	  continue;
+	}
+      dist = HWB_Diff (im->red[i], im->green[i], im->blue[i], r, g, b);
+      if (first || (dist < mindist))
+	{
+	  mindist = dist;
+	  ct = i;
+	  first = 0;
+	}
+    }
+  return ct;
+}
+
+int
+gdImageColorExact (gdImagePtr im, int r, int g, int b)
+{
+  return gdImageColorExactAlpha (im, r, g, b, gdAlphaOpaque);
+}
+
+int
+gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a)
+{
+  int i;
+  if (im->trueColor)
+    {
+      return gdTrueColorAlpha (r, g, b, a);
+    }
+  for (i = 0; (i < (im->colorsTotal)); i++)
+    {
+      if (im->open[i])
+	{
+	  continue;
+	}
+      if ((im->red[i] == r) &&
+	  (im->green[i] == g) &&
+	  (im->blue[i] == b) &&
+	  (im->alpha[i] == a))
+	{
+	  return i;
+	}
+    }
+  return -1;
+}
+
+int
+gdImageColorAllocate (gdImagePtr im, int r, int g, int b)
+{
+  return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque);
+}
+
+int
+gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a)
+{
+  int i;
+  int ct = (-1);
+  if (im->trueColor)
+    {
+      return gdTrueColorAlpha (r, g, b, a);
+    }
+  for (i = 0; (i < (im->colorsTotal)); i++)
+    {
+      if (im->open[i])
+	{
+	  ct = i;
+	  break;
+	}
+    }
+  if (ct == (-1))
+    {
+      ct = im->colorsTotal;
+      if (ct == gdMaxColors)
+	{
+	  return -1;
+	}
+      im->colorsTotal++;
+    }
+  im->red[ct] = r;
+  im->green[ct] = g;
+  im->blue[ct] = b;
+  im->alpha[ct] = a;
+  im->open[ct] = 0;
+  return ct;
+}
+
+/*
+ * gdImageColorResolve is an alternative for the code fragment:
+ *
+ *      if ((color=gdImageColorExact(im,R,G,B)) < 0)
+ *        if ((color=gdImageColorAllocate(im,R,G,B)) < 0)
+ *          color=gdImageColorClosest(im,R,G,B);
+ *
+ * in a single function.    Its advantage is that it is guaranteed to
+ * return a color index in one search over the color table.
+ */
+
+int
+gdImageColorResolve (gdImagePtr im, int r, int g, int b)
+{
+  return gdImageColorResolveAlpha (im, r, g, b, gdAlphaOpaque);
+}
+
+int
+gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a)
+{
+  int c;
+  int ct = -1;
+  int op = -1;
+  long rd, gd, bd, ad, dist;
+  long mindist = 4 * 255 * 255;	/* init to max poss dist */
+  if (im->trueColor)
+    {
+      return gdTrueColorAlpha (r, g, b, a);
+    }
+
+  for (c = 0; c < im->colorsTotal; c++)
+    {
+      if (im->open[c])
+	{
+	  op = c;		/* Save open slot */
+	  continue;		/* Color not in use */
+	}
+      rd = (long) (im->red[c] - r);
+      gd = (long) (im->green[c] - g);
+      bd = (long) (im->blue[c] - b);
+      ad = (long) (im->alpha[c] - a);
+      dist = rd * rd + gd * gd + bd * bd + ad * ad;
+      if (dist < mindist)
+	{
+	  if (dist == 0)
+	    {
+	      return c;		/* Return exact match color */
+	    }
+	  mindist = dist;
+	  ct = c;
+	}
+    }
+  /* no exact match.  We now know closest, but first try to allocate exact */
+  if (op == -1)
+    {
+      op = im->colorsTotal;
+      if (op == gdMaxColors)
+	{			/* No room for more colors */
+	  return ct;		/* Return closest available color */
+	}
+      im->colorsTotal++;
+    }
+  im->red[op] = r;
+  im->green[op] = g;
+  im->blue[op] = b;
+  im->alpha[op] = a;
+  im->open[op] = 0;
+  return op;			/* Return newly allocated color */
+}
+
+void
+gdImageColorDeallocate (gdImagePtr im, int color)
+{
+  if (im->trueColor)
+    {
+      return;
+    }
+  /* Mark it open. */
+  im->open[color] = 1;
+}
+
+void
+gdImageColorTransparent (gdImagePtr im, int color)
+{
+  if (!im->trueColor)
+    {
+      if (im->transparent != -1)
+	{
+	  im->alpha[im->transparent] = gdAlphaOpaque;
+	}
+      if (color != -1)
+	{
+	  im->alpha[color] = gdAlphaTransparent;
+	}
+    }
+  im->transparent = color;
+}
+
+void
+gdImagePaletteCopy (gdImagePtr to, gdImagePtr from)
+{
+  int i;
+  int x, y, p;
+  int xlate[256];
+  if (to->trueColor)
+    {
+      return;
+    }
+  if (from->trueColor)
+    {
+      return;
+    }
+
+  for (i = 0; i < 256; i++)
+    {
+      xlate[i] = -1;
+    };
+
+  for (x = 0; x < (to->sx); x++)
+    {
+      for (y = 0; y < (to->sy); y++)
+	{
+	  p = gdImageGetPixel (to, x, y);
+	  if (xlate[p] == -1)
+	    {
+	      /* This ought to use HWB, but we don't have an alpha-aware
+	         version of that yet. */
+	      xlate[p] = gdImageColorClosestAlpha (from, to->red[p], to->green[p], to->blue[p], to->alpha[p]);
+	      /*printf("Mapping %d (%d, %d, %d, %d) to %d (%d, %d, %d, %d)\n", */
+	      /*      p,  to->red[p], to->green[p], to->blue[p], to->alpha[p], */
+	      /*      xlate[p], from->red[xlate[p]], from->green[xlate[p]], from->blue[xlate[p]], from->alpha[xlate[p]]); */
+	    };
+	  gdImageSetPixel (to, x, y, xlate[p]);
+	};
+    };
+
+  for (i = 0; (i < (from->colorsTotal)); i++)
+    {
+      /*printf("Copying color %d (%d, %d, %d, %d)\n", i, from->red[i], from->blue[i], from->green[i], from->alpha[i]); */
+      to->red[i] = from->red[i];
+      to->blue[i] = from->blue[i];
+      to->green[i] = from->green[i];
+      to->alpha[i] = from->alpha[i];
+      to->open[i] = 0;
+    };
+
+  for (i = from->colorsTotal; (i < to->colorsTotal); i++)
+    {
+      to->open[i] = 1;
+    };
+
+  to->colorsTotal = from->colorsTotal;
+
+}
+
+void
+gdImageSetPixel (gdImagePtr im, int x, int y, int color)
+{
+  int p;
+  switch (color)
+    {
+    case gdStyled:
+      if (!im->style)
+	{
+	  /* Refuse to draw if no style is set. */
+	  return;
+	}
+      else
+	{
+	  p = im->style[im->stylePos++];
+	}
+      if (p != (gdTransparent))
+	{
+	  gdImageSetPixel (im, x, y, p);
+	}
+      im->stylePos = im->stylePos % im->styleLength;
+      break;
+    case gdStyledBrushed:
+      if (!im->style)
+	{
+	  /* Refuse to draw if no style is set. */
+	  return;
+	}
+      p = im->style[im->stylePos++];
+      if ((p != gdTransparent) && (p != 0))
+	{
+	  gdImageSetPixel (im, x, y, gdBrushed);
+	}
+      im->stylePos = im->stylePos % im->styleLength;
+      break;
+    case gdBrushed:
+      gdImageBrushApply (im, x, y);
+      break;
+    case gdTiled:
+      gdImageTileApply (im, x, y);
+      break;
+    default:
+      if (gdImageBoundsSafe (im, x, y))
+	{
+	  if (im->trueColor)
+	    {
+	      if (im->alphaBlendingFlag)
+		{
+		  im->tpixels[y][x] =
+		    gdAlphaBlend (im->tpixels[y][x],
+				  color);
+		}
+	      else
+		{
+		  im->tpixels[y][x] = color;
+		}
+	    }
+	  else
+	    {
+	      im->pixels[y][x] = color;
+	    }
+	}
+      break;
+    }
+}
+
+static void
+gdImageBrushApply (gdImagePtr im, int x, int y)
+{
+  int lx, ly;
+  int hy;
+  int hx;
+  int x1, y1, x2, y2;
+  int srcx, srcy;
+  if (!im->brush)
+    {
+      return;
+    }
+  hy = gdImageSY (im->brush) / 2;
+  y1 = y - hy;
+  y2 = y1 + gdImageSY (im->brush);
+  hx = gdImageSX (im->brush) / 2;
+  x1 = x - hx;
+  x2 = x1 + gdImageSX (im->brush);
+  srcy = 0;
+  if (im->trueColor)
+    {
+      for (ly = y1; (ly < y2); ly++)
+	{
+	  srcx = 0;
+	  for (lx = x1; (lx < x2); lx++)
+	    {
+	      int p;
+	      p = gdImageGetTrueColorPixel (
+					     im->brush, srcx, srcy);
+	      gdImageSetPixel (im, lx, ly,
+			       p);
+	      srcx++;
+	    }
+	  srcy++;
+	}
+    }
+  else
+    {
+      for (ly = y1; (ly < y2); ly++)
+	{
+	  srcx = 0;
+	  for (lx = x1; (lx < x2); lx++)
+	    {
+	      int p;
+	      p = gdImageGetPixel (im->brush, srcx, srcy);
+	      /* Allow for non-square brushes! */
+	      if (p != gdImageGetTransparent (im->brush))
+		{
+		  /* Truecolor brush. Very slow
+		     on a palette destination. */
+		  if (im->brush->trueColor)
+		    {
+		      gdImageSetPixel (im, lx, ly,
+				       gdImageColorResolveAlpha (
+								  im,
+						      gdTrueColorGetRed (p),
+						    gdTrueColorGetGreen (p),
+						     gdTrueColorGetBlue (p),
+						  gdTrueColorGetAlpha (p)));
+		    }
+		  else
+		    {
+		      gdImageSetPixel (im, lx, ly,
+				       im->brushColorMap[p]);
+		    }
+		}
+	      srcx++;
+	    }
+	  srcy++;
+	}
+    }
+}
+
+static void
+gdImageTileApply (gdImagePtr im, int x, int y)
+{
+  int srcx, srcy;
+  int p;
+  if (!im->tile)
+    {
+      return;
+    }
+  srcx = x % gdImageSX (im->tile);
+  srcy = y % gdImageSY (im->tile);
+  if (im->trueColor)
+    {
+      p = gdImageGetTrueColorPixel (im->tile, srcx, srcy);
+      gdImageSetPixel (im, x, y, p);
+    }
+  else
+    {
+      /* Allow for transparency */
+      if (p != gdImageGetTransparent (im->tile))
+	{
+	  if (im->tile->trueColor)
+	    {
+	      /* Truecolor tile. Very slow
+	         on a palette destination. */
+	      gdImageSetPixel (im, x, y,
+			       gdImageColorResolveAlpha (
+							  im,
+						      gdTrueColorGetRed (p),
+						    gdTrueColorGetGreen (p),
+						     gdTrueColorGetBlue (p),
+						  gdTrueColorGetAlpha (p)));
+	    }
+	  else
+	    {
+	      gdImageSetPixel (im, x, y,
+			       im->tileColorMap[p]);
+	    }
+	}
+    }
+}
+
+int
+gdImageGetPixel (gdImagePtr im, int x, int y)
+{
+  if (gdImageBoundsSafe (im, x, y))
+    {
+      if (im->trueColor)
+	{
+	  return im->tpixels[y][x];
+	}
+      else
+	{
+	  return im->pixels[y][x];
+	}
+    }
+  else
+    {
+      return 0;
+    }
+}
+
+int
+gdImageGetTrueColorPixel (gdImagePtr im, int x, int y)
+{
+  int p = gdImageGetPixel (im, x, y);
+  if (!im->trueColor)
+    {
+      return gdTrueColorAlpha (im->red[p], im->green[p], im->blue[p],
+			       (im->transparent == p) ? gdAlphaTransparent :
+			       gdAlphaOpaque);
+    }
+  else
+    {
+      return p;
+    }
+}
+
+/* Bresenham as presented in Foley & Van Dam */
+void
+gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+  int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
+  int wid;
+  int w, wstart;
+  int thick = im->thick;
+  dx = abs (x2 - x1);
+  dy = abs (y2 - y1);
+  if (dy <= dx)
+    {
+      /* More-or-less horizontal. use wid for vertical stroke */
+      wid = thick * cos (atan2 (dy, dx));
+      if (wid == 0)
+	wid = 1;
+
+      d = 2 * dy - dx;
+      incr1 = 2 * dy;
+      incr2 = 2 * (dy - dx);
+      if (x1 > x2)
+	{
+	  x = x2;
+	  y = y2;
+	  ydirflag = (-1);
+	  xend = x1;
+	}
+      else
+	{
+	  x = x1;
+	  y = y1;
+	  ydirflag = 1;
+	  xend = x2;
+	}
+
+      /* Set up line thickness */
+      wstart = y - wid / 2;
+      for (w = wstart; w < wstart + wid; w++)
+	gdImageSetPixel (im, x, w, color);
+
+      if (((y2 - y1) * ydirflag) > 0)
+	{
+	  while (x < xend)
+	    {
+	      x++;
+	      if (d < 0)
+		{
+		  d += incr1;
+		}
+	      else
+		{
+		  y++;
+		  d += incr2;
+		}
+	      wstart = y - wid / 2;
+	      for (w = wstart; w < wstart + wid; w++)
+		gdImageSetPixel (im, x, w, color);
+	    }
+	}
+      else
+	{
+	  while (x < xend)
+	    {
+	      x++;
+	      if (d < 0)
+		{
+		  d += incr1;
+		}
+	      else
+		{
+		  y--;
+		  d += incr2;
+		}
+	      wstart = y - wid / 2;
+	      for (w = wstart; w < wstart + wid; w++)
+		gdImageSetPixel (im, x, w, color);
+	    }
+	}
+    }
+  else
+    {
+      /* More-or-less vertical. use wid for horizontal stroke */
+      wid = thick * sin (atan2 (dy, dx));
+      if (wid == 0)
+	wid = 1;
+
+      d = 2 * dx - dy;
+      incr1 = 2 * dx;
+      incr2 = 2 * (dx - dy);
+      if (y1 > y2)
+	{
+	  y = y2;
+	  x = x2;
+	  yend = y1;
+	  xdirflag = (-1);
+	}
+      else
+	{
+	  y = y1;
+	  x = x1;
+	  yend = y2;
+	  xdirflag = 1;
+	}
+
+      /* Set up line thickness */
+      wstart = x - wid / 2;
+      for (w = wstart; w < wstart + wid; w++)
+	gdImageSetPixel (im, w, y, color);
+
+      if (((x2 - x1) * xdirflag) > 0)
+	{
+	  while (y < yend)
+	    {
+	      y++;
+	      if (d < 0)
+		{
+		  d += incr1;
+		}
+	      else
+		{
+		  x++;
+		  d += incr2;
+		}
+	      wstart = x - wid / 2;
+	      for (w = wstart; w < wstart + wid; w++)
+		gdImageSetPixel (im, w, y, color);
+	    }
+	}
+      else
+	{
+	  while (y < yend)
+	    {
+	      y++;
+	      if (d < 0)
+		{
+		  d += incr1;
+		}
+	      else
+		{
+		  x--;
+		  d += incr2;
+		}
+	      wstart = x - wid / 2;
+	      for (w = wstart; w < wstart + wid; w++)
+		gdImageSetPixel (im, w, y, color);
+	    }
+	}
+    }
+}
+static void dashedSet (gdImagePtr im, int x, int y, int color,
+		       int *onP, int *dashStepP, int wid, int vert);
+
+void
+gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+  int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
+  int dashStep = 0;
+  int on = 1;
+  int wid;
+  int w, wstart, vert;
+  int thick = im->thick;
+
+  dx = abs (x2 - x1);
+  dy = abs (y2 - y1);
+  if (dy <= dx)
+    {
+      /* More-or-less horizontal. use wid for vertical stroke */
+      wid = thick * sin (atan2 (dy, dx));
+      vert = 1;
+
+      d = 2 * dy - dx;
+      incr1 = 2 * dy;
+      incr2 = 2 * (dy - dx);
+      if (x1 > x2)
+	{
+	  x = x2;
+	  y = y2;
+	  ydirflag = (-1);
+	  xend = x1;
+	}
+      else
+	{
+	  x = x1;
+	  y = y1;
+	  ydirflag = 1;
+	  xend = x2;
+	}
+      dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+      if (((y2 - y1) * ydirflag) > 0)
+	{
+	  while (x < xend)
+	    {
+	      x++;
+	      if (d < 0)
+		{
+		  d += incr1;
+		}
+	      else
+		{
+		  y++;
+		  d += incr2;
+		}
+	      dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+	    }
+	}
+      else
+	{
+	  while (x < xend)
+	    {
+	      x++;
+	      if (d < 0)
+		{
+		  d += incr1;
+		}
+	      else
+		{
+		  y--;
+		  d += incr2;
+		}
+	      dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+	    }
+	}
+    }
+  else
+    {
+      /* More-or-less vertical. use wid for horizontal stroke */
+      wid = thick * sin (atan2 (dy, dx));
+      vert = 0;
+
+      d = 2 * dx - dy;
+      incr1 = 2 * dx;
+      incr2 = 2 * (dx - dy);
+      if (y1 > y2)
+	{
+	  y = y2;
+	  x = x2;
+	  yend = y1;
+	  xdirflag = (-1);
+	}
+      else
+	{
+	  y = y1;
+	  x = x1;
+	  yend = y2;
+	  xdirflag = 1;
+	}
+      dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+      if (((x2 - x1) * xdirflag) > 0)
+	{
+	  while (y < yend)
+	    {
+	      y++;
+	      if (d < 0)
+		{
+		  d += incr1;
+		}
+	      else
+		{
+		  x++;
+		  d += incr2;
+		}
+	      dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+	    }
+	}
+      else
+	{
+	  while (y < yend)
+	    {
+	      y++;
+	      if (d < 0)
+		{
+		  d += incr1;
+		}
+	      else
+		{
+		  x--;
+		  d += incr2;
+		}
+	      dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+	    }
+	}
+    }
+}
+
+static void
+dashedSet (gdImagePtr im, int x, int y, int color,
+	   int *onP, int *dashStepP, int wid, int vert)
+{
+  int dashStep = *dashStepP;
+  int on = *onP;
+  int w, wstart;
+
+  dashStep++;
+  if (dashStep == gdDashSize)
+    {
+      dashStep = 0;
+      on = !on;
+    }
+  if (on)
+    {
+      if (vert)
+	{
+	  wstart = y - wid / 2;
+	  for (w = wstart; w < wstart + wid; w++)
+	    gdImageSetPixel (im, x, w, color);
+	}
+      else
+	{
+	  wstart = x - wid / 2;
+	  for (w = wstart; w < wstart + wid; w++)
+	    gdImageSetPixel (im, w, y, color);
+	}
+    }
+  *dashStepP = dashStep;
+  *onP = on;
+}
+
+int
+gdImageBoundsSafe (gdImagePtr im, int x, int y)
+{
+  return (!(((y < 0) || (y >= im->sy)) ||
+	    ((x < 0) || (x >= im->sx))));
+}
+
+void
+gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y,
+	     int c, int color)
+{
+  int cx, cy;
+  int px, py;
+  int fline;
+  cx = 0;
+  cy = 0;
+#ifdef CHARSET_EBCDIC
+  c = ASC (c);
+#endif /*CHARSET_EBCDIC */
+  if ((c < f->offset) || (c >= (f->offset + f->nchars)))
+    {
+      return;
+    }
+  fline = (c - f->offset) * f->h * f->w;
+  for (py = y; (py < (y + f->h)); py++)
+    {
+      for (px = x; (px < (x + f->w)); px++)
+	{
+	  if (f->data[fline + cy * f->w + cx])
+	    {
+	      gdImageSetPixel (im, px, py, color);
+	    }
+	  cx++;
+	}
+      cx = 0;
+      cy++;
+    }
+}
+
+void
+gdImageCharUp (gdImagePtr im, gdFontPtr f,
+	       int x, int y, int c, int color)
+{
+  int cx, cy;
+  int px, py;
+  int fline;
+  cx = 0;
+  cy = 0;
+#ifdef CHARSET_EBCDIC
+  c = ASC (c);
+#endif /*CHARSET_EBCDIC */
+  if ((c < f->offset) || (c >= (f->offset + f->nchars)))
+    {
+      return;
+    }
+  fline = (c - f->offset) * f->h * f->w;
+  for (py = y; (py > (y - f->w)); py--)
+    {
+      for (px = x; (px < (x + f->h)); px++)
+	{
+	  if (f->data[fline + cy * f->w + cx])
+	    {
+	      gdImageSetPixel (im, px, py, color);
+	    }
+	  cy++;
+	}
+      cy = 0;
+      cx++;
+    }
+}
+
+void
+gdImageString (gdImagePtr im, gdFontPtr f,
+	       int x, int y, unsigned char *s, int color)
+{
+  int i;
+  int l;
+  l = strlen ((char *) s);
+  for (i = 0; (i < l); i++)
+    {
+      gdImageChar (im, f, x, y, s[i], color);
+      x += f->w;
+    }
+}
+
+void
+gdImageStringUp (gdImagePtr im, gdFontPtr f,
+		 int x, int y, unsigned char *s, int color)
+{
+  int i;
+  int l;
+  l = strlen ((char *) s);
+  for (i = 0; (i < l); i++)
+    {
+      gdImageCharUp (im, f, x, y, s[i], color);
+      y -= f->w;
+    }
+}
+
+static int strlen16 (unsigned short *s);
+
+void
+gdImageString16 (gdImagePtr im, gdFontPtr f,
+		 int x, int y, unsigned short *s, int color)
+{
+  int i;
+  int l;
+  l = strlen16 (s);
+  for (i = 0; (i < l); i++)
+    {
+      gdImageChar (im, f, x, y, s[i], color);
+      x += f->w;
+    }
+}
+
+void
+gdImageStringUp16 (gdImagePtr im, gdFontPtr f,
+		   int x, int y, unsigned short *s, int color)
+{
+  int i;
+  int l;
+  l = strlen16 (s);
+  for (i = 0; (i < l); i++)
+    {
+      gdImageCharUp (im, f, x, y, s[i], color);
+      y -= f->w;
+    }
+}
+
+static int
+strlen16 (unsigned short *s)
+{
+  int len = 0;
+  while (*s)
+    {
+      s++;
+      len++;
+    }
+  return len;
+}
+
+#ifndef HAVE_LSQRT
+/* If you don't have a nice square root function for longs, you can use
+   ** this hack
+ */
+long
+lsqrt (long n)
+{
+  long result = (long) sqrt ((double) n);
+  return result;
+}
+#endif
+
+/* s and e are integers modulo 360 (degrees), with 0 degrees
+   being the rightmost extreme and degrees changing clockwise.
+   cx and cy are the center in pixels; w and h are the horizontal 
+   and vertical diameter in pixels. Nice interface, but slow.
+   See gd_arc_f_buggy.c for a better version that doesn't 
+   seem to be bug-free yet. */
+
+void 
+gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color)
+{
+  gdImageFilledArc (im, cx, cy, w, h, s, e, color, gdNoFill);
+}
+
+void 
+gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style)
+{
+  gdPoint pts[3];
+  int i;
+  int lx = 0, ly = 0;
+  int fx, fy;
+  int w2, h2;
+  w2 = w / 2;
+  h2 = h / 2;
+  while (e < s)
+    {
+      e += 360;
+    }
+  for (i = s; (i <= e); i++)
+    {
+      int x, y;
+      x = ((long) gdCosT[i % 360] * (long) w2 / 1024) + cx;
+      y = ((long) gdSinT[i % 360] * (long) h2 / 1024) + cy;
+      if (i != s)
+	{
+	  if (!(style & gdChord))
+	    {
+	      if (style & gdNoFill)
+		{
+		  gdImageLine (im, lx, ly, x, y, color);
+		}
+	      else
+		{
+		  /* This is expensive! */
+		  pts[0].x = lx;
+		  pts[0].y = ly;
+		  pts[1].x = x;
+		  pts[1].y = y;
+		  pts[2].x = cx;
+		  pts[2].y = cy;
+		  gdImageFilledPolygon (im, pts, 3, color);
+		}
+	    }
+	}
+      else
+	{
+	  fx = x;
+	  fy = y;
+	}
+      lx = x;
+      ly = y;
+    }
+  if (style & gdChord)
+    {
+      if (style & gdNoFill)
+	{
+	  if (style & gdEdged)
+	    {
+	      gdImageLine (im, cx, cy, lx, ly, color);
+	      gdImageLine (im, cx, cy, fx, fy, color);
+	    }
+	  gdImageLine (im, fx, fy, lx, ly, color);
+	}
+      else
+	{
+	  pts[0].x = fx;
+	  pts[0].y = fy;
+	  pts[1].x = lx;
+	  pts[1].y = ly;
+	  pts[2].x = cx;
+	  pts[2].y = cy;
+	  gdImageFilledPolygon (im, pts, 3, color);
+	}
+    }
+  else
+    {
+      if (style & gdNoFill)
+	{
+	  if (style & gdEdged)
+	    {
+	      gdImageLine (im, cx, cy, lx, ly, color);
+	      gdImageLine (im, cx, cy, fx, fy, color);
+	    }
+	}
+    }
+}
+
+void 
+gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int w, int h, int color)
+{
+  gdImageFilledArc (im, cx, cy, w, h, 0, 360, color, gdPie);
+}
+
+void
+gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color)
+{
+  int lastBorder;
+  /* Seek left */
+  int leftLimit, rightLimit;
+  int i;
+  leftLimit = (-1);
+  if (border < 0)
+    {
+      /* Refuse to fill to a non-solid border */
+      return;
+    }
+  for (i = x; (i >= 0); i--)
+    {
+      if (gdImageGetPixel (im, i, y) == border)
+	{
+	  break;
+	}
+      gdImageSetPixel (im, i, y, color);
+      leftLimit = i;
+    }
+  if (leftLimit == (-1))
+    {
+      return;
+    }
+  /* Seek right */
+  rightLimit = x;
+  for (i = (x + 1); (i < im->sx); i++)
+    {
+      if (gdImageGetPixel (im, i, y) == border)
+	{
+	  break;
+	}
+      gdImageSetPixel (im, i, y, color);
+      rightLimit = i;
+    }
+  /* Look at lines above and below and start paints */
+  /* Above */
+  if (y > 0)
+    {
+      lastBorder = 1;
+      for (i = leftLimit; (i <= rightLimit); i++)
+	{
+	  int c;
+	  c = gdImageGetPixel (im, i, y - 1);
+	  if (lastBorder)
+	    {
+	      if ((c != border) && (c != color))
+		{
+		  gdImageFillToBorder (im, i, y - 1,
+				       border, color);
+		  lastBorder = 0;
+		}
+	    }
+	  else if ((c == border) || (c == color))
+	    {
+	      lastBorder = 1;
+	    }
+	}
+    }
+  /* Below */
+  if (y < ((im->sy) - 1))
+    {
+      lastBorder = 1;
+      for (i = leftLimit; (i <= rightLimit); i++)
+	{
+	  int c;
+	  c = gdImageGetPixel (im, i, y + 1);
+	  if (lastBorder)
+	    {
+	      if ((c != border) && (c != color))
+		{
+		  gdImageFillToBorder (im, i, y + 1,
+				       border, color);
+		  lastBorder = 0;
+		}
+	    }
+	  else if ((c == border) || (c == color))
+	    {
+	      lastBorder = 1;
+	    }
+	}
+    }
+}
+
+void
+gdImageFill (gdImagePtr im, int x, int y, int color)
+{
+  int lastBorder;
+  int old;
+  int leftLimit, rightLimit;
+  int i;
+  old = gdImageGetPixel (im, x, y);
+  if (color == gdTiled)
+    {
+      /* Tile fill -- got to watch out! */
+      int p, tileColor;
+      int srcx, srcy;
+      if (!im->tile)
+	{
+	  return;
+	}
+      /* Refuse to flood-fill with a transparent pattern --
+         I can't do it without allocating another image */
+      if (gdImageGetTransparent (im->tile) != (-1))
+	{
+	  return;
+	}
+      srcx = x % gdImageSX (im->tile);
+      srcy = y % gdImageSY (im->tile);
+      p = gdImageGetPixel (im->tile, srcx, srcy);
+      if (im->trueColor)
+	{
+	  tileColor = p;
+	}
+      else
+	{
+	  if (im->tile->trueColor)
+	    {
+	      tileColor = gdImageColorResolveAlpha (im,
+						    gdTrueColorGetRed (p),
+						    gdTrueColorGetGreen (p),
+						    gdTrueColorGetBlue (p),
+						    gdTrueColorGetAlpha (p));
+	    }
+	  else
+	    {
+	      tileColor = im->tileColorMap[p];
+	    }
+	}
+      if (old == tileColor)
+	{
+	  /* Nothing to be done */
+	  return;
+	}
+    }
+  else
+    {
+      if (old == color)
+	{
+	  /* Nothing to be done */
+	  return;
+	}
+    }
+  /* Seek left */
+  leftLimit = (-1);
+  for (i = x; (i >= 0); i--)
+    {
+      if (gdImageGetPixel (im, i, y) != old)
+	{
+	  break;
+	}
+      gdImageSetPixel (im, i, y, color);
+      leftLimit = i;
+    }
+  if (leftLimit == (-1))
+    {
+      return;
+    }
+  /* Seek right */
+  rightLimit = x;
+  for (i = (x + 1); (i < im->sx); i++)
+    {
+      if (gdImageGetPixel (im, i, y) != old)
+	{
+	  break;
+	}
+      gdImageSetPixel (im, i, y, color);
+      rightLimit = i;
+    }
+  /* Look at lines above and below and start paints */
+  /* Above */
+  if (y > 0)
+    {
+      lastBorder = 1;
+      for (i = leftLimit; (i <= rightLimit); i++)
+	{
+	  int c;
+	  c = gdImageGetPixel (im, i, y - 1);
+	  if (lastBorder)
+	    {
+	      if (c == old)
+		{
+		  gdImageFill (im, i, y - 1, color);
+		  lastBorder = 0;
+		}
+	    }
+	  else if (c != old)
+	    {
+	      lastBorder = 1;
+	    }
+	}
+    }
+  /* Below */
+  if (y < ((im->sy) - 1))
+    {
+      lastBorder = 1;
+      for (i = leftLimit; (i <= rightLimit); i++)
+	{
+	  int c;
+	  c = gdImageGetPixel (im, i, y + 1);
+	  if (lastBorder)
+	    {
+	      if (c == old)
+		{
+		  gdImageFill (im, i, y + 1, color);
+		  lastBorder = 0;
+		}
+	    }
+	  else if (c != old)
+	    {
+	      lastBorder = 1;
+	    }
+	}
+    }
+}
+
+void
+gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+  int x1h = x1, x1v = x1, y1h = y1, y1v = y1, x2h = x2, x2v = x2, y2h = y2,
+    y2v = y2;
+  int thick = im->thick;
+  if (thick > 1)
+    {
+      int half = thick / 2;
+      int half1 = thick - half;
+
+      if (y1 < y2)
+	{
+	  y1v = y1h - half;
+	  y2v = y2h + half1 - 1;
+	}
+      else
+	{
+	  y1v = y1h + half1 - 1;
+	  y2v = y2h - half;
+	}
+    }
+
+  gdImageLine (im, x1h, y1h, x2h, y1h, color);
+  gdImageLine (im, x1h, y2h, x2h, y2h, color);
+  gdImageLine (im, x1v, y1v, x1v, y2v, color);
+  gdImageLine (im, x2v, y1v, x2v, y2v, color);
+}
+
+void
+gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+  int x, y;
+  for (y = y1; (y <= y2); y++)
+    {
+      for (x = x1; (x <= x2); x++)
+	{
+	  gdImageSetPixel (im, x, y, color);
+	}
+    }
+}
+
+void
+gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h)
+{
+  int c;
+  int x, y;
+  int tox, toy;
+  int i;
+  int colorMap[gdMaxColors];
+  if (dst->trueColor)
+    {
+      /* 2.0: much easier when the destination is truecolor. */
+      for (y = 0; (y < h); y++)
+	{
+	  for (x = 0; (x < w); x++)
+	    {
+	      int c = gdImageGetTrueColorPixel (src, srcX + x,
+						srcY + y);
+	      if (c != src->transparent)
+		{
+		  gdImageSetPixel (dst,
+				   dstX + x,
+				   dstY + y,
+				   c);
+		}
+	    }
+	}
+      return;
+    }
+  for (i = 0; (i < gdMaxColors); i++)
+    {
+      colorMap[i] = (-1);
+    }
+  toy = dstY;
+  for (y = srcY; (y < (srcY + h)); y++)
+    {
+      tox = dstX;
+      for (x = srcX; (x < (srcX + w)); x++)
+	{
+	  int nc;
+	  c = gdImageGetPixel (src, x, y);
+	  /* Added 7/24/95: support transparent copies */
+	  if (gdImageGetTransparent (src) == c)
+	    {
+	      tox++;
+	      continue;
+	    }
+	  /* Have we established a mapping for this color? */
+	  if (colorMap[c] == (-1))
+	    {
+	      /* If it's the same image, mapping is trivial */
+	      if (dst == src)
+		{
+		  nc = c;
+		}
+	      else
+		{
+		  /* Get best match possible. This
+		     function never returns error. */
+		  nc = gdImageColorResolveAlpha (
+						  dst,
+						  src->red[c], src->green[c],
+					       src->blue[c], src->alpha[c]);
+		}
+	      colorMap[c] = nc;
+	    }
+	  gdImageSetPixel (dst, tox, toy, colorMap[c]);
+	  tox++;
+	}
+      toy++;
+    }
+}
+
+/* This function is a substitute for real alpha channel operations,
+   so it doesn't pay attention to the alpha channel. */
+void
+gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
+{
+
+  int c, dc;
+  int x, y;
+  int tox, toy;
+  int ncR, ncG, ncB;
+  toy = dstY;
+  for (y = srcY; (y < (srcY + h)); y++)
+    {
+      tox = dstX;
+      for (x = srcX; (x < (srcX + w)); x++)
+	{
+	  int nc;
+	  c = gdImageGetPixel (src, x, y);
+	  /* Added 7/24/95: support transparent copies */
+	  if (gdImageGetTransparent (src) == c)
+	    {
+	      tox++;
+	      continue;
+	    }
+	  /* If it's the same image, mapping is trivial */
+	  if (dst == src)
+	    {
+	      nc = c;
+	    }
+	  else
+	    {
+	      dc = gdImageGetPixel (dst, tox, toy);
+
+	      ncR = gdImageRed (src, c) * (pct / 100.0)
+		+ gdImageRed (dst, dc) * ((100 - pct) / 100.0);
+	      ncG = gdImageGreen (src, c) * (pct / 100.0)
+		+ gdImageGreen (dst, dc) * ((100 - pct) / 100.0);
+	      ncB = gdImageBlue (src, c) * (pct / 100.0)
+		+ gdImageBlue (dst, dc) * ((100 - pct) / 100.0);
+
+	      /* Find a reasonable color */
+	      nc = gdImageColorResolve (dst, ncR, ncG, ncB);
+	    }
+	  gdImageSetPixel (dst, tox, toy, nc);
+	  tox++;
+	}
+      toy++;
+    }
+}
+
+/* This function is a substitute for real alpha channel operations,
+   so it doesn't pay attention to the alpha channel. */
+void
+gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
+{
+
+  int c, dc;
+  int x, y;
+  int tox, toy;
+  int ncR, ncG, ncB;
+  float g;
+  toy = dstY;
+  for (y = srcY; (y < (srcY + h)); y++)
+    {
+      tox = dstX;
+      for (x = srcX; (x < (srcX + w)); x++)
+	{
+	  int nc;
+	  c = gdImageGetPixel (src, x, y);
+	  /* Added 7/24/95: support transparent copies */
+	  if (gdImageGetTransparent (src) == c)
+	    {
+	      tox++;
+	      continue;
+	    }
+	  /* If it's the same image, mapping is trivial */
+	  if (dst == src)
+	    {
+	      nc = c;
+	    }
+	  else
+	    {
+	      dc = gdImageGetPixel (dst, tox, toy);
+	      g = 0.29900 * dst->red[dc]
+		+ 0.58700 * dst->green[dc]
+		+ 0.11400 * dst->blue[dc];
+
+	      ncR = gdImageRed (src, c) * (pct / 100.0)
+		+ gdImageRed (dst, dc) * g *
+		((100 - pct) / 100.0);
+	      ncG = gdImageGreen (src, c) * (pct / 100.0)
+		+ gdImageGreen (dst, dc) * g *
+		((100 - pct) / 100.0);
+	      ncB = gdImageBlue (src, c) * (pct / 100.0)
+		+ gdImageBlue (dst, dc) * g *
+		((100 - pct) / 100.0);
+
+	      /* First look for an exact match */
+	      nc = gdImageColorExact (dst, ncR, ncG, ncB);
+	      if (nc == (-1))
+		{
+		  /* No, so try to allocate it */
+		  nc = gdImageColorAllocate (dst, ncR, ncG, ncB);
+		  /* If we're out of colors, go for the
+		     closest color */
+		  if (nc == (-1))
+		    {
+		      nc = gdImageColorClosest (dst, ncR, ncG, ncB);
+		    }
+		}
+	    }
+	  gdImageSetPixel (dst, tox, toy, nc);
+	  tox++;
+	}
+      toy++;
+    }
+}
+
+void
+gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
+{
+  int c;
+  int x, y;
+  int tox, toy;
+  int ydest;
+  int i;
+  int colorMap[gdMaxColors];
+  /* Stretch vectors */
+  int *stx;
+  int *sty;
+  /* We only need to use floating point to determine the correct
+     stretch vector for one line's worth. */
+  double accum;
+  stx = (int *) gdMalloc (sizeof (int) * srcW);
+  sty = (int *) gdMalloc (sizeof (int) * srcH);
+  accum = 0;
+  for (i = 0; (i < srcW); i++)
+    {
+      int got;
+      accum += (double) dstW / (double) srcW;
+      got = (int) floor (accum);
+      stx[i] = got;
+      accum -= got;
+    }
+  accum = 0;
+  for (i = 0; (i < srcH); i++)
+    {
+      int got;
+      accum += (double) dstH / (double) srcH;
+      got = (int) floor (accum);
+      sty[i] = got;
+      accum -= got;
+    }
+  for (i = 0; (i < gdMaxColors); i++)
+    {
+      colorMap[i] = (-1);
+    }
+  toy = dstY;
+  for (y = srcY; (y < (srcY + srcH)); y++)
+    {
+      for (ydest = 0; (ydest < sty[y - srcY]); ydest++)
+	{
+	  tox = dstX;
+	  for (x = srcX; (x < (srcX + srcW)); x++)
+	    {
+	      int nc;
+	      int mapTo;
+	      if (!stx[x - srcX])
+		{
+		  continue;
+		}
+	      if (dst->trueColor)
+		{
+		  int d;
+		  mapTo = gdImageGetTrueColorPixel (src, x, y);
+		  /* Added 7/24/95: support transparent copies */
+		  if (gdImageGetTransparent (src) == mapTo)
+		    {
+		      tox++;
+		      continue;
+		    }
+		}
+	      else
+		{
+		  c = gdImageGetPixel (src, x, y);
+		  /* Added 7/24/95: support transparent copies */
+		  if (gdImageGetTransparent (src) == c)
+		    {
+		      tox += stx[x - srcX];
+		      continue;
+		    }
+		  if (src->trueColor)
+		    {
+		      /* Remap to the palette available in the
+		         destination image. This is slow and
+		         works badly. */
+		      mapTo = gdImageColorResolveAlpha (dst,
+						      gdTrueColorGetRed (c),
+						    gdTrueColorGetGreen (c),
+						     gdTrueColorGetBlue (c),
+						   gdTrueColorGetAlpha (c));
+		    }
+		  else
+		    {
+		      /* Have we established a mapping for this color? */
+		      if (colorMap[c] == (-1))
+			{
+			  /* If it's the same image, mapping is trivial */
+			  if (dst == src)
+			    {
+			      nc = c;
+			    }
+			  else
+			    {
+			      /* Find or create the best match */
+			      mapTo = gdImageColorResolveAlpha (dst,
+						      gdTrueColorGetRed (c),
+						    gdTrueColorGetGreen (c),
+						     gdTrueColorGetBlue (c),
+						   gdTrueColorGetAlpha (c));
+			    }
+			  colorMap[c] = nc;
+			}
+		      mapTo = colorMap[c];
+		    }
+		}
+	      for (i = 0; (i < stx[x - srcX]); i++)
+		{
+		  gdImageSetPixel (dst, tox, toy, mapTo);
+		  tox++;
+		}
+	    }
+	  toy++;
+	}
+    }
+  gdFree (stx);
+  gdFree (sty);
+}
+
+/* When gd 1.x was first created, floating point was to be avoided.
+   These days it is often faster than table lookups or integer
+   arithmetic. The routine below is shamelessly, gloriously
+   floating point. TBB */
+
+void
+gdImageCopyResampled (gdImagePtr dst,
+		      gdImagePtr src,
+		      int dstX, int dstY,
+		      int srcX, int srcY,
+		      int dstW, int dstH,
+		      int srcW, int srcH)
+{
+  int x, y;
+  float sx, sy;
+  if (!dst->trueColor)
+    {
+      gdImageCopyResized (
+			   dst, src, dstX, dstY, srcX, srcY, dstW, dstH,
+			   srcW, srcH);
+      return;
+    }
+  for (y = dstY; (y < dstY + dstH); y++)
+    {
+      for (x = dstX; (x < dstX + dstW); x++)
+	{
+	  int pd = gdImageGetPixel (dst, x, y);
+	  float sy1, sy2, sx1, sx2;
+	  float sx, sy;
+	  float spixels = 0;
+	  float red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
+	  sy1 = ((float) y - (float) dstY) * (float) srcH /
+	    (float) dstH;
+	  sy2 = ((float) (y + 1) - (float) dstY) * (float) srcH /
+	    (float) dstH;
+	  sy = sy1;
+	  do
+	    {
+	      float yportion;
+	      if (floor (sy) == floor (sy1))
+		{
+		  yportion = 1.0 - (sy - floor (sy));
+		  if (yportion > sy2 - sy1)
+		    {
+		      yportion = sy2 - sy1;
+		    }
+		  sy = floor (sy);
+		}
+	      else if (sy == floor (sy2))
+		{
+		  yportion = sy2 - floor (sy2);
+		}
+	      else
+		{
+		  yportion = 1.0;
+		}
+	      sx1 = ((float) x - (float) dstX) * (float) srcW /
+		dstW;
+	      sx2 = ((float) (x + 1) - (float) dstX) * (float) srcW /
+		dstW;
+	      sx = sx1;
+	      do
+		{
+		  float xportion;
+		  float pcontribution;
+		  int p;
+		  if (floor (sx) == floor (sx1))
+		    {
+		      xportion = 1.0 - (sx - floor (sx));
+		      if (xportion > sx2 - sx1)
+			{
+			  xportion = sx2 - sx1;
+			}
+		      sx = floor (sx);
+		    }
+		  else if (sx == floor (sx2))
+		    {
+		      xportion = sx2 - floor (sx2);
+		    }
+		  else
+		    {
+		      xportion = 1.0;
+		    }
+		  pcontribution = xportion * yportion;
+		  p = gdImageGetTrueColorPixel (
+						 src,
+						 (int) sx,
+						 (int) sy);
+		  red += gdTrueColorGetRed (p) * pcontribution;
+		  green += gdTrueColorGetGreen (p) * pcontribution;
+		  blue += gdTrueColorGetBlue (p) * pcontribution;
+		  alpha += gdTrueColorGetAlpha (p) * pcontribution;
+		  spixels += xportion * yportion;
+		  sx += 1.0;
+		}
+	      while (sx < sx2);
+	      sy += 1.0;
+	    }
+	  while (sy < sy2);
+	  if (spixels != 0.0)
+	    {
+	      red /= spixels;
+	      green /= spixels;
+	      blue /= spixels;
+	      alpha /= spixels;
+	    }
+	  /* Clamping to allow for rounding errors above */
+	  if (red > 255.0)
+	    {
+	      red = 255.0;
+	    }
+	  if (green > 255.0)
+	    {
+	      green = 255.0;
+	    }
+	  if (blue > 255.0)
+	    {
+	      blue = 255.0;
+	    }
+	  if (alpha > gdAlphaMax)
+	    {
+	      alpha = gdAlphaMax;
+	    }
+	  gdImageSetPixel (dst,
+			   x, y,
+			   gdTrueColorAlpha ((int) red,
+					     (int) green,
+					     (int) blue,
+					     (int) alpha));
+	}
+    }
+}
+
+gdImagePtr
+gdImageCreateFromXbm (FILE * fd)
+{
+  gdImagePtr im;
+  int bit;
+  int w, h;
+  int bytes;
+  int ch;
+  int i, x, y;
+  char *sp;
+  char s[161];
+  if (!fgets (s, 160, fd))
+    {
+      return 0;
+    }
+  sp = &s[0];
+  /* Skip #define */
+  sp = strchr (sp, ' ');
+  if (!sp)
+    {
+      return 0;
+    }
+  /* Skip width label */
+  sp++;
+  sp = strchr (sp, ' ');
+  if (!sp)
+    {
+      return 0;
+    }
+  /* Get width */
+  w = atoi (sp + 1);
+  if (!w)
+    {
+      return 0;
+    }
+  if (!fgets (s, 160, fd))
+    {
+      return 0;
+    }
+  sp = s;
+  /* Skip #define */
+  sp = strchr (sp, ' ');
+  if (!sp)
+    {
+      return 0;
+    }
+  /* Skip height label */
+  sp++;
+  sp = strchr (sp, ' ');
+  if (!sp)
+    {
+      return 0;
+    }
+  /* Get height */
+  h = atoi (sp + 1);
+  if (!h)
+    {
+      return 0;
+    }
+  /* Skip declaration line */
+  if (!fgets (s, 160, fd))
+    {
+      return 0;
+    }
+  bytes = (w * h / 8) + 1;
+  im = gdImageCreate (w, h);
+  gdImageColorAllocate (im, 255, 255, 255);
+  gdImageColorAllocate (im, 0, 0, 0);
+  x = 0;
+  y = 0;
+  for (i = 0; (i < bytes); i++)
+    {
+      char h[3];
+      int b;
+      /* Skip spaces, commas, CRs, 0x */
+      while (1)
+	{
+	  ch = getc (fd);
+	  if (ch == EOF)
+	    {
+	      goto fail;
+	    }
+	  if (ch == 'x')
+	    {
+	      break;
+	    }
+	}
+      /* Get hex value */
+      ch = getc (fd);
+      if (ch == EOF)
+	{
+	  goto fail;
+	}
+      h[0] = ch;
+      ch = getc (fd);
+      if (ch == EOF)
+	{
+	  goto fail;
+	}
+      h[1] = ch;
+      h[2] = '\0';
+      sscanf (h, "%x", &b);
+      for (bit = 1; (bit <= 128); (bit = bit << 1))
+	{
+	  gdImageSetPixel (im, x++, y, (b & bit) ? 1 : 0);
+	  if (x == im->sx)
+	    {
+	      x = 0;
+	      y++;
+	      if (y == im->sy)
+		{
+		  return im;
+		}
+	      /* Fix 8/8/95 */
+	      break;
+	    }
+	}
+    }
+  /* Shouldn't happen */
+  fprintf (stderr, "Error: bug in gdImageCreateFromXbm!\n");
+  return 0;
+fail:
+  gdImageDestroy (im);
+  return 0;
+}
+
+void
+gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
+{
+  int i;
+  int lx, ly;
+  if (!n)
+    {
+      return;
+    }
+  lx = p->x;
+  ly = p->y;
+  gdImageLine (im, lx, ly, p[n - 1].x, p[n - 1].y, c);
+  for (i = 1; (i < n); i++)
+    {
+      p++;
+      gdImageLine (im, lx, ly, p->x, p->y, c);
+      lx = p->x;
+      ly = p->y;
+    }
+}
+
+int gdCompareInt (const void *a, const void *b);
+
+/* THANKS to Kirsten Schulz for the polygon fixes! */
+
+/* The intersection finding technique of this code could be improved  */
+/* by remembering the previous intertersection, and by using the slope. */
+/* That could help to adjust intersections  to produce a nice */
+/* interior_extrema. */
+
+void
+gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
+{
+  int i;
+  int y;
+  int miny, maxy;
+  int x1, y1;
+  int x2, y2;
+  int ind1, ind2;
+  int ints;
+  if (!n)
+    {
+      return;
+    }
+  if (!im->polyAllocated)
+    {
+      im->polyInts = (int *) gdMalloc (sizeof (int) * n);
+      im->polyAllocated = n;
+    }
+  if (im->polyAllocated < n)
+    {
+      while (im->polyAllocated < n)
+	{
+	  im->polyAllocated *= 2;
+	}
+      im->polyInts = (int *) gdRealloc (im->polyInts,
+					sizeof (int) * im->polyAllocated);
+    }
+  miny = p[0].y;
+  maxy = p[0].y;
+  for (i = 1; (i < n); i++)
+    {
+      if (p[i].y < miny)
+	{
+	  miny = p[i].y;
+	}
+      if (p[i].y > maxy)
+	{
+	  maxy = p[i].y;
+	}
+    }
+  /* Fix in 1.3: count a vertex only once */
+  for (y = miny; (y <= maxy); y++)
+    {
+/*1.4           int interLast = 0; */
+/*              int dirLast = 0; */
+/*              int interFirst = 1; */
+      ints = 0;
+      for (i = 0; (i < n); i++)
+	{
+	  if (!i)
+	    {
+	      ind1 = n - 1;
+	      ind2 = 0;
+	    }
+	  else
+	    {
+	      ind1 = i - 1;
+	      ind2 = i;
+	    }
+	  y1 = p[ind1].y;
+	  y2 = p[ind2].y;
+	  if (y1 < y2)
+	    {
+	      x1 = p[ind1].x;
+	      x2 = p[ind2].x;
+	    }
+	  else if (y1 > y2)
+	    {
+	      y2 = p[ind1].y;
+	      y1 = p[ind2].y;
+	      x2 = p[ind1].x;
+	      x1 = p[ind2].x;
+	    }
+	  else
+	    {
+	      continue;
+	    }
+	  if ((y >= y1) && (y < y2))
+	    {
+	      im->polyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1;
+	    }
+	  else if ((y == maxy) && (y > y1) && (y <= y2))
+	    {
+	      im->polyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1;
+	    }
+	}
+      qsort (im->polyInts, ints, sizeof (int), gdCompareInt);
+
+      for (i = 0; (i < (ints)); i += 2)
+	{
+	  gdImageLine (im, im->polyInts[i], y,
+		       im->polyInts[i + 1], y, c);
+	}
+    }
+}
+
+int
+gdCompareInt (const void *a, const void *b)
+{
+  return (*(const int *) a) - (*(const int *) b);
+}
+
+void
+gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels)
+{
+  if (im->style)
+    {
+      gdFree (im->style);
+    }
+  im->style = (int *)
+    gdMalloc (sizeof (int) * noOfPixels);
+  memcpy (im->style, style, sizeof (int) * noOfPixels);
+  im->styleLength = noOfPixels;
+  im->stylePos = 0;
+}
+
+void
+gdImageSetThickness (gdImagePtr im, int thickness)
+{
+  im->thick = thickness;
+}
+
+void
+gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
+{
+  int i;
+  im->brush = brush;
+  if ((!im->trueColor) && (!im->brush->trueColor))
+    {
+      for (i = 0; (i < gdImageColorsTotal (brush)); i++)
+	{
+	  int index;
+	  index = gdImageColorResolveAlpha (im,
+					    gdImageRed (brush, i),
+					    gdImageGreen (brush, i),
+					    gdImageBlue (brush, i),
+					    gdImageAlpha (brush, i));
+	  im->brushColorMap[i] = index;
+	}
+    }
+}
+
+void
+gdImageSetTile (gdImagePtr im, gdImagePtr tile)
+{
+  int i;
+  im->tile = tile;
+  if ((!im->trueColor) && (!im->tile->trueColor))
+    {
+      for (i = 0; (i < gdImageColorsTotal (tile)); i++)
+	{
+	  int index;
+	  index = gdImageColorResolveAlpha (im,
+					    gdImageRed (tile, i),
+					    gdImageGreen (tile, i),
+					    gdImageBlue (tile, i),
+					    gdImageAlpha (tile, i));
+	  im->tileColorMap[i] = index;
+	}
+    }
+}
+
+void
+gdImageInterlace (gdImagePtr im, int interlaceArg)
+{
+  im->interlace = interlaceArg;
+}
+
+int
+gdImageCompare (gdImagePtr im1, gdImagePtr im2)
+{
+  int x, y;
+  int p1, p2;
+  int cmpStatus = 0;
+  int sx, sy;
+
+  if (im1->interlace != im2->interlace)
+    {
+      cmpStatus |= GD_CMP_INTERLACE;
+    }
+
+  if (im1->transparent != im2->transparent)
+    {
+      cmpStatus |= GD_CMP_TRANSPARENT;
+    }
+
+  if (im1->trueColor != im2->trueColor)
+    {
+      cmpStatus |= GD_CMP_TRUECOLOR;
+    }
+
+  sx = im1->sx;
+  if (im1->sx != im2->sx)
+    {
+      cmpStatus |= GD_CMP_SIZE_X + GD_CMP_IMAGE;
+      if (im2->sx < im1->sx)
+	{
+	  sx = im2->sx;
+	}
+    }
+
+  sy = im1->sy;
+  if (im1->sy != im2->sy)
+    {
+      cmpStatus |= GD_CMP_SIZE_Y + GD_CMP_IMAGE;
+      if (im2->sy < im1->sy)
+	{
+	  sy = im2->sy;
+	}
+    }
+
+  if (im1->colorsTotal != im2->colorsTotal)
+    {
+      cmpStatus |= GD_CMP_NUM_COLORS;
+    }
+
+  for (y = 0; (y < sy); y++)
+    {
+      for (x = 0; (x < sx); x++)
+	{
+	  p1 = im1->pixels[y][x];
+	  p2 = im2->pixels[y][x];
+	  if (gdImageRed (im1, p1) != gdImageRed (im2, p2))
+	    {
+	      cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
+	      break;
+	    }
+	  if (gdImageGreen (im1, p1) != gdImageGreen (im2, p2))
+	    {
+	      cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
+	      break;
+	    }
+	  if (gdImageBlue (im1, p1) != gdImageBlue (im2, p2))
+	    {
+	      cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
+	      break;
+	    }
+#if 0
+	  /* Soon we'll add alpha channel to palettes */
+	  if (gdImageAlpha (im1, p1) != gdImageAlpha (im2, p2))
+	    {
+	      cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
+	      break;
+	    }
+#endif
+	}
+      if (cmpStatus & GD_CMP_COLOR)
+	{
+	  break;
+	};
+    }
+
+  return cmpStatus;
+}
+
+int
+gdAlphaBlend (int dst, int src)
+{
+  return (((((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
+	     gdTrueColorGetRed (src) / gdAlphaMax) +
+	    (gdTrueColorGetAlpha (src) *
+	     gdTrueColorGetRed (dst)) / gdAlphaMax) << 16) +
+	  ((((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
+	     gdTrueColorGetGreen (src) / gdAlphaMax) +
+	    (gdTrueColorGetAlpha (src) *
+	     gdTrueColorGetGreen (dst)) / gdAlphaMax) << 8) +
+	  (((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
+	    gdTrueColorGetBlue (src) / gdAlphaMax) +
+	   (gdTrueColorGetAlpha (src) *
+	    gdTrueColorGetBlue (dst)) / gdAlphaMax));
+}
+
+void
+gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg)
+{
+  im->alphaBlendingFlag = alphaBlendingArg;
+}
+
+void
+gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg)
+{
+  im->saveAlphaFlag = saveAlphaArg;
+}