--- a/src/glyphs-x.c	Mon Aug 13 10:35:55 2007 +0200
+++ b/src/glyphs-x.c	Mon Aug 13 10:36:47 2007 +0200
@@ -61,26 +61,12 @@
 
 #include "sysfile.h"
 
-#ifdef HAVE_PNG
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <png.h>
-#ifdef __cplusplus
-}
-#endif
-#else
 #include <setjmp.h>
-#endif
+
 #ifdef FILE_CODING
 #include "file-coding.h"
 #endif
 
-#undef HAVE_PNG
-#undef HAVE_TIFF
-#undef HAVE_JPEG
-#undef HAVE_GIF
-
 #if INTBITS == 32
 # define FOUR_BYTE_TYPE unsigned int
 #elif LONGBITS == 32
@@ -98,26 +84,6 @@
 Lisp_Object Qxface;
 #endif
 
-#ifdef HAVE_TIFF
-DEFINE_IMAGE_INSTANTIATOR_FORMAT (tiff);
-Lisp_Object Qtiff;
-#endif
-
-#ifdef HAVE_JPEG
-DEFINE_IMAGE_INSTANTIATOR_FORMAT (jpeg);
-Lisp_Object Qjpeg;
-#endif
-
-#ifdef HAVE_GIF
-DEFINE_IMAGE_INSTANTIATOR_FORMAT (gif);
-Lisp_Object Qgif;
-#endif
-
-#ifdef HAVE_PNG
-DEFINE_IMAGE_INSTANTIATOR_FORMAT (png);
-Lisp_Object Qpng;
-#endif
-
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (cursor_font);
 Lisp_Object Qcursor_font;
 
@@ -1499,1792 +1465,6 @@
 #endif /* HAVE_XPM */
 
 
-#ifdef HAVE_JPEG
-
-/**********************************************************************
- *                             JPEG                                   *
- **********************************************************************/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <jpeglib.h>
-#include <jerror.h>
-#ifdef __cplusplus
-}
-#endif
-
-/*#define USE_TEMP_FILES_FOR_JPEG_IMAGES 1*/
-static void
-jpeg_validate (Lisp_Object instantiator)
-{
-  file_or_data_must_be_present (instantiator);
-}
-
-static Lisp_Object
-jpeg_normalize (Lisp_Object inst, Lisp_Object console_type)
-{
-  return simple_image_type_normalize (inst, console_type, Qjpeg);
-}
-
-static int
-jpeg_possible_dest_types (void)
-{
-  return IMAGE_COLOR_PIXMAP_MASK;
-}
-
-/* To survive the otherwise baffling complexity of making sure
-   everything gets cleaned up in the presence of an error, we
-   use an unwind_protect(). */
-
-struct jpeg_unwind_data
-{
-  Display *dpy;
-  Colormap cmap;
-  /* Stream that we need to close */
-  FILE *instream;
-  /* Object that holds state info for JPEG decoding */
-  struct jpeg_decompress_struct *cinfo_ptr;
-  /* EImage data */
-  unsigned char *eimage;
-  /* Pixels to keep around while the image is active */
-  unsigned long *pixels;
-  int npixels, pixcount;
-  /* Client-side image structure */
-  XImage *ximage;
-  /* Tempfile to remove */
-#ifdef USE_TEMP_FILES_FOR_JPEG_IMAGES
-  char tempfile[50];
-  int tempfile_needs_to_be_removed;
-#endif
-};
-
-static Lisp_Object
-jpeg_instantiate_unwind (Lisp_Object unwind_obj)
-{
-  struct jpeg_unwind_data *data =
-    (struct jpeg_unwind_data *) get_opaque_ptr (unwind_obj);
-
-  free_opaque_ptr (unwind_obj);
-  if (data->cinfo_ptr)
-    jpeg_destroy_decompress (data->cinfo_ptr);
-
-  if (data->instream)
-    fclose (data->instream);
-
-  if (data->eimage) xfree (data->eimage);
-
-  if (data->npixels > 0)
-      XFreeColors (data->dpy, data->cmap, data->pixels, data->npixels, 0L);
-  if (data->pixcount)
-      xfree (data->pixels);
-
-  if (data->ximage)
-    {
-      if (data->ximage->data)
-        {
-	  xfree (data->ximage->data);
-          data->ximage->data = 0;
-        }
-      XDestroyImage (data->ximage);
-    }
-#if USE_TEMP_FILES_FOR_JPEG_IMAGES
-  if (data->tempfile_needs_to_be_removed)
-    unlink (data->tempfile);
-#endif
-
-  return Qnil;
-}
-
-/*
- * ERROR HANDLING:
- *
- * The JPEG library's standard error handler (jerror.c) is divided into
- * several "methods" which you can override individually.  This lets you
- * adjust the behavior without duplicating a lot of code, which you might
- * have to update with each future release.
- *
- * Our example here shows how to override the "error_exit" method so that
- * control is returned to the library's caller when a fatal error occurs,
- * rather than calling exit() as the standard error_exit method does.
- *
- * We use C's setjmp/longjmp facility to return control.  This means that the
- * routine which calls the JPEG library must first execute a setjmp() call to
- * establish the return point.  We want the replacement error_exit to do a
- * longjmp().  But we need to make the setjmp buffer accessible to the
- * error_exit routine.  To do this, we make a private extension of the
- * standard JPEG error handler object.  (If we were using C++, we'd say we
- * were making a subclass of the regular error handler.)
- *
- * Here's the extended error handler struct:
- */
-
-struct my_jpeg_error_mgr
-{
-  struct jpeg_error_mgr pub;	/* "public" fields */
-  jmp_buf setjmp_buffer;	/* for return to caller */
-};
-
-#if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
-METHODDEF(void)
-#else
-METHODDEF void
-#endif
-our_init_source (j_decompress_ptr cinfo)
-{
-}
-
-#if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
-METHODDEF(boolean)
-#else
-METHODDEF boolean
-#endif
-our_fill_input_buffer (j_decompress_ptr cinfo)
-{
-  /* Insert a fake EOI marker */
-  struct jpeg_source_mgr *src = cinfo->src;
-  static JOCTET buffer[2];
-
-  buffer[0] = (JOCTET) 0xFF;
-  buffer[1] = (JOCTET) JPEG_EOI;
-
-  src->next_input_byte = buffer;
-  src->bytes_in_buffer = 2;
-  return TRUE;
-}
-
-#if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
-METHODDEF(void)
-#else
-METHODDEF void
-#endif
-our_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
-{
-  struct jpeg_source_mgr *src = NULL;
-
-  src = (struct jpeg_source_mgr *) cinfo->src;
-
-  if (!src)
-    {
-      return;
-    } else if (num_bytes > src->bytes_in_buffer)
-      {
-	ERREXIT(cinfo, JERR_INPUT_EOF);
-	/*NOTREACHED*/
-      }
-
-  src->bytes_in_buffer -= num_bytes;
-  src->next_input_byte += num_bytes;
-}
-
-#if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
-METHODDEF(void)
-#else
-METHODDEF void
-#endif
-our_term_source (j_decompress_ptr cinfo)
-{
-}
-
-typedef struct
-{
-  struct jpeg_source_mgr pub;
-} our_jpeg_source_mgr;
-
-static void
-jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, unsigned int len)
-{
-  struct jpeg_source_mgr *src;
-
-  if (cinfo->src == NULL)
-    {	/* first time for this JPEG object? */
-      cinfo->src = (struct jpeg_source_mgr *)
-	(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-				    sizeof(our_jpeg_source_mgr));
-      src = (struct jpeg_source_mgr *) cinfo->src;
-      src->next_input_byte = data;
-    }
-  src = (struct jpeg_source_mgr *) cinfo->src;
-  src->init_source = our_init_source;
-  src->fill_input_buffer = our_fill_input_buffer;
-  src->skip_input_data = our_skip_input_data;
-  src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
-  src->term_source = our_term_source;
-  src->bytes_in_buffer = len;
-  src->next_input_byte = data;
-}
-
-#if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
-METHODDEF(void)
-#else
-METHODDEF void
-#endif
-my_jpeg_error_exit (j_common_ptr cinfo)
-{
-  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
-  struct my_jpeg_error_mgr *myerr = (struct my_jpeg_error_mgr *) cinfo->err;
-
-  /* Return control to the setjmp point */
-  longjmp (myerr->setjmp_buffer, 1);
-}
-
-#if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
-METHODDEF(void)
-#else
-METHODDEF void
-#endif
-my_jpeg_output_message (j_common_ptr cinfo)
-{
-  char buffer[JMSG_LENGTH_MAX];
-
-  /* Create the message */
-  (*cinfo->err->format_message) (cinfo, buffer);
-  warn_when_safe (Qjpeg, Qinfo, "%s", buffer);
-}
-
-/* The code in this routine is based on example.c from the JPEG library
-   source code and from gif_instantiate() */
-static void
-jpeg_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
-		  Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		  int dest_mask, Lisp_Object domain)
-{
-  struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
-  Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
-  Display *dpy;
-  Colormap cmap;
-  Visual *vis;
-  /* It is OK for the unwind data to be local to this function,
-     because the unwind-protect is always executed when this
-     stack frame is still valid. */
-  struct jpeg_unwind_data unwind;
-  int speccount = specpdl_depth ();
-
-  /* This struct contains the JPEG decompression parameters and pointers to
-   * working space (which is allocated as needed by the JPEG library).
-   */
-  struct jpeg_decompress_struct cinfo;
-  /* We use our private extension JPEG error handler.
-   * Note that this struct must live as long as the main JPEG parameter
-   * struct, to avoid dangling-pointer problems.
-   */
-  struct my_jpeg_error_mgr jerr;
-
-  if (!DEVICE_X_P (XDEVICE (device)))
-    signal_simple_error ("Not an X device", device);
-
-  dpy = DEVICE_X_DISPLAY (XDEVICE (device));
-  cmap = DEVICE_X_COLORMAP (XDEVICE(device));
-  vis = DEVICE_X_VISUAL (XDEVICE(device));
-
-  /* Step -1: First record our unwind-protect, which will clean up after
-     any exit, normal or not */
-
-  xzero (unwind);
-  unwind.dpy = dpy;
-  unwind.cmap = cmap;
-  record_unwind_protect (jpeg_instantiate_unwind, make_opaque_ptr (&unwind));
-
-#ifdef USE_TEMP_FILES_FOR_JPEG_IMAGES
-  /* Step 0: Write out to a temp file.
-
-     The JPEG routines require you to read from a file unless
-     you provide your own special input handlers, which I don't
-     feel like doing. */
-  {
-    Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
-
-    assert (!NILP (data));
-
-    write_lisp_string_to_temp_file (data, unwind.tempfile);
-    unwind.tempfile_needs_to_be_removed = 1;
-
-    /* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
-     * requires it in order to read binary files.
-     */
-
-    if ((unwind.instream = fopen (unwind.tempfile, "r")) == NULL)
-      report_file_error ("Opening JPEG temp file",
-			 list1 (build_string (unwind.tempfile)));
-  }
-#endif
-
-  /* Step 1: allocate and initialize JPEG decompression object */
-
-  /* We set up the normal JPEG error routines, then override error_exit. */
-  cinfo.err = jpeg_std_error (&jerr.pub);
-  jerr.pub.error_exit = my_jpeg_error_exit;
-  jerr.pub.output_message = my_jpeg_output_message;
-
-  /* Establish the setjmp return context for my_error_exit to use. */
-  if (setjmp (jerr.setjmp_buffer))
-    {
-      /* If we get here, the JPEG code has signaled an error.
-       * We need to clean up the JPEG object, close the input file, and return.
-       */
-
-      {
-	Lisp_Object errstring;
-	char buffer[JMSG_LENGTH_MAX];
-
-	/* Create the message */
-	(*cinfo.err->format_message) ((j_common_ptr) &cinfo, buffer);
-	errstring = build_string (buffer);
-
-	signal_image_error_2 ("JPEG decoding error",
-			      errstring, instantiator);
-      }
-    }
-
-  /* Now we can initialize the JPEG decompression object. */
-  jpeg_create_decompress (&cinfo);
-  unwind.cinfo_ptr = &cinfo;
-
-  /* Step 2: specify data source (eg, a file) */
-
-#ifdef USE_TEMP_FILES_FOR_JPEG_IMAGES
-  jpeg_stdio_src (&cinfo, unwind.instream);
-#else
-  {
-    Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
-    CONST Extbyte *bytes;
-    Extcount len;
-
-    /* #### This is a definite problem under Mule due to the amount of
-       stack data it might allocate.  Need to be able to convert and
-       write out to a file. */
-    GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
-    jpeg_memory_src (&cinfo, (JOCTET *) bytes, len);
-  }
-#endif
-
-  /* Step 3: read file parameters with jpeg_read_header() */
-
-  jpeg_read_header (&cinfo, TRUE);
-  /* We can ignore the return value from jpeg_read_header since
-   *   (a) suspension is not possible with the stdio data source, and
-   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
-   * See libjpeg.doc for more info.
-   */
-
-#if 0
-  /* Step 4: set parameters for decompression.   */
-
-  if (vis->class == PseudoColor)
-    {
-    
-      /* We request that the JPEG file be automatically quantized into
-	 8-bit color in case it's not already (many JPEGs are stored in
-	 24-bit color).  "Two-pass quantize" means that the colormap
-	 is determined on-the-fly for this particular image rather than
-	 quantizing to a supplied colormap.  We can get away with this
-	 because we then use allocate_nearest_color().
-
-	 #### Note of course that this is not the most color-effective
-	 way of doing things -- we could quantize an image that has
-	 lots of very similar colors, and eat up the colormap with these
-	 (useless to other images) colors.  Unfortunately I don't think
-	 there's any "general" way of maximizing the overall image
-	 quality of lots of images, given that we don't know the
-	 colors of the images until we come across each one.  Best we
-	 could do would be various sorts of heuristics, which I don't
-	 feel like dealing with now.  A better scheme would be the
-	 way things are done under MS Windows, where the colormap is
-	 dynamically adjusted for various applications; but that kind
-	 of thing would have to be provided by X, which it isn't. */
-      
-      cinfo.quantize_colors = TRUE;
-      cinfo.two_pass_quantize = TRUE;
-      cinfo.colormap = NULL;
-    }
-  
-  /* Step 5: Start decompressor */
-
-  jpeg_start_decompress (&cinfo);
-  /* We can ignore the return value since suspension is not possible
-   * with the stdio data source.
-   */
-
-  /* At this point we know the size of the image and the colormap. */
-
-  /* Step 5.33: Allocate the colors */
-  if (vis->class == PseudoColor)
-    {
-      int i;
-      unwind.pixcount = 32;
-      unwind.pixels = xnew_array (unsigned long, unwind.pixcount);
-      unwind.npixels = 0;
-
-      /* Allocate pixels for the various colors. */
-      for (i = 0; i < cinfo.actual_number_of_colors; i++)
-	{
-	  XColor color;
-	  int ri, gi, bi, res;
-
-	  ri = 0;
-	  gi = cinfo.out_color_components > 1 ? 1 : 0;
-	  bi = cinfo.out_color_components > 2 ? 2 : 0;
-
-	  /* Ok... apparently, an entry of cinfo.colormap can be NULL if
-	     there are no bits of that color in the image.  How incredibly
-	     gross.  Wouldn't it be nice to have exceptions!? */
-	  color.red = cinfo.colormap[ri] ? cinfo.colormap[ri][i] << 8 : 0;
-	  color.green = cinfo.colormap[gi] ? cinfo.colormap[gi][i] << 8 : 0;
-	  color.blue = cinfo.colormap[bi] ? cinfo.colormap[bi][i] << 8 : 0;
-	  color.flags = DoRed | DoGreen | DoBlue;
-
-	  res = allocate_nearest_color (dpy, cmap, vis, &color);
-	  if (res > 0 && res < 3)
-	    {
-	      DO_REALLOC(unwind.pixels, unwind.pixcount, unwind.npixels+1, unsigned long);
-	      unwind.pixels[unwind.npixels] = color.pixel;
-	      unwind.npixels++;
-	    }
-	}
-    }
-
-  /* Step 5.66: Create the image */
-  {
-    int height = cinfo.output_height;
-    int width = cinfo.output_width;
-    int depth;
-    int bitmap_pad;
-
-    depth = DEVICE_X_DEPTH(XDEVICE(device));
-
-    /* first get bitmap_pad (from XPM) */
-    bitmap_pad = ((depth > 16) ? 32 :
-		  (depth >  8) ? 16 :
-		  8);
-
-    unwind.ximage = XCreateImage (dpy, vis, depth, ZPixmap, 0, 0, width, height,
-				  bitmap_pad, 0);
-
-    if (!unwind.ximage)
-      signal_image_error ("Unable to create X image struct", instantiator);
-
-    /* now that bytes_per_line must have been set properly alloc data */
-    unwind.ximage->data =
-      (char *) xmalloc (unwind.ximage->bytes_per_line * height);
-  }
-
-  /* Step 6: Read in the data and put into image */
-  {
-    JSAMPARRAY row_buffer;	/* Output row buffer */
-    int row_stride;		/* physical row width in output buffer */
-
-    /* We may need to do some setup of our own at this point before reading
-     * the data.  After jpeg_start_decompress() we have the correct scaled
-     * output image dimensions available, as well as the output colormap
-     * if we asked for color quantization.
-     * In this example, we need to make an output work buffer of the right size.
-     */
-    /* JSAMPLEs per row in output buffer.
-       Since we asked for quantized output, cinfo.output_components
-       will always be 1. */
-    row_stride = cinfo.output_width * cinfo.output_components;
-    /* Make a one-row-high sample array that will go away when done
-       with image */
-    row_buffer = ((*cinfo.mem->alloc_sarray)
-		  ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1));
-
-    /* Here we use the library's state variable cinfo.output_scanline as the
-     * loop counter, so that we don't have to keep track ourselves.
-     */
-    while (cinfo.output_scanline < cinfo.output_height)
-      {
-	int i;
-	int scanline = cinfo.output_scanline;
-
-	/* jpeg_read_scanlines expects an array of pointers to scanlines.
-	 * Here the array is only one element long, but you could ask for
-	 * more than one scanline at a time if that's more convenient.
-	 */
-	jpeg_read_scanlines (&cinfo, row_buffer, 1);
-
-	for (i = 0; i < (int) cinfo.output_width; i++)
-	  XPutPixel (unwind.ximage, i, scanline,
-		     /* Let's make sure we avoid getting bit like
-			what happened for GIF's.  It's probably the
-			case that JSAMPLE's are unsigned chars as
-			opposed to chars, but you never know.
-
-			(They could even be shorts if the library
-			was compiled with 12-bit samples -- ####
-			We should deal with this possibility) */
-		     unwind.pixels[(unsigned char) row_buffer[0][i]]);
-      }
-  }
-#else
-  {
-    /* Step 4: set parameters for decompression.   */
-
-    /* Now that we're using EImages, use the default of all data in 24bit color.
-       The backend routine will take care of any necessary reductions. */
-
-    /* Step 5: Start decompressor */
-    jpeg_start_decompress (&cinfo);
-
-    /* Step 6: Read in the data and put into EImage format (8bit RGB triples)*/
-
-    unwind.eimage = (unsigned char*) xmalloc (cinfo.output_width * cinfo.output_height * 3);
-    if (!unwind.eimage)
-      signal_image_error("Unable to allocate enough memory for image", instantiator);
-
-    {
-      JSAMPARRAY row_buffer;	/* Output row buffer */
-      JSAMPLE *jp;
-      int row_stride;		/* physical row width in output buffer */
-      unsigned char *op = unwind.eimage;
-
-      /* We may need to do some setup of our own at this point before reading
-       * the data.  After jpeg_start_decompress() we have the correct scaled
-       * output image dimensions available
-       * We need to make an output work buffer of the right size.
-       */
-      /* JSAMPLEs per row in output buffer. */
-      row_stride = cinfo.output_width * cinfo.output_components;
-      /* Make a one-row-high sample array that will go away when done
-	 with image */
-      row_buffer = ((*cinfo.mem->alloc_sarray)
-		    ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1));
-
-      /* Here we use the library's state variable cinfo.output_scanline as the
-       * loop counter, so that we don't have to keep track ourselves.
-       */
-      while (cinfo.output_scanline < cinfo.output_height)
-	{
-	  int i;
-
-	  /* jpeg_read_scanlines expects an array of pointers to scanlines.
-	   * Here the array is only one element long, but you could ask for
-	   * more than one scanline at a time if that's more convenient.
-	   */
-	  (void) jpeg_read_scanlines (&cinfo, row_buffer, 1);
-	  jp = row_buffer[0];
-	  for (i = 0; i < cinfo.output_width; i++)
-	    {
-	      int clr;
-#if (BITS_IN_JSAMPLE == 8)
-	      for (clr = 0; clr < 3; clr++)
-		*op++ = (unsigned char)*jp++;
-#else /* other option is 12 */
-	      for (clr = 0; clr < 3; clr++)
-		*op++ = (unsigned char)(*jp++ >> 4);
-#endif
-	    }
-	}
-      unwind.ximage = convert_EImage_to_XImage (device, cinfo.output_width, cinfo.output_height, unwind.eimage,
-				     &unwind.pixels, &unwind.pixcount, &unwind.npixels);
-      if (!unwind.ximage)
-	signal_image_error("JPEG conversion failed", instantiator);
-    }
-  }
-  
-#endif
-  /* Step 6.5: Create the pixmap and set up the image instance */
-  init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
-				    cmap, unwind.pixels, unwind.npixels,
-				    instantiator);
-
-  /* Step 7: Finish decompression */
-
-  jpeg_finish_decompress (&cinfo);
-  /* We can ignore the return value since suspension is not possible
-   * with the stdio data source.
-   */
-
-  /* And we're done!
-
-     Now that we've succeeded, we don't want the pixels
-     freed right now.  They're kept around in the image instance
-     structure until it's destroyed. */
-  unwind.npixels = 0;
-  unwind.pixcount = 0;
-
-  /* This will clean up everything else. */
-  unbind_to (speccount, Qnil);
-}
-
-#endif /* HAVE_JPEG */
-
-#ifdef HAVE_GIF
-/* #define USE_TEMP_FILES_FOR_GIF_IMAGES */
-/**********************************************************************
- *                               GIF                                  *
- **********************************************************************/
-
-#include <gif_lib.h>
-
-static void
-gif_validate (Lisp_Object instantiator)
-{
-  file_or_data_must_be_present (instantiator);
-}
-
-static Lisp_Object
-gif_normalize (Lisp_Object inst, Lisp_Object console_type)
-{
-  return simple_image_type_normalize (inst, console_type, Qgif);
-}
-
-static int
-gif_possible_dest_types (void)
-{
-  return IMAGE_COLOR_PIXMAP_MASK;
-}
-
-/* To survive the otherwise baffling complexity of making sure
-   everything gets cleaned up in the presence of an error, we
-   use an unwind_protect(). */
-
-struct gif_unwind_data
-{
-  Display *dpy;
-  Colormap cmap;
-  unsigned char *eimage;
-  /* Object that holds the decoded data from a GIF file */
-  GifFileType *giffile;
-  /* Pixels to keep around while the image is active */
-  unsigned long *pixels;
-  int npixels, pixcount;
-  /* Client-side image structure */
-  XImage *ximage;
-#ifdef USE_TEMP_FILES_FOR_GIF_IMAGES
-  /* Tempfile to remove */
-  char tempfile[50];
-  int tempfile_needs_to_be_removed;
-#endif
-};
-
-static Lisp_Object
-gif_instantiate_unwind (Lisp_Object unwind_obj)
-{
-  struct gif_unwind_data *data =
-    (struct gif_unwind_data *) get_opaque_ptr (unwind_obj);
-
-  free_opaque_ptr (unwind_obj);
-  if (data->giffile)
-    {
-      DGifCloseFile (data->giffile);
-      GifFree(data->giffile);
-    }
-  if (data->eimage) xfree(data->eimage);
-#ifdef USE_TEMP_FILES_FOR_GIF_IMAGES
-  if (data->tempfile_needs_to_be_removed)
-    unlink (data->tempfile);
-#endif
-  if (data->npixels > 0)
-    XFreeColors (data->dpy, data->cmap, data->pixels, data->npixels, 0L);
-  if (data->pixcount > 0)
-    xfree (data->pixels);
-  if (data->ximage)
-    {
-      if (data->ximage->data)
-        {
-	  xfree (data->ximage->data);
-          data->ximage->data = 0;
-        }
-      XDestroyImage (data->ximage);
-    }
-
-  return Qnil;
-}
-
-#ifndef USE_TEMP_FILES_FOR_GIF_IMAGES
-typedef struct gif_memory_storage
-{
-  Extbyte *bytes;		/* The data       */
-  Extcount len;			/* How big is it? */
-  int index;			/* Where are we?  */
-} gif_memory_storage;
-
-static size_t
-gif_read_from_memory(GifByteType *buf, size_t size, VoidPtr data)
-{
-  gif_memory_storage *mem = (gif_memory_storage*)data;
-
-  if (size > (mem->len - mem->index))
-    return -1;
-  memcpy(buf, mem->bytes + mem->index, size);
-  mem->index = mem->index + size;
-  return size;
-}
-
-static int
-gif_memory_close(VoidPtr data)
-{
-  return 0;
-}
-
-#endif
-struct gif_error_struct
-{
-  CONST char *err_str;		/* return the error string */
-  jmp_buf setjmp_buffer;	/* for return to caller */
-};
-
-static void
-gif_error_func(CONST char *err_str, VoidPtr error_ptr)
-{
-  struct gif_error_struct *error_data = (struct gif_error_struct*)error_ptr;
-
-  /* return to setjmp point */
-  error_data->err_str = err_str;
-  longjmp (error_data->setjmp_buffer, 1);
-}
-
-static void
-gif_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
-		 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		 int dest_mask, Lisp_Object domain)
-{
-  struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
-  Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
-  Display *dpy;
-  Colormap cmap;
-  Visual *vis;
-  /* It is OK for the unwind data to be local to this function,
-     because the unwind-protect is always executed when this
-     stack frame is still valid. */
-  struct gif_unwind_data unwind;
-  int speccount = specpdl_depth ();
-#ifndef USE_TEMP_FILES_FOR_GIF_IMAGES
-  gif_memory_storage mem_struct;
-  struct gif_error_struct gif_err;
-  Extbyte *bytes;
-  Extcount len;
-#endif
-  if (!DEVICE_X_P (XDEVICE (device)))
-    signal_simple_error ("Not an X device", device);
-
-  dpy = DEVICE_X_DISPLAY (XDEVICE (device));
-  cmap = DEVICE_X_COLORMAP (XDEVICE(device));
-  vis = DEVICE_X_VISUAL (XDEVICE(device));
-
-  xzero (unwind);
-  unwind.dpy = dpy;
-  unwind.cmap = cmap;
-  record_unwind_protect (gif_instantiate_unwind, make_opaque_ptr (&unwind));
-
-  /* 1. Now decode the data. */
-
-  {
-    Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
-
-    assert (!NILP (data));
-
-    if (!(unwind.giffile = GifSetup()))
-      signal_image_error ("Insufficent memory to instantiate GIF image", instantiator);
-
-    /* set up error facilities */
-    if (setjmp(gif_err.setjmp_buffer))
-      {
-	/* An error was signaled. No clean up is needed, as unwind handles that
-	   for us.  Just pass the error along. */
-	Lisp_Object errstring;
-	errstring = build_string (gif_err.err_str);
-	signal_image_error_2 ("GIF decoding error", errstring, instantiator);
-      }
-    GifSetErrorFunc(unwind.giffile, (Gif_error_func)gif_error_func, (VoidPtr)&gif_err);
-    
-#ifdef USE_TEMP_FILES_FOR_GIF_IMAGES
-    write_lisp_string_to_temp_file (data, unwind.tempfile);
-    unwind.tempfile_needs_to_be_removed = 1;
-    DGifOpenFileName (unwind.giffile, unwind.tempfile);
-#else
-    GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
-    mem_struct.bytes = bytes;
-    mem_struct.len = len;
-    mem_struct.index = 0;
-    GifSetReadFunc(unwind.giffile, gif_read_from_memory, (VoidPtr)&mem_struct);
-    GifSetCloseFunc(unwind.giffile, gif_memory_close, (VoidPtr)&mem_struct);
-    DGifInitRead(unwind.giffile);
-#endif
-    /* Then slurp the image into memory, decoding along the way.
-       The result is the image in a simple one-byte-per-pixel
-       format (#### the GIF routines only support 8-bit GIFs,
-       it appears). */
-    DGifSlurp (unwind.giffile);
-  }
-
-#if 0
-  /* 2. Now allocate the colors for the image. */
-  {
-    int i;
-    ColorMapObject *cmo = unwind.giffile->SColorMap;
-    /* Just in case the image contains out-of-range pixels, we go
-       ahead and allocate space for all of them. */
-    unwind.pixels = xnew_array (unsigned long, 256);
-    unwind.npixels = 0;
-
-    for (i = 0; i < 256; i++)
-      unwind.pixels[i] = 0;   /* Use a reasonable color for out of range. */
-
-    /* Allocate pixels for the various colors. */
-    for (i = 0; i < cmo->ColorCount; i++)
-      {
-	int res;
-	XColor color;
-
-	color.red   = cmo->Colors[i].Red   << 8;
-	color.green = cmo->Colors[i].Green << 8;
-	color.blue  = cmo->Colors[i].Blue  << 8;
-	color.flags = DoRed | DoGreen | DoBlue;
-
-	res = allocate_nearest_color (dpy, cmap, vis, &color);
-	if (res > 0 && res < 3)
-	  {
-	    unwind.pixels[unwind.npixels] = color.pixel;
-	    unwind.npixels++;
-	  }
-      }
-  }
-
-  /* 3. Now create the image */
-  {
-    int height = unwind.giffile->SHeight;
-    int width = unwind.giffile->SWidth;
-    int depth;
-    int bitmap_pad;
-    int i, j, row, pass, interlace;
-    /* interlaced gifs have rows in this order:
-       0, 8, 16, ..., 4, 12, 20, ..., 2, 6, 10, ..., 1, 3, 5, ...  */
-    static int InterlacedOffset[] = { 0, 4, 2, 1 };
-    static int InterlacedJumps[] = { 8, 8, 4, 2 };
-
-    depth = DEVICE_X_DEPTH(XDEVICE(device));
-
-    /* first get bitmap_pad (from XPM) */
-    bitmap_pad = ((depth > 16) ? 32 :
-		  (depth >  8) ? 16 :
-		  8);
-
-    unwind.ximage = XCreateImage (dpy, vis,
-				  depth, ZPixmap, 0, 0, width, height,
-				  bitmap_pad, 0);
-
-    if (!unwind.ximage)
-      signal_image_error ("Unable to create X image struct", instantiator);
-
-    /* now that bytes_per_line must have been set properly alloc data */
-    unwind.ximage->data =
-      (char *) xmalloc (unwind.ximage->bytes_per_line * height);
-
-    /* write the data --
-       #### XPutPixel() is a client-side-only function but could
-       still be slow.  Another possibility is to just convert to
-       XPM format and use the Xpm routines, which optimize this
-       stuff; but it's doubtful that this will be faster in the
-       long run, what with all the XPM overhead.  If this proves
-       to be a bottleneck here, maybe we should just copy the
-       optimization routines from XPM (they're in turn mostly
-       copied from the Xlib source code). */
-
-    /* Note: We just use the first image in the file and ignore the rest.
-             We check here that that image covers the full "screen" size.
-	     I don't know whether that's always the case.
-             -dkindred@cs.cmu.edu  */
-    if (unwind.giffile->SavedImages[0].ImageDesc.Height != height
-	|| unwind.giffile->SavedImages[0].ImageDesc.Width != width
-	|| unwind.giffile->SavedImages[0].ImageDesc.Left != 0
-	|| unwind.giffile->SavedImages[0].ImageDesc.Top != 0)
-      signal_image_error ("First image in GIF file is not full size",
-			   instantiator);
-
-    interlace = unwind.giffile->SavedImages[0].ImageDesc.Interlace;
-    pass = 0;
-    row = interlace ? InterlacedOffset[pass] : 0;
-    for (i = 0; i < height; i++)
-      {
-	if (interlace && row >= height)
-	  row = InterlacedOffset[++pass];
-
-	for (j = 0; j < width; j++)
-	  XPutPixel (unwind.ximage, j, row,
-		     unwind.pixels[(unsigned char)
-				  /* incorrect signed declaration
-				     of RasterBits[] */
-				  (unwind.giffile->SavedImages[0].
-				   RasterBits[i * width + j])]);
-
-	row += interlace ? InterlacedJumps[pass] : 1;
-      }
-  }
-#else
-  /* 3. Now create the EImage */
-  {
-    ColorMapObject *cmo = unwind.giffile->SColorMap;
-    int height = unwind.giffile->SHeight;
-    int width = unwind.giffile->SWidth;
-    int i, j, row, pass, interlace;
-    unsigned char *eip;
-    /* interlaced gifs have rows in this order:
-       0, 8, 16, ..., 4, 12, 20, ..., 2, 6, 10, ..., 1, 3, 5, ...  */
-    static int InterlacedOffset[] = { 0, 4, 2, 1 };
-    static int InterlacedJumps[] = { 8, 8, 4, 2 };
-
-    unwind.eimage = (unsigned char*) xmalloc (width * height * 3);
-    if (!unwind.eimage)
-      signal_image_error("Unable to allocate enough memory for image", instantiator);
-
-    /* write the data in EImage format (8bit RGB triples) */
-
-    /* Note: We just use the first image in the file and ignore the rest.
-             We check here that that image covers the full "screen" size.
-	     I don't know whether that's always the case.
-             -dkindred@cs.cmu.edu  */
-    if (unwind.giffile->SavedImages[0].ImageDesc.Height != height
-	|| unwind.giffile->SavedImages[0].ImageDesc.Width != width
-	|| unwind.giffile->SavedImages[0].ImageDesc.Left != 0
-	|| unwind.giffile->SavedImages[0].ImageDesc.Top != 0)
-      signal_image_error ("First image in GIF file is not full size",
-			   instantiator);
-
-    interlace = unwind.giffile->SavedImages[0].ImageDesc.Interlace;
-    pass = 0;
-    row = interlace ? InterlacedOffset[pass] : 0;
-    eip = unwind.eimage;
-    for (i = 0; i < height; i++)
-      {
-	if (interlace && row >= height)
-	  row = InterlacedOffset[++pass];
-	eip = unwind.eimage + (row * width * 3);
-	for (j = 0; j < width; j++)
-	  {
-	    unsigned char pixel = unwind.giffile->SavedImages[0].RasterBits[(i * width) + j];
-	    *eip++ = cmo->Colors[pixel].Red;
-	    *eip++ = cmo->Colors[pixel].Green;
-	    *eip++ = cmo->Colors[pixel].Blue;
-	  }
-	row += interlace ? InterlacedJumps[pass] : 1;
-      }
-    unwind.ximage = convert_EImage_to_XImage (device, width, height, unwind.eimage,
-				   &unwind.pixels, &unwind.pixcount, &unwind.npixels);
-    if (!unwind.ximage)
-      signal_image_error("GIF conversion failed", instantiator);
-  }
-#endif
-  /* 4. Now create the pixmap and set up the image instance */
-  init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
-				    cmap, unwind.pixels, unwind.npixels,
-				    instantiator);
-  /* Now that we've succeeded, we don't want the pixels
-     freed right now.  They're kept around in the image instance
-     structure until it's destroyed. */
-  unwind.npixels = 0;
-  unwind.pixcount = 0;
-  unbind_to (speccount, Qnil);
-}
-
-#endif /* HAVE_GIF */
-
-
-#ifdef HAVE_PNG
-/* #define USE_TEMP_FILES_FOR_PNG_IMAGES 1 */
-
-/**********************************************************************
- *                             PNG                                    *
- **********************************************************************/
-static void
-png_validate (Lisp_Object instantiator)
-{
-  file_or_data_must_be_present (instantiator);
-}
-
-static Lisp_Object
-png_normalize (Lisp_Object inst, Lisp_Object console_type)
-{
-  return simple_image_type_normalize (inst, console_type, Qpng);
-}
-
-static int
-png_possible_dest_types (void)
-{
-  return IMAGE_COLOR_PIXMAP_MASK;
-}
-
-#ifndef USE_TEMP_FILES_FOR_PNG_IMAGES
-struct png_memory_storage
-{
-  CONST Extbyte *bytes;		/* The data       */
-  Extcount len;			/* How big is it? */
-  int index;			/* Where are we?  */
-};
-
-static void
-png_read_from_memory(png_structp png_ptr, png_bytep data,
-		     png_size_t length)
-{
-   struct png_memory_storage *tbr =
-     (struct png_memory_storage *) png_get_io_ptr (png_ptr);
-
-   if (length > (tbr->len - tbr->index))
-     png_error (png_ptr, (png_const_charp) "Read Error");
-   memcpy (data,tbr->bytes + tbr->index,length);
-   tbr->index = tbr->index + length;
-}
-#endif /* !USE_TEMP_FILES_FOR_PNG_IMAGES */
-
-struct png_error_struct
-{
-  CONST char *err_str;
-  jmp_buf setjmp_buffer;	/* for return to caller */
-};
-
-/* jh 98/03/12 - #### AARRRGH! libpng includes jmp_buf inside its own
-   structure, and there are cases where the size can be different from
-   between inside the libarary, and inside the code!  To do an end run
-   around this, use our own error functions, and don't rely on things
-   passed in the png_ptr to them.  This is an ugly hack and must
-   go away when the lisp engine is threaded! */
-static struct png_error_struct png_err_stct;
-
-static void
-png_error_func (png_structp png_ptr, png_const_charp msg)
-{
-  png_err_stct.err_str = msg;
-  longjmp (png_err_stct.setjmp_buffer, 1);
-}
-
-static void
-png_warning_func (png_structp png_ptr, png_const_charp msg)
-{
-  warn_when_safe (Qpng, Qinfo, "%s", msg);
-}
-
-struct png_unwind_data
-{
-  Display *dpy;
-  Colormap cmap;
-  FILE *instream;
-  unsigned char *eimage;
-  png_structp png_ptr;
-  png_infop info_ptr;
-  unsigned long *pixels;
-  int npixels, pixcount;
-  XImage *ximage;
-#ifdef USE_TEMP_FILES_FOR_PNG_IMAGESS
-  char tempfile[50];
-  int tempfile_needs_to_be_removed;
-#endif
-};
-
-static Lisp_Object
-png_instantiate_unwind (Lisp_Object unwind_obj)
-{
-  struct png_unwind_data *data =
-    (struct png_unwind_data *) get_opaque_ptr (unwind_obj);
-
-  free_opaque_ptr (unwind_obj);
-  if (data->png_ptr)
-    png_destroy_read_struct (&(data->png_ptr), &(data->info_ptr), (png_infopp)NULL);
-  if (data->instream)
-    fclose (data->instream);
-  if (data->npixels > 0)
-    XFreeColors (data->dpy, data->cmap, data->pixels, data->npixels, 0L);
-  if (data->pixcount > 0)
-    xfree (data->pixels);
-
-  if (data->eimage)
-    xfree (data->eimage);
-  if (data->ximage)
-    {
-      if (data->ximage->data)
-	{
-	  xfree (data->ximage->data);
-	  data->ximage->data = 0;
-	}
-      XDestroyImage (data->ximage);
-    }
-#ifdef USE_TEMP_FILES_FOR_PNG_IMAGES
-  if (data->tempfile_needs_to_be_removed)
-    unlink (data->tempfile);
-#endif
-  return Qnil;
-}
-
-static void
-png_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
-		 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		 int dest_mask, Lisp_Object domain)
-{
-  struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
-  Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
-  Display *dpy;
-  Colormap cmap;
-  Visual *vis;
-  struct png_unwind_data unwind;
-  int speccount = specpdl_depth ();
-
-  /* PNG variables */
-  png_structp png_ptr;
-  png_infop info_ptr;
-
-  if (!DEVICE_X_P (XDEVICE (device)))
-    signal_simple_error ("Not an X device", device);
-
-  dpy = DEVICE_X_DISPLAY (XDEVICE (device));
-  cmap = DEVICE_X_COLORMAP (XDEVICE(device));
-  vis = DEVICE_X_VISUAL (XDEVICE(device));
-
-  /* Initialize all PNG structures */
-  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, (void*)&png_err_stct,
-				    png_error_func, png_warning_func);
-  if (!png_ptr)
-    signal_image_error ("Error obtaining memory for png_read", instantiator);
-  info_ptr = png_create_info_struct (png_ptr);
-  if (!info_ptr)
-    {
-      png_destroy_read_struct (&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
-      signal_image_error ("Error obtaining memory for png_read", instantiator);
-    }
-  
-  xzero (unwind);
-  unwind.png_ptr = png_ptr;
-  unwind.info_ptr = info_ptr;
-  unwind.dpy = dpy;
-  unwind.cmap = cmap;
-
-  record_unwind_protect (png_instantiate_unwind, make_opaque_ptr (&unwind));
-
-  /* This code is a mixture of stuff from Ben's GIF/JPEG stuff from
-     this file, example.c from the libpng 0.81 distribution, and the
-     pngtopnm sources. -WMP-
-     */
-  /* It has been further modified to handle the API changes for 0.96,
-     and is no longer usable for previous versions. jh
-  */
-
-  /* Set the jmp_buf reurn context for png_error ... if this returns !0, then
-     we ran into a problem somewhere, and need to clean up after ourselves. */
-  if (setjmp (png_err_stct.setjmp_buffer))
-    {
-      /* Something blew up: just display the error (cleanup happens in the unwind) */
-      signal_image_error_2 ("Error decoding PNG",
-			     build_string(png_err_stct.err_str),
-			     instantiator);
-    }
-
-  /* Initialize the IO layer and read in header information */
-  {
-    Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
-    CONST Extbyte *bytes;
-    Extcount len;
-    struct png_memory_storage tbr; /* Data to be read */
-
-    assert (!NILP (data));
-
-    /* #### This is a definite problem under Mule due to the amount of
-       stack data it might allocate.  Need to think about using Lstreams */
-    GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
-    tbr.bytes = bytes;
-    tbr.len = len;
-    tbr.index = 0;
-    png_set_read_fn (png_ptr,(void *) &tbr, png_read_from_memory);
-  }
-
-  png_read_info (png_ptr, info_ptr);
-
-#if 0
-  /* set up the transformations you want.  Note that these are
-     all optional.  Only call them if you want them */
-  /* tell libpng to strip 16 bit depth files down to 8 bits */
-  if (info_ptr->bit_depth == 16)
-    png_set_strip_16 (png_ptr);
-  if (info_ptr->bit_depth < 8)
-    png_set_packing (png_ptr);
-  /* ##### Perhaps some way to specify the screen gamma should be in here? */
-
-  {
-    int height = info_ptr->height;
-    int width = info_ptr->width;
-    int depth = info_ptr->bit_depth;
-    int linesize = max (info_ptr->bit_depth >> 3, 1) * width;
-    int bitmap_pad;
-    int y;
-    XColor color;
-    png_byte *png_pixels;
-    png_byte **row_pointers;
-    png_color static_color_cube[216];
-
-    /* Wow, allocate all the memory.  Truly, exciting. */
-    unwind.pixcount = 32;
-    unwind.pixels = xnew_array (unsigned long, unwind.pixcount);
-    png_pixels    = xnew_array (png_byte, linesize * height);
-    row_pointers  = xnew_array (png_byte *, height);
-
-    for (y = 0; y < height; y++)
-      row_pointers[y] = png_pixels + (linesize * y);
-
-    /*  #### This is where we should handle transparency, but I am unsure of
-	how exactly to get that information right now, in a safe manner. */
-#if 0
-    {
-      png_color_16 current_background;
-
-      /* Some appropriate magic should go here to get the current
-	 buffers (device?)  background color and convert it to a
-	 png_color_16 struct */
-      if (info_ptr->valid & PNG_INFO_bKGD)
-	png_set_background (png_ptr, &(info_ptr->background), PNG_GAMMA_FILE,
-			    1, 1.0);
-      else
-	png_set_background (png_ptr, &current_background, PNG_GAMMA_SCREEN,
-			    0, 1.0);
-    }
-#endif
-
-    if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
-	 (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
-	(vis->class == PseudoColor))
-      {
-	if (!(info_ptr->valid & PNG_INFO_PLTE))
-	  {
-	    for (y = 0; y < 216; y++)
-	      {
-		static_color_cube[y].red   = (png_byte) ((y % 6) * 255.0 / 5);
-		static_color_cube[y].green = (png_byte) (((y / 6) % 6) * 255.0 / 5);
-		static_color_cube[y].blue  = (png_byte) ((y / 36) * 255.0 / 5);
-	      }
-	    png_set_dither (png_ptr, static_color_cube, 216, 216, NULL, 1);
-	  }
-	else
-	  {
-	    png_set_dither (png_ptr, info_ptr->palette, info_ptr->num_palette,
-			    info_ptr->num_palette, info_ptr->hist, 1);
-	  }
-      }
-
-    png_read_image (png_ptr, row_pointers);
-    png_read_end (png_ptr, info_ptr);
-
-    /* Ok, now we go and allocate all the colors */
-    if (info_ptr->valid & PNG_INFO_PLTE)
-      {
-	unwind.npixels = 0;
-	for (y = 0; y < info_ptr->num_palette; y++)
-	  {
-	    int res;
-	    color.red   = info_ptr->palette[y].red   << 8;
-	    color.green = info_ptr->palette[y].green << 8;
-	    color.blue  = info_ptr->palette[y].blue  << 8;
-	    color.flags = DoRed | DoGreen | DoBlue;
-	    res = allocate_nearest_color (dpy, cmap, vis, &color);
-	    if (res > 0 && res < 3)
-	      {
-		DO_REALLOC(unwind.pixels, unwind.pixcount, unwind.npixels+1, unsigned long);
-		unwind.pixels[unwind.npixels] = color.pixel;
-		unwind.npixels++;
-	      }
-	  }
-      }
-    else
-      {
-	unwind.npixels = 0;
-	for (y = 0; y < 216; y++)
-	  {
-	    int res;
-	    color.red   = static_color_cube[y].red   << 8;
-	    color.green = static_color_cube[y].green << 8;
-	    color.blue  = static_color_cube[y].blue  << 8;
-	    color.flags = DoRed|DoGreen|DoBlue;
-	    res = allocate_nearest_color (dpy, cmap, vis, &color);
-	    if (res > 0 && res < 3)
-	      {
-		unwind.pixels[unwind.npixels] = color.pixel;
-		unwind.npixels++;
-	      }
-	  }
-      }
-
-#ifdef PNG_SHOW_COMMENTS
-    /* ####
-     * I turn this off by default now, because the !%^@#!% comments
-     * show up every time the image is instantiated, which can get
-     * really really annoying.  There should be some way to pass this
-     * type of data down into the glyph code, where you can get to it
-     * from lisp anyway. - WMP
-     */
-    {
-      int i;
-
-      for (i = 0 ; i < info_ptr->num_text ; i++)
-	{
-	  /* How paranoid do I have to be about no trailing NULLs, and
-	     using (int)info_ptr->text[i].text_length, and strncpy and a temp
-	     string somewhere? */
-
-	  warn_when_safe (Qpng, Qinfo, "%s - %s",
-			  info_ptr->text[i].key,
-			  info_ptr->text[i].text);
-	}
-    }
-#endif
-
-    /* Now create the image */
-
-    depth = DEVICE_X_DEPTH(XDEVICE(device));
-
-    /* first get bitmap_pad (from XPM) */
-    bitmap_pad = ((depth > 16) ? 32 :
-		  (depth >  8) ? 16 :
-		  8);
-
-    unwind.ximage = XCreateImage (dpy, vis,
-				  depth, ZPixmap, 0, 0, width, height,
-				  bitmap_pad, 0);
-
-    if (!unwind.ximage)
-      signal_image_error ("Unable to create X image struct",
-			   instantiator);
-
-    /* now that bytes_per_line must have been set properly alloc data */
-    unwind.ximage->data = (char *) xmalloc (unwind.ximage->bytes_per_line *
-					    height);
-
-    {
-      int i, j;
-      for (i = 0; i < height; i++)
-	for (j = 0; j < width; j++)
-	  XPutPixel (unwind.ximage, j, i,
-		     unwind.pixels[png_pixels[i * width + j]]);
-    }
-
-    xfree (row_pointers);
-    xfree (png_pixels);
-  }
-#else
-  {
-    int height = info_ptr->height;
-    int width = info_ptr->width;
-    int y;
-    unsigned char **row_pointers;
-
-    /* Wow, allocate all the memory.  Truly, exciting. */
-    unwind.eimage = xnew_array_and_zero (unsigned char, width * height * 3);
-    /* libpng expects that the image buffer passed in contains a
-       picture to draw on top of if the png has any transparencies.
-       This could be a good place to pass that in... */
-    
-    row_pointers  = xnew_array (png_byte *, height);
-
-    for (y = 0; y < height; y++)
-      row_pointers[y] = unwind.eimage + (width * 3 * y);
-
-    /* Now that we're using EImage, ask for 8bit RGB triples for any type
-       of image*/
-    /* convert palatte images to full RGB */
-    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
-      png_set_expand (png_ptr);
-    /* send grayscale images to RGB too */
-    if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
-        info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
-      png_set_gray_to_rgb (png_ptr);
-    /* we can't handle alpha values */
-    if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
-      png_set_strip_alpha (png_ptr);
-    /* rip out any transparancy layers/colors */
-    if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
-      {
-        png_set_expand (png_ptr);
-	png_set_strip_alpha (png_ptr);
-      }
-    /* tell libpng to strip 16 bit depth files down to 8 bits */
-    if (info_ptr->bit_depth == 16)
-      png_set_strip_16 (png_ptr);
-    /* if the image is < 8 bits, pad it out */
-    if (info_ptr->bit_depth < 8)
-      {
-	if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)
-	  png_set_expand (png_ptr);
-	else
-	  png_set_packing (png_ptr);
-      }
-
-#if 1 /* tests? or permanent? */
-    {
-      /* if the png specifies a background chunk, go ahead and
-	 use it */
-      png_color_16 my_background, *image_background;
-    
-      /* ### how do I get the background of the current frame? */
-      my_background.red   = 0x7fff;
-      my_background.green = 0x7fff;
-      my_background.blue  = 0x7fff;
-
-      if (png_get_bKGD (png_ptr, info_ptr, &image_background))
-	png_set_background (png_ptr, image_background,
-			    PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
-      else 
-	png_set_background (png_ptr, &my_background,
-			    PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
-    }
-#endif
-    png_read_image (png_ptr, row_pointers);
-    png_read_end (png_ptr, info_ptr);
-    
-#ifdef PNG_SHOW_COMMENTS
-    /* ####
-     * I turn this off by default now, because the !%^@#!% comments
-     * show up every time the image is instantiated, which can get
-     * really really annoying.  There should be some way to pass this
-     * type of data down into the glyph code, where you can get to it
-     * from lisp anyway. - WMP
-     */
-    {
-      int i;
-
-      for (i = 0 ; i < info_ptr->num_text ; i++)
-	{
-	  /* How paranoid do I have to be about no trailing NULLs, and
-	     using (int)info_ptr->text[i].text_length, and strncpy and a temp
-	     string somewhere? */
-
-	  warn_when_safe (Qpng, Qinfo, "%s - %s",
-			  info_ptr->text[i].key,
-			  info_ptr->text[i].text);
-	}
-    }
-#endif
-
-    xfree (row_pointers);
-    unwind.ximage = convert_EImage_to_XImage (device, width, height, unwind.eimage,
-				   &unwind.pixels, &unwind.pixcount, &unwind.npixels);
-    if (!unwind.ximage)
-      signal_image_error ("PNG conversion failed", instantiator);
-  }
-#endif
-
-  init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
-				    cmap, unwind.pixels, unwind.npixels,
-				    instantiator);
-
-  /* This will clean up everything else. */
-  unwind.npixels = 0;
-  unwind.pixcount = 0;
-  unbind_to (speccount, Qnil);
-}
-
-#endif /* HAVE_PNG */
-
-
-#ifdef HAVE_TIFF
-#include "tiffio.h"
-
-/**********************************************************************
- *                             TIFF                                   *
- **********************************************************************/
-static void
-tiff_validate (Lisp_Object instantiator)
-{
-  file_or_data_must_be_present (instantiator);
-}
-
-static Lisp_Object
-tiff_normalize (Lisp_Object inst, Lisp_Object console_type)
-{
-  return simple_image_type_normalize (inst, console_type, Qtiff);
-}
-
-static int
-tiff_possible_dest_types (void)
-{
-  return IMAGE_COLOR_PIXMAP_MASK;
-}
-
-struct tiff_unwind_data
-{
-  Display *dpy;
-  Colormap cmap;
-  unsigned char *eimage;
-  /* Object that holds the decoded data from a TIFF file */
-  TIFF *tiff;
-  /* Pixels to keep around while the image is active */
-  unsigned long *pixels;
-  int npixels,pixcount;
-  /* Client-side image structure */
-  XImage *ximage;
-};
-
-static Lisp_Object
-tiff_instantiate_unwind (Lisp_Object unwind_obj)
-{
-  struct tiff_unwind_data *data =
-    (struct tiff_unwind_data *) get_opaque_ptr (unwind_obj);
-
-  free_opaque_ptr (unwind_obj);
-  if (data->tiff)
-    {
-      TIFFClose(data->tiff);
-    }
-  if (data->eimage)
-    xfree (data->eimage);
-  if (data->npixels > 0)
-    XFreeColors (data->dpy, data->cmap, data->pixels, data->npixels, 0L);
-  if (data->pixcount)
-    xfree (data->pixels);
-  if (data->ximage)
-    {
-      if (data->ximage->data)
-        {
-	  xfree (data->ximage->data);
-          data->ximage->data = 0;
-        }
-      XDestroyImage (data->ximage);
-    }
-
-  return Qnil;
-}
-
-typedef struct tiff_memory_storage
-{
-  Extbyte *bytes;		/* The data       */
-  Extcount len;			/* How big is it? */
-  int index;			/* Where are we?  */
-} tiff_memory_storage;
-
-static size_t
-tiff_memory_read(thandle_t data, tdata_t buf, tsize_t size)
-{
-  tiff_memory_storage *mem = (tiff_memory_storage*)data;
-
-  if (size > (mem->len - mem->index))
-    return (size_t) -1;
-  memcpy(buf, mem->bytes + mem->index, size);
-  mem->index = mem->index + size;
-  return size;
-}
-
-static size_t tiff_memory_write(thandle_t data, tdata_t buf, tsize_t size)
-{
-  abort();
-  return 0;			/* Shut up warnings. */
-}
-
-static toff_t tiff_memory_seek(thandle_t data, toff_t off, int whence)
-{
-  tiff_memory_storage *mem = (tiff_memory_storage*)data;
-  int newidx;
-  switch(whence) {
-  case SEEK_SET:
-    newidx = off;
-    break;
-  case SEEK_END:
-    newidx = mem->len + off;
-    break;
-  case SEEK_CUR:
-    newidx = mem->index + off;
-    break;
-  default:
-    fprintf(stderr,"Eh? invalid seek mode in tiff_memory_seek\n");
-    return -1;
-  }
-
-  if ((newidx > mem->len) || (newidx < 0))
-    return -1;
-  
-  mem->index = newidx;
-  return newidx;
-}
-
-static int
-tiff_memory_close(thandle_t data)
-{
-  return 0;
-}
-
-static int
-tiff_map_noop(thandle_t data, tdata_t* pbase, toff_t* psize)
-{
-  return 0;
-}
-
-static void
-tiff_unmap_noop(thandle_t data, tdata_t pbase, toff_t psize)
-{
-  return;
-}
-
-static toff_t
-tiff_memory_size(thandle_t data)
-{
-  tiff_memory_storage *mem = (tiff_memory_storage*)data;
-  return mem->len;
-}
-
-struct tiff_error_struct
-{
-#if HAVE_VSNPRINTF
-  char err_str[256];
-#else
-  char err_str[1024];		/* return the error string */
-#endif
-  jmp_buf setjmp_buffer;	/* for return to caller */
-};
-
-/* jh 98/03/12 - ###This struct for passing data to the error functions
-   is an ugly hack caused by the fact that libtiff (as of v3.4) doesn't
-   have any place to store error func data.  This should be rectified
-   before XEmacs gets threads! */
-static struct tiff_error_struct tiff_err_data;
-
-static void
-tiff_error_func(CONST char *module, CONST char *fmt, ...)
-{
-  va_list vargs;
-
-  va_start (vargs, fmt);
-#if HAVE_VSNPRINTF
-  vsnprintf (tiff_err_data.err_str, 255, fmt, vargs);
-#else
-  /* pray this doesn't overflow... */
-  vsprintf (tiff_err_data.err_str, fmt, vargs);
-#endif
-  va_end (vargs);
-  /* return to setjmp point */
-  longjmp (tiff_err_data.setjmp_buffer, 1);
-}
-
-static void
-tiff_warning_func(CONST char *module, CONST char *fmt, ...)
-{
-  va_list vargs;
-#if HAVE_VSNPRINTF
-  char warn_str[256];
-#else
-  char warn_str[1024];
-#endif
-
-  va_start (vargs, fmt);
-#if HAVE_VSNPRINTF
-  vsnprintf (warn_str, 255, fmt, vargs);
-#else
-  vsprintf (warn_str, fmt, vargs);
-#endif
-  va_end (vargs);
-  warn_when_safe (Qtiff, Qinfo, "%s - %s",
-		  module, warn_str);
-}
-
-static void
-tiff_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
-		  Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		  int dest_mask, Lisp_Object domain)
-{
-  struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
-  Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
-  Colormap cmap;
-  Display *dpy;
-  tiff_memory_storage mem_struct;
-  /* It is OK for the unwind data to be local to this function,
-     because the unwind-protect is always executed when this
-     stack frame is still valid. */
-  struct tiff_unwind_data unwind;
-  int speccount = specpdl_depth ();
-
-  if (!DEVICE_X_P (XDEVICE (device)))
-    signal_simple_error ("Not an X device", device);
-
-  dpy = DEVICE_X_DISPLAY (XDEVICE (device));
-  cmap = DEVICE_X_COLORMAP (XDEVICE(device));
-
-  xzero (unwind);
-  unwind.dpy = dpy;
-  unwind.cmap = cmap;
-  record_unwind_protect (tiff_instantiate_unwind, make_opaque_ptr (&unwind));
-  
-  /* set up error facilities */
-  if (setjmp (tiff_err_data.setjmp_buffer))
-    {
-      /* An error was signaled. No clean up is needed, as unwind handles that
-	 for us.  Just pass the error along. */
-      signal_image_error_2 ("TIFF decoding error",
-			    build_string(tiff_err_data.err_str),
-			    instantiator);
-    }
-  TIFFSetErrorHandler ((TIFFErrorHandler)tiff_error_func);
-  TIFFSetWarningHandler ((TIFFErrorHandler)tiff_warning_func);
-  {
-    Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
-    Extbyte *bytes;
-    Extcount len;
-
-    uint32 width, height;
-    uint32 *raster;
-    unsigned char *ep;
-
-    assert (!NILP (data));
-
-    /* #### This is a definite problem under Mule due to the amount of
-       stack data it might allocate.  Think about Lstreams... */
-    GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
-    mem_struct.bytes = bytes;
-    mem_struct.len = len;
-    mem_struct.index = 0;
-
-    unwind.tiff = TIFFClientOpen ("memfile", "r", &mem_struct,
-				  (TIFFReadWriteProc)tiff_memory_read,
-				  (TIFFReadWriteProc)tiff_memory_write,
-				  tiff_memory_seek, tiff_memory_close, tiff_memory_size,
-				  tiff_map_noop, tiff_unmap_noop);
-    if (!unwind.tiff)
-      signal_image_error ("Insufficent memory to instantiate TIFF image", instantiator);
-
-    TIFFGetField (unwind.tiff, TIFFTAG_IMAGEWIDTH, &width);
-    TIFFGetField (unwind.tiff, TIFFTAG_IMAGELENGTH, &height);
-    unwind.eimage = (unsigned char *) xmalloc (width * height * 3);
-
-    /* ### This is little more than proof-of-concept/function testing.
-       It needs to be reimplimented via scanline reads for both memory
-       compactness. */
-    raster = (uint32*) _TIFFmalloc (width * height * sizeof (uint32));
-    if (raster != NULL)
-      {
-	int i,j;
-	uint32 *rp;
-	ep = unwind.eimage;
-	rp = raster;
-	if (TIFFReadRGBAImage (unwind.tiff, width, height, raster, 0))
-	  {
-	    for (i = height - 1;  i >= 0; i--)
-	      {
-		/* This is to get around weirdness in the libtiff library where properly
-		   made TIFFs will come out upside down.  libtiff bug or jhod-brainlock? */
-		rp = raster + (i * width);
-		for (j = 0; j < width; j++)
-		  {
-		    *ep++ = (unsigned char)TIFFGetR(*rp);
-		    *ep++ = (unsigned char)TIFFGetG(*rp);
-		    *ep++ = (unsigned char)TIFFGetB(*rp);
-		    rp++;
-		  }
-	      }
-	  }
-	_TIFFfree (raster);
-      } else
-	signal_image_error ("Unable to allocate memory for TIFFReadRGBA", instantiator);
-
-    unwind.ximage = convert_EImage_to_XImage (device, width, height, unwind.eimage,
-				   &unwind.pixels, &unwind.pixcount, &unwind.npixels);
-    if (!unwind.ximage)
-      signal_image_error ("TIFF conversion failed", instantiator);    
-  }
-  /* Now create the pixmap and set up the image instance */
-  init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
-				    cmap, unwind.pixels, unwind.npixels,
-				    instantiator);
-  /* Now that we've succeeded, we don't want the pixels
-     freed right now.  They're kept around in the image instance
-     structure until it's destroyed. */
-  unwind.npixels = 0;
-  unwind.pixcount = 0;
-  unbind_to (speccount, Qnil);
-}
-
-#endif /* HAVE_TIFF */
-
-
 #ifdef HAVE_XFACE
 
 /**********************************************************************
@@ -4164,54 +2344,6 @@
   IIFORMAT_VALID_KEYWORD (font, Q_foreground, check_valid_string);
   IIFORMAT_VALID_KEYWORD (font, Q_background, check_valid_string);
 
-#ifdef HAVE_JPEG
-  INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (jpeg, "jpeg");
-
-  IIFORMAT_HAS_METHOD (jpeg, validate);
-  IIFORMAT_HAS_METHOD (jpeg, normalize);
-  IIFORMAT_HAS_METHOD (jpeg, possible_dest_types);
-  IIFORMAT_HAS_METHOD (jpeg, instantiate);
-
-  IIFORMAT_VALID_KEYWORD (jpeg, Q_data, check_valid_string);
-  IIFORMAT_VALID_KEYWORD (jpeg, Q_file, check_valid_string);
-#endif
-
-#ifdef HAVE_GIF
-  INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (gif, "gif");
-
-  IIFORMAT_HAS_METHOD (gif, validate);
-  IIFORMAT_HAS_METHOD (gif, normalize);
-  IIFORMAT_HAS_METHOD (gif, possible_dest_types);
-  IIFORMAT_HAS_METHOD (gif, instantiate);
-
-  IIFORMAT_VALID_KEYWORD (gif, Q_data, check_valid_string);
-  IIFORMAT_VALID_KEYWORD (gif, Q_file, check_valid_string);
-#endif
-
-#ifdef HAVE_PNG
-  INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (png, "png");
-
-  IIFORMAT_HAS_METHOD (png, validate);
-  IIFORMAT_HAS_METHOD (png, normalize);
-  IIFORMAT_HAS_METHOD (png, possible_dest_types);
-  IIFORMAT_HAS_METHOD (png, instantiate);
-
-  IIFORMAT_VALID_KEYWORD (png, Q_data, check_valid_string);
-  IIFORMAT_VALID_KEYWORD (png, Q_file, check_valid_string);
-#endif
-
-#ifdef HAVE_TIFF
-  INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (tiff, "tiff");
-
-  IIFORMAT_HAS_METHOD (tiff, validate);
-  IIFORMAT_HAS_METHOD (tiff, normalize);
-  IIFORMAT_HAS_METHOD (tiff, possible_dest_types);
-  IIFORMAT_HAS_METHOD (tiff, instantiate);
-
-  IIFORMAT_VALID_KEYWORD (tiff, Q_data, check_valid_string);
-  IIFORMAT_VALID_KEYWORD (tiff, Q_file, check_valid_string);
-#endif
-
 #ifdef HAVE_XFACE
   INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (xface, "xface");
 
@@ -4242,22 +2374,6 @@
 void
 vars_of_glyphs_x (void)
 {
-#ifdef HAVE_JPEG
-  Fprovide (Qjpeg);
-#endif
-
-#ifdef HAVE_GIF
-  Fprovide (Qgif);
-#endif
-
-#ifdef HAVE_PNG
-  Fprovide (Qpng);
-#endif
-
-#ifdef HAVE_TIFF
-  Fprovide (Qtiff);
-#endif
-
 #ifdef HAVE_XFACE
   Fprovide (Qxface);
 #endif