diff --git a/src/extra/gd/Makefile.am b/src/extra/gd/Makefile.am

index 3fb9330..14bda8c 100644

--- a/src/extra/gd/Makefile.am

+++ b/src/extra/gd/Makefile.am

@@ -22,7 +22,7 @@ libgd_la_SOURCES = gd.c gd_gd.c gd_gd2.c gd_io.c gd_io_dp.c \

 		gd_io_file.c gd_ss.c gd_io_ss.c gd_png.c gd_jpeg.c gdxpm.c \

 		gdfontt.c gdfonts.c gdfontmb.c gdfontl.c gdfontg.c \

 		gdtables.c gdft.c gdcache.c gdkanji.c wbmp.c \

-		gd_wbmp.c gdhelpers.c gd_topal.c gd_clip.c

+		gd_wbmp.c gdhelpers.c gd_clip.c

 gddir = $(includedir)/libwmf/gd

diff --git a/src/extra/gd/Makefile.gd b/src/extra/gd/Makefile.gd

index 3cd876f..b90e4ac 100644

--- a/src/extra/gd/Makefile.gd

+++ b/src/extra/gd/Makefile.gd

@@ -145,7 +145,7 @@ LIBOBJS=gd.o gd_gd.o gd_gd2.o gd_io.o gd_io_dp.o \

 		gd_io_file.o gd_ss.o gd_io_ss.o gd_png.o gd_jpeg.o gdxpm.o \

 		gdfontt.o gdfonts.o gdfontmb.o gdfontl.o gdfontg.o \

 		gdtables.o gdft.o gdcache.o gdkanji.o wbmp.o \

-		gd_wbmp.o gdhelpers.o gd_topal.o 

+		gd_wbmp.o gdhelpers.o

 #Shared library. This should work fine on any ELF platform (Linux, etc.) with

 #GNU ld or something similarly intelligent. To avoid the chicken-and-egg

diff --git a/src/extra/gd/Makefile.in b/src/extra/gd/Makefile.in

index edb5c90..8cf93a6 100644

--- a/src/extra/gd/Makefile.in

+++ b/src/extra/gd/Makefile.in

@@ -107,7 +107,7 @@ am_libgd_la_OBJECTS = gd.lo gd_gd.lo gd_gd2.lo gd_io.lo gd_io_dp.lo \

 	gd_io_file.lo gd_ss.lo gd_io_ss.lo gd_png.lo gd_jpeg.lo \

 	gdxpm.lo gdfontt.lo gdfonts.lo gdfontmb.lo gdfontl.lo \

 	gdfontg.lo gdtables.lo gdft.lo gdcache.lo gdkanji.lo wbmp.lo \

-	gd_wbmp.lo gdhelpers.lo gd_topal.lo gd_clip.lo

+	gd_wbmp.lo gdhelpers.lo gd_clip.lo

 libgd_la_OBJECTS = $(am_libgd_la_OBJECTS)

 AM_V_lt = $(am__v_lt_@AM_V@)

 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)

@@ -370,7 +370,7 @@ libgd_la_SOURCES = gd.c gd_gd.c gd_gd2.c gd_io.c gd_io_dp.c \

 		gd_io_file.c gd_ss.c gd_io_ss.c gd_png.c gd_jpeg.c gdxpm.c \

 		gdfontt.c gdfonts.c gdfontmb.c gdfontl.c gdfontg.c \

 		gdtables.c gdft.c gdcache.c gdkanji.c wbmp.c \

-		gd_wbmp.c gdhelpers.c gd_topal.c gd_clip.c

+		gd_wbmp.c gdhelpers.c gd_clip.c

 gddir = $(includedir)/libwmf/gd

 gd_HEADERS = $(HDRGDINST)

@@ -472,7 +472,6 @@ distclean-compile:

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gd_jpeg.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gd_png.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gd_ss.Plo@am__quote@

-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gd_topal.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gd_wbmp.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gdcache.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gdfontg.Plo@am__quote@

diff --git a/src/extra/gd/gd.c b/src/extra/gd/gd.c

index 6296472..dc6a9a7 100644

--- a/src/extra/gd/gd.c

+++ b/src/extra/gd/gd.c

@@ -1995,7 +1995,7 @@ gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX

 			  else

 			    {

 			      /* Find or create the best match */

-			      mapTo = gdImageColorResolveAlpha (dst,

+			      nc = gdImageColorResolveAlpha (dst,

 						      gdTrueColorGetRed (c),

 						    gdTrueColorGetGreen (c),

 						     gdTrueColorGetBlue (c),

diff --git a/src/extra/gd/gd.h b/src/extra/gd/gd.h

index 619ddd3..8c19354 100644

--- a/src/extra/gd/gd.h

+++ b/src/extra/gd/gd.h

@@ -308,24 +308,6 @@ int gdImageColorResolveAlpha(gdImagePtr im, int r, int g, int b, int a);

 void gdImageColorDeallocate(gdImagePtr im, int color);

-/* Converts a truecolor image to a palette-based image,

-	using a high-quality two-pass quantization routine

-	which attempts to preserve alpha channel information

-	as well as R/G/B color information when creating

-	a palette. If ditherFlag is set, the image will be

-	dithered to approximate colors better, at the expense

-	of some obvious "speckling." colorsWanted can be

-	anything up to 256. If the original source image

-	includes photographic information or anything that

-	came out of a JPEG, 256 is strongly recommended.

-

-	Better yet, don't use this function -- write real

-	truecolor PNGs and JPEGs. The disk space gain of

-        conversion to palette is not great (for small images

-        it can be negative) and the quality loss is ugly. */

-

-void gdImageTrueColorToPalette(gdImagePtr im, int ditherFlag, int colorsWanted);

-

 /* Specifies a color index (if a palette image) or an

 	RGB color (if a truecolor image) which should be

 	considered 100% transparent. FOR TRUECOLOR IMAGES,

diff --git a/src/extra/gd/gd_gd2.c b/src/extra/gd/gd_gd2.c

index 602b869..05d8dcb 100644

--- a/src/extra/gd/gd_gd2.c

+++ b/src/extra/gd/gd_gd2.c

@@ -361,7 +361,7 @@ gdImageCreateFromGd2Ctx (gdIOCtxPtr in)

 		  xhi = im->sx;

 		};

 	      /*GD2_DBG(printf("y=%d: ",y)); */

-	      if (fmt == GD2_FMT_RAW)

+	      if (fmt != GD2_FMT_COMPRESSED)

 		{

 		  for (x = xlo; x < xhi; x++)

 		    {

@@ -617,7 +617,7 @@ gdImageCreateFromGd2PartCtx (gdIOCtx * in, int srcx, int srcy, int w, int h)

 	      for (x = xlo; x < xhi; x++)

 		{

-		  if (fmt == GD2_FMT_RAW)

+		  if (fmt != GD2_FMT_COMPRESSED)

 		    {

 		      if (im->trueColor)

 			{

diff --git a/src/extra/gd/gd_png.c b/src/extra/gd/gd_png.c

index b37fc2c..c7f3aa0 100644

--- a/src/extra/gd/gd_png.c

+++ b/src/extra/gd/gd_png.c

@@ -131,7 +131,6 @@ gdImageCreateFromPngCtx (gdIOCtx * infile)

   gdImagePtr im = NULL;

   int i, j, *open;

   volatile int transparent = -1;

-  volatile int palette_allocated = FALSE;

   /* Make sure the signature can't match by dumb luck -- TBB */

   memset (sig, 0, sizeof (sig));

@@ -177,6 +176,7 @@ gdImageCreateFromPngCtx (gdIOCtx * infile)

     }

 #endif

   open = NULL;

+  palette = NULL;

   png_set_sig_bytes (png_ptr, 8);	/* we already read the 8 signature bytes */

@@ -254,7 +254,6 @@ gdImageCreateFromPngCtx (gdIOCtx * infile)

 	  gdImageDestroy(im);

 	  return NULL;

 	}

-      palette_allocated = TRUE;

       if (bit_depth < 8)

 	{

 	  num_palette = 1 << bit_depth;

@@ -321,8 +320,7 @@ gdImageCreateFromPngCtx (gdIOCtx * infile)

       fprintf (stderr, "gd-png error: cannot allocate image data\n");

       png_destroy_read_struct (&png_ptr, &info_ptr, NULL);

       gdImageDestroy(im);

-      if (palette_allocated)

-        gdFree (palette);

+      gdFree(palette);

       return NULL;

     }

   if ((row_pointers = (png_bytepp) gdMalloc (height * sizeof (png_bytep))) == NULL)

@@ -331,8 +329,7 @@ gdImageCreateFromPngCtx (gdIOCtx * infile)

       png_destroy_read_struct (&png_ptr, &info_ptr, NULL);

       gdFree (image_data);

       gdImageDestroy(im);

-      if (palette_allocated)

-        gdFree (palette);

+      gdFree(palette);

       return NULL;

     }

@@ -429,8 +426,7 @@ gdImageCreateFromPngCtx (gdIOCtx * infile)

     }

 #endif

-  if (palette_allocated)

-    gdFree (palette);

+  gdFree (palette);

   gdFree (image_data);

   gdFree (row_pointers);

diff --git a/src/extra/gd/gd_topal.c b/src/extra/gd/gd_topal.c

deleted file mode 100644

index 4ca86c9..0000000

--- a/src/extra/gd/gd_topal.c

+++ /dev/null

@@ -1,1698 +0,0 @@

-

-

-/*

- * gd_topal.c 

- * 

- * This code is adapted pretty much entirely from jquant2.c,

- * Copyright (C) 1991-1996, Thomas G. Lane. That file is

- * part of the Independent JPEG Group's software. Conditions of

- * use are compatible with the gd license. See the gd license 

- * statement and README-JPEG.TXT for additional information.

- *

- * This file contains 2-pass color quantization (color mapping) routines.

- * These routines provide selection of a custom color map for an image,

- * followed by mapping of the image to that color map, with optional

- * Floyd-Steinberg dithering.

- *

- * It is also possible to use just the second pass to map to an arbitrary

- * externally-given color map.

- *

- * Note: ordered dithering is not supported, since there isn't any fast

- * way to compute intercolor distances; it's unclear that ordered dither's

- * fundamental assumptions even hold with an irregularly spaced color map.

- *

- * SUPPORT FOR ALPHA CHANNELS WAS HACKED IN BY THOMAS BOUTELL, who also

- * adapted the code to work within gd rather than within libjpeg, and

- * may not have done a great job of either. It's not Thomas G. Lane's fault.

- */

-

-#include "gd.h"

-#include "gdhelpers.h"

-#include <string.h>

-

-/*

- * This module implements the well-known Heckbert paradigm for color

- * quantization.  Most of the ideas used here can be traced back to

- * Heckbert's seminal paper

- *   Heckbert, Paul.  "Color Image Quantization for Frame Buffer Display",

- *   Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304.

- *

- * In the first pass over the image, we accumulate a histogram showing the

- * usage count of each possible color.  To keep the histogram to a reasonable

- * size, we reduce the precision of the input; typical practice is to retain

- * 5 or 6 bits per color, so that 8 or 4 different input values are counted

- * in the same histogram cell.

- *

- * Next, the color-selection step begins with a box representing the whole

- * color space, and repeatedly splits the "largest" remaining box until we

- * have as many boxes as desired colors.  Then the mean color in each

- * remaining box becomes one of the possible output colors.

- * 

- * The second pass over the image maps each input pixel to the closest output

- * color (optionally after applying a Floyd-Steinberg dithering correction).

- * This mapping is logically trivial, but making it go fast enough requires

- * considerable care.

- *

- * Heckbert-style quantizers vary a good deal in their policies for choosing

- * the "largest" box and deciding where to cut it.  The particular policies

- * used here have proved out well in experimental comparisons, but better ones

- * may yet be found.

- *

- * In earlier versions of the IJG code, this module quantized in YCbCr color

- * space, processing the raw upsampled data without a color conversion step.

- * This allowed the color conversion math to be done only once per colormap

- * entry, not once per pixel.  However, that optimization precluded other

- * useful optimizations (such as merging color conversion with upsampling)

- * and it also interfered with desired capabilities such as quantizing to an

- * externally-supplied colormap.  We have therefore abandoned that approach.

- * The present code works in the post-conversion color space, typically RGB.

- *

- * To improve the visual quality of the results, we actually work in scaled

- * RGBA space, giving G distances more weight than R, and R in turn more than

- * B.  Alpha is weighted least. To do everything in integer math, we must 

- * use integer scale factors. The 2/3/1 scale factors used here correspond 

- * loosely to the relative weights of the colors in the NTSC grayscale 

- * equation. 

- */

-

-#ifndef TRUE

-#define TRUE 1

-#endif /* TRUE */

-

-#ifndef FALSE

-#define FALSE 0

-#endif /* FALSE */

-

-#define R_SCALE 2		/* scale R distances by this much */

-#define G_SCALE 3		/* scale G distances by this much */

-#define B_SCALE 1		/* and B by this much */

-#define A_SCALE 4		/* and alpha by this much. This really

-				   only scales by 1 because alpha

-				   values are 7-bit to begin with. */

-

-/* Channel ordering (fixed in gd) */

-#define C0_SCALE R_SCALE

-#define C1_SCALE G_SCALE

-#define C2_SCALE B_SCALE

-#define C3_SCALE A_SCALE

-

-/*

- * First we have the histogram data structure and routines for creating it.

- *

- * The number of bits of precision can be adjusted by changing these symbols.

- * We recommend keeping 6 bits for G and 5 each for R and B.

- * If you have plenty of memory and cycles, 6 bits all around gives marginally

- * better results; if you are short of memory, 5 bits all around will save

- * some space but degrade the results.

- * To maintain a fully accurate histogram, we'd need to allocate a "long"

- * (preferably unsigned long) for each cell.  In practice this is overkill;

- * we can get by with 16 bits per cell.  Few of the cell counts will overflow,

- * and clamping those that do overflow to the maximum value will give close-

- * enough results.  This reduces the recommended histogram size from 256Kb

- * to 128Kb, which is a useful savings on PC-class machines.

- * (In the second pass the histogram space is re-used for pixel mapping data;

- * in that capacity, each cell must be able to store zero to the number of

- * desired colors.  16 bits/cell is plenty for that too.)

- * Since the JPEG code is intended to run in small memory model on 80x86

- * machines, we can't just allocate the histogram in one chunk.  Instead

- * of a true 3-D array, we use a row of pointers to 2-D arrays.  Each

- * pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and

- * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries.  Note that

- * on 80x86 machines, the pointer row is in near memory but the actual

- * arrays are in far memory (same arrangement as we use for image arrays).

- */

-

-#define MAXNUMCOLORS  (gdMaxColors)	/* maximum size of colormap */

-

-#define HIST_C0_BITS  5		/* bits of precision in R histogram */

-#define HIST_C1_BITS  6		/* bits of precision in G histogram */

-#define HIST_C2_BITS  5		/* bits of precision in B histogram */

-#define HIST_C3_BITS  3		/* bits of precision in A histogram */

-

-/* Number of elements along histogram axes. */

-#define HIST_C0_ELEMS  (1<

-#define HIST_C1_ELEMS  (1<

-#define HIST_C2_ELEMS  (1<

-#define HIST_C3_ELEMS  (1<

-

-/* These are the amounts to shift an input value to get a histogram index. */

-#define C0_SHIFT  (8-HIST_C0_BITS)

-#define C1_SHIFT  (8-HIST_C1_BITS)

-#define C2_SHIFT  (8-HIST_C2_BITS)

-/* Beware! Alpha is 7 bit to begin with */

-#define C3_SHIFT  (7-HIST_C3_BITS)

-

-

-typedef unsigned short histcell;	/* histogram cell; prefer an unsigned type */

-

-typedef histcell *histptr;	/* for pointers to histogram cells */

-

-typedef histcell hist1d[HIST_C3_ELEMS];		/* typedefs for the array */

-typedef hist1d *hist2d;		/* type for the 2nd-level pointers */

-typedef hist2d *hist3d;		/* type for third-level pointer */

-typedef hist3d *hist4d;		/* type for top-level pointer */

-

-

-/* Declarations for Floyd-Steinberg dithering.

-

- * Errors are accumulated into the array fserrors[], at a resolution of

- * 1/16th of a pixel count.  The error at a given pixel is propagated

- * to its not-yet-processed neighbors using the standard F-S fractions,

- *              ...     (here)  7/16

- *              3/16    5/16    1/16

- * We work left-to-right on even rows, right-to-left on odd rows.

- *

- * We can get away with a single array (holding one row's worth of errors)

- * by using it to store the current row's errors at pixel columns not yet

- * processed, but the next row's errors at columns already processed.  We

- * need only a few extra variables to hold the errors immediately around the

- * current column.  (If we are lucky, those variables are in registers, but

- * even if not, they're probably cheaper to access than array elements are.)

- *

- * The fserrors[] array has (#columns + 2) entries; the extra entry at

- * each end saves us from special-casing the first and last pixels.

- * Each entry is three values long, one value for each color component.

- *

- */

-

-typedef signed short FSERROR;	/* 16 bits should be enough */

-typedef int LOCFSERROR;		/* use 'int' for calculation temps */

-

-typedef FSERROR *FSERRPTR;	/* pointer to error array */

-

-/* Private object */

-

-typedef struct

-  {

-    hist4d histogram;		/* pointer to the histogram */

-    int needs_zeroed;		/* TRUE if next pass must zero histogram */

-

-    /* Variables for Floyd-Steinberg dithering */

-    FSERRPTR fserrors;		/* accumulated errors */

-    int on_odd_row;		/* flag to remember which row we are on */

-    int *error_limiter;		/* table for clamping the applied error */

-    int *error_limiter_storage;	/* gdMalloc'd storage for the above */

-    int transparentIsPresent;	/* TBB: for rescaling to ensure that */

-    int opaqueIsPresent;	/* 100% opacity & transparency are preserved */

-  }

-my_cquantizer;

-

-typedef my_cquantizer *my_cquantize_ptr;

-

-/*

- * Prescan the pixel array. 

- * 

- * The prescan simply updates the histogram, which has been

- * initialized to zeroes by start_pass.

- *

- */

-

-static void

-prescan_quantize (gdImagePtr im, my_cquantize_ptr cquantize)

-{

-  register histptr histp;

-  register hist4d histogram = cquantize->histogram;

-  int row;

-  int col;

-  int *ptr;

-  int width = im->sx;

-

-  for (row = 0; row < im->sy; row++)

-    {

-      ptr = im->tpixels[row];

-      for (col = width; col > 0; col--)

-	{

-	  /* get pixel value and index into the histogram */

-	  int r, g, b, a;

-	  r = gdTrueColorGetRed (*ptr) >> C0_SHIFT;

-	  g = gdTrueColorGetGreen (*ptr) >> C1_SHIFT;

-	  b = gdTrueColorGetBlue (*ptr) >> C2_SHIFT;

-	  a = gdTrueColorGetAlpha (*ptr);

-	  /* We must have 100% opacity and transparency available

-	     in the color map to do an acceptable job with alpha 

-	     channel, if opacity and transparency are present in the

-	     original, because of the visual properties of large

-	     flat-color border areas (requiring 100% transparency) 

-	     and the behavior of poorly implemented browsers 

-	     (requiring 100% opacity). Test for the presence of

-	     these here, and rescale the most opaque and transparent

-	     palette entries at the end if so. This avoids the need

-	     to develop a fuller understanding I have not been able

-	     to reach so far in my study of this subject. TBB */

-	  if (a == gdAlphaTransparent)

-	    {

-	      cquantize->transparentIsPresent = 1;

-	    }

-	  if (a == gdAlphaOpaque)

-	    {

-	      cquantize->opaqueIsPresent = 1;

-	    }

-	  a >>= C3_SHIFT;

-	  histp = &histogram[r][g][b][a];

-	  /* increment, check for overflow and undo increment if so. */

-	  if (++(*histp) <= 0)

-	    (*histp)--;

-	  ptr++;

-	}

-    }

-}

-

-

-/*

- * Next we have the really interesting routines: selection of a colormap

- * given the completed histogram.

- * These routines work with a list of "boxes", each representing a rectangular

- * subset of the input color space (to histogram precision).

- */

-

-typedef struct

-{

-  /* The bounds of the box (inclusive); expressed as histogram indexes */

-  int c0min, c0max;

-  int c1min, c1max;

-  int c2min, c2max;

-  int c3min, c3max;

-  /* The volume (actually 2-norm) of the box */

-  int volume;

-  /* The number of nonzero histogram cells within this box */

-  long colorcount;

-}

-box;

-

-typedef box *boxptr;

-

-static boxptr

-find_biggest_color_pop (boxptr boxlist, int numboxes)

-/* Find the splittable box with the largest color population */

-/* Returns NULL if no splittable boxes remain */

-{

-  register boxptr boxp;

-  register int i;

-  register long maxc = 0;

-  boxptr which = NULL;

-

-  for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++)

-    {

-      if (boxp->colorcount > maxc && boxp->volume > 0)

-	{

-	  which = boxp;

-	  maxc = boxp->colorcount;

-	}

-    }

-  return which;

-}

-

-

-static boxptr

-find_biggest_volume (boxptr boxlist, int numboxes)

-/* Find the splittable box with the largest (scaled) volume */

-/* Returns NULL if no splittable boxes remain */

-{

-  register boxptr boxp;

-  register int i;

-  register int maxv = 0;

-  boxptr which = NULL;

-

-  for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++)

-    {

-      if (boxp->volume > maxv)

-	{

-	  which = boxp;

-	  maxv = boxp->volume;

-	}

-    }

-  return which;

-}

-

-

-static void

-update_box (my_cquantize_ptr cquantize, boxptr boxp)

-/* Shrink the min/max bounds of a box to enclose only nonzero elements, */

-/* and recompute its volume and population */

-{

-  hist4d histogram = cquantize->histogram;

-  histptr histp;

-  int c0, c1, c2, c3;

-  int c0min, c0max, c1min, c1max, c2min, c2max, c3min, c3max;

-  int dist0, dist1, dist2, dist3;

-  long ccount;

-

-  c0min = boxp->c0min;

-  c0max = boxp->c0max;

-  c1min = boxp->c1min;

-  c1max = boxp->c1max;

-  c2min = boxp->c2min;

-  c2max = boxp->c2max;

-  c3min = boxp->c3min;

-  c3max = boxp->c3max;

-

-  if (c0max > c0min)

-    {

-      for (c0 = c0min; c0 <= c0max; c0++)

-	{

-	  for (c1 = c1min; c1 <= c1max; c1++)

-	    {

-	      for (c2 = c2min; c2 <= c2max; c2++)

-		{

-		  histp = &histogram[c0][c1][c2][c3min];

-		  for (c3 = c3min; c3 <= c3max; c3++)

-		    {

-		      if (*histp++ != 0)

-			{

-			  boxp->c0min = c0min = c0;

-			  goto have_c0min;

-			}

-		    }

-		}

-	    }

-	}

-    }

-have_c0min:

-  if (c0max > c0min)

-    {

-      for (c0 = c0max; c0 >= c0min; c0--)

-	{

-	  for (c1 = c1min; c1 <= c1max; c1++)

-	    {

-	      for (c2 = c2min; c2 <= c2max; c2++)

-		{

-		  histp = &histogram[c0][c1][c2][c3min];

-		  for (c3 = c3min; c3 <= c3max; c3++)

-		    {

-		      if (*histp++ != 0)

-			{

-			  boxp->c0max = c0max = c0;

-			  goto have_c0max;

-			}

-		    }

-		}

-	    }

-	}

-    }

-have_c0max:

-  if (c1max > c1min)

-    for (c1 = c1min; c1 <= c1max; c1++)

-      for (c0 = c0min; c0 <= c0max; c0++)

-	{

-	  for (c2 = c2min; c2 <= c2max; c2++)

-	    {

-	      histp = &histogram[c0][c1][c2][c3min];

-	      for (c3 = c3min; c3 <= c3max; c3++)

-		if (*histp++ != 0)

-		  {

-		    boxp->c1min = c1min = c1;

-		    goto have_c1min;

-		  }

-	    }

-	}

-have_c1min:

-  if (c1max > c1min)

-    for (c1 = c1max; c1 >= c1min; c1--)

-      for (c0 = c0min; c0 <= c0max; c0++)

-	{

-	  for (c2 = c2min; c2 <= c2max; c2++)

-	    {

-	      histp = &histogram[c0][c1][c2][c3min];

-	      for (c3 = c3min; c3 <= c3max; c3++)

-		if (*histp++ != 0)

-		  {

-		    boxp->c1max = c1max = c1;

-		    goto have_c1max;

-		  }

-	    }

-	}

-have_c1max:

-  /* The original version hand-rolled the array lookup a little, but

-     with four dimensions, I don't even want to think about it. TBB */

-  if (c2max > c2min)

-    for (c2 = c2min; c2 <= c2max; c2++)

-      for (c0 = c0min; c0 <= c0max; c0++)

-	for (c1 = c1min; c1 <= c1max; c1++)

-	  for (c3 = c3min; c3 <= c3max; c3++)

-	    if (histogram[c0][c1][c2][c3] != 0)

-	      {

-		boxp->c2min = c2min = c2;

-		goto have_c2min;

-	      }

-have_c2min:

-  if (c2max > c2min)

-    for (c2 = c2max; c2 >= c2min; c2--)

-      for (c0 = c0min; c0 <= c0max; c0++)

-	for (c1 = c1min; c1 <= c1max; c1++)

-	  for (c3 = c3min; c3 <= c3max; c3++)

-	    if (histogram[c0][c1][c2][c3] != 0)

-	      {

-		boxp->c2max = c2max = c2;

-		goto have_c2max;

-	      }

-have_c2max:

-  if (c3max > c3min)

-    for (c3 = c3min; c3 <= c3max; c3++)

-      for (c0 = c0min; c0 <= c0max; c0++)

-	for (c1 = c1min; c1 <= c1max; c1++)

-	  for (c2 = c2min; c2 <= c2max; c2++)

-	    if (histogram[c0][c1][c2][c3] != 0)

-	      {

-		boxp->c3min = c3min = c3;

-		goto have_c3min;

-	      }

-have_c3min:

-  if (c3max > c3min)

-    for (c3 = c3max; c3 >= c3min; c3--)

-      for (c0 = c0min; c0 <= c0max; c0++)

-	for (c1 = c1min; c1 <= c1max; c1++)

-	  for (c2 = c2min; c2 <= c2max; c2++)

-	    if (histogram[c0][c1][c2][c3] != 0)

-	      {

-		boxp->c3max = c3max = c3;

-		goto have_c3max;

-	      }

-have_c3max:

-  /* Update box volume.

-   * We use 2-norm rather than real volume here; this biases the method

-   * against making long narrow boxes, and it has the side benefit that

-   * a box is splittable iff norm > 0.

-   * Since the differences are expressed in histogram-cell units,

-   * we have to shift back to 8-bit units to get consistent distances; 

-   * after which, we scale according to the selected distance scale factors.

-   * TBB: alpha shifts back to 7 bit units. That was accounted for in the

-   * alpha scale factor. 

-   */

-  dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE;

-  dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE;

-  dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE;

-  dist3 = ((c3max - c3min) << C3_SHIFT) * C3_SCALE;

-  boxp->volume = dist0 * dist0 + dist1 * dist1 + dist2 * dist2 + dist3 * dist3;

-

-  /* Now scan remaining volume of box and compute population */

-  ccount = 0;

-  for (c0 = c0min; c0 <= c0max; c0++)

-    for (c1 = c1min; c1 <= c1max; c1++)

-      for (c2 = c2min; c2 <= c2max; c2++)

-	{

-	  histp = &histogram[c0][c1][c2][c3min];

-	  for (c3 = c3min; c3 <= c3max; c3++, histp++)

-	    if (*histp != 0)

-	      {

-		ccount++;

-	      }

-	}

-  boxp->colorcount = ccount;

-}

-

-

-static int

-median_cut (my_cquantize_ptr cquantize,

-	    boxptr boxlist, int numboxes,

-	    int desired_colors)

-/* Repeatedly select and split the largest box until we have enough boxes */

-{

-  int n, lb;

-  int c0, c1, c2, c3, cmax;

-  register boxptr b1, b2;

-

-  while (numboxes < desired_colors)

-    {

-      /* Select box to split.

-       * Current algorithm: by population for first half, then by volume.

-       */

-      if (numboxes * 2 <= desired_colors)

-	{

-	  b1 = find_biggest_color_pop (boxlist, numboxes);

-	}

-      else

-	{

-	  b1 = find_biggest_volume (boxlist, numboxes);

-	}

-      if (b1 == NULL)		/* no splittable boxes left! */

-	break;

-      b2 = &boxlist[numboxes];	/* where new box will go */

-      /* Copy the color bounds to the new box. */

-      b2->c0max = b1->c0max;

-      b2->c1max = b1->c1max;

-      b2->c2max = b1->c2max;

-      b2->c3max = b1->c3max;

-      b2->c0min = b1->c0min;