1 files changed, 380 insertions, 184 deletions

diff --git a/src/image.c b/src/image.c
index f9f6ce70040..2c288342028 100644
--- a/src/image.c
+++ b/src/image.c
@@ -106,8 +106,6 @@ typedef struct ns_bitmap_record Bitmap_Record;
 #define GET_PIXEL(ximg, x, y) XGetPixel (ximg, x, y)
 #define NO_PIXMAP 0
 
-#define ZPixmap 0
-
 #define PIX_MASK_RETAIN 0
 #define PIX_MASK_DRAW   1
 
@@ -132,6 +130,8 @@ static void free_color_table (void);
 static unsigned long *colors_in_color_table (int *n);
 #endif
 
+static Lisp_Object QCmax_width, QCmax_height;
+
 /* Code to deal with bitmaps.  Bitmaps are referenced by their bitmap
    id, which is just an int that this section returns.  Bitmaps are
    reference counted so they can be shared among frames.
@@ -144,16 +144,6 @@ static unsigned long *colors_in_color_table (int *n);
    data more than once will not be caught.  */
 
 #ifdef HAVE_NS
-XImagePtr
-XGetImage (Display *display, Pixmap pixmap, int x, int y,
-           unsigned int width, unsigned int height,
-           unsigned long plane_mask, int format)
-{
-  /* TODO: not sure what this function is supposed to do.. */
-  ns_retain_object (pixmap);
-  return pixmap;
-}
-
 /* Use with images created by ns_image_for_XPM.  */
 unsigned long
 XGetPixel (XImagePtr ximage, int x, int y)
@@ -433,8 +423,24 @@ static bool x_create_x_image_and_pixmap (struct frame *, int, int, int,
                                          XImagePtr *, Pixmap *);
 static void x_destroy_x_image (XImagePtr ximg);
 
+#ifdef HAVE_NTGUI
+static XImagePtr_or_DC image_get_x_image_or_dc (struct frame *, struct image *,
+                                                bool, HGDIOBJ *);
+static void image_unget_x_image_or_dc (struct image *, bool, XImagePtr_or_DC,
+                                       HGDIOBJ);
+#else
+static XImagePtr image_get_x_image (struct frame *, struct image *, bool);
+static void image_unget_x_image (struct image *, bool, XImagePtr);
+#define image_get_x_image_or_dc(f, img, mask_p, dummy)  \
+  image_get_x_image (f, img, mask_p)
+#define image_unget_x_image_or_dc(img, mask_p, ximg, dummy)     \
+  image_unget_x_image (img, mask_p, ximg)
+#endif
+
 #ifdef HAVE_X_WINDOWS
 
+static void image_sync_to_pixmaps (struct frame *, struct image *);
+
 /* Useful functions defined in the section
    `Image type independent image structures' below. */
 
@@ -1048,6 +1054,14 @@ prepare_image_for_display (struct frame *f, struct image *img)
   if (img->pixmap == NO_PIXMAP && !img->load_failed_p)
     img->load_failed_p = ! img->type->load (f, img);
 
+#ifdef HAVE_X_WINDOWS
+  if (!img->load_failed_p)
+    {
+      block_input ();
+      image_sync_to_pixmaps (f, img);
+      unblock_input ();
+    }
+#endif
 }
 
 
@@ -1143,25 +1157,16 @@ four_corners_best (XImagePtr_or_DC ximg, int *corners,
 
 #ifdef HAVE_NTGUI
 
-#define Destroy_Image(img_dc, prev) \
-  do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
-
 #define Free_Pixmap(display, pixmap) \
   DeleteObject (pixmap)
 
 #elif defined (HAVE_NS)
 
-#define Destroy_Image(ximg, dummy) \
-  ns_release_object (ximg)
-
 #define Free_Pixmap(display, pixmap) \
   ns_release_object (pixmap)
 
 #else
 
-#define Destroy_Image(ximg, dummy) \
-  XDestroyImage (ximg)
-
 #define Free_Pixmap(display, pixmap) \
   XFreePixmap (display, pixmap)
 
@@ -1185,22 +1190,12 @@ image_background (struct image *img, struct frame *f, XImagePtr_or_DC ximg)
 #endif /* HAVE_NTGUI */
 
       if (free_ximg)
-        {
-#ifndef HAVE_NTGUI
-          ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
-                            0, 0, img->width, img->height, ~0, ZPixmap);
-#else
-          HDC frame_dc = get_frame_dc (f);
-          ximg = CreateCompatibleDC (frame_dc);
-          release_frame_dc (f, frame_dc);
-          prev = SelectObject (ximg, img->pixmap);
-#endif /* !HAVE_NTGUI */
-        }
+        ximg = image_get_x_image_or_dc (f, img, 0, &prev);
 
       img->background = four_corners_best (ximg, img->corners, img->width, img->height);
 
       if (free_ximg)
-        Destroy_Image (ximg, prev);
+        image_unget_x_image_or_dc (img, 0, ximg, prev);
 
       img->background_valid = 1;
     }
@@ -1226,23 +1221,13 @@ image_background_transparent (struct image *img, struct frame *f, XImagePtr_or_D
 #endif /* HAVE_NTGUI */
 
           if (free_mask)
-            {
-#ifndef HAVE_NTGUI
-              mask = XGetImage (FRAME_X_DISPLAY (f), img->mask,
-                                0, 0, img->width, img->height, ~0, ZPixmap);
-#else
-              HDC frame_dc = get_frame_dc (f);
-              mask = CreateCompatibleDC (frame_dc);
-              release_frame_dc (f, frame_dc);
-              prev = SelectObject (mask, img->mask);
-#endif /* HAVE_NTGUI */
-            }
+            mask = image_get_x_image_or_dc (f, img, 1, &prev);
 
           img->background_transparent
             = (four_corners_best (mask, img->corners, img->width, img->height) == PIX_MASK_RETAIN);
 
           if (free_mask)
-            Destroy_Image (mask, prev);
+            image_unget_x_image_or_dc (img, 1, mask, prev);
         }
       else
         img->background_transparent = 0;
@@ -1258,30 +1243,58 @@ image_background_transparent (struct image *img, struct frame *f, XImagePtr_or_D
                   Helper functions for X image types
  ***********************************************************************/
 
-/* Clear X resources of image IMG on frame F.  PIXMAP_P means free the
-   pixmap if any.  MASK_P means clear the mask pixmap if any.
-   COLORS_P means free colors allocated for the image, if any.  */
+/* Clear X resources of image IMG on frame F according to FLAGS.
+   FLAGS is bitwise-or of the following masks:
+   CLEAR_IMAGE_PIXMAP free the pixmap if any.
+   CLEAR_IMAGE_MASK means clear the mask pixmap if any.
+   CLEAR_IMAGE_COLORS means free colors allocated for the image, if
+     any.  */
+
+#define CLEAR_IMAGE_PIXMAP      (1 << 0)
+#define CLEAR_IMAGE_MASK        (1 << 1)
+#define CLEAR_IMAGE_COLORS      (1 << 2)
 
 static void
-x_clear_image_1 (struct frame *f, struct image *img, bool pixmap_p,
-                 bool mask_p, bool colors_p)
+x_clear_image_1 (struct frame *f, struct image *img, int flags)
 {
-  if (pixmap_p && img->pixmap)
+  if (flags & CLEAR_IMAGE_PIXMAP)
     {
-      Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
-      img->pixmap = NO_PIXMAP;
-      /* NOTE (HAVE_NS): background color is NOT an indexed color! */
-      img->background_valid = 0;
+      if (img->pixmap)
+        {
+          Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
+          img->pixmap = NO_PIXMAP;
+          /* NOTE (HAVE_NS): background color is NOT an indexed color! */
+          img->background_valid = 0;
+        }
+#ifdef HAVE_X_WINDOWS
+      if (img->ximg)
+        {
+          x_destroy_x_image (img->ximg);
+          img->ximg = NULL;
+          img->background_valid = 0;
+        }
+#endif
     }
 
-  if (mask_p && img->mask)
+  if (flags & CLEAR_IMAGE_MASK)
     {
-      Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
-      img->mask = NO_PIXMAP;
-      img->background_transparent_valid = 0;
+      if (img->mask)
+        {
+          Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
+          img->mask = NO_PIXMAP;
+          img->background_transparent_valid = 0;
+        }
+#ifdef HAVE_X_WINDOWS
+      if (img->mask_img)
+        {
+          x_destroy_x_image (img->mask_img);
+          img->mask_img = NULL;
+          img->background_transparent_valid = 0;
+        }
+#endif
     }
 
-  if (colors_p && img->ncolors)
+  if ((flags & CLEAR_IMAGE_COLORS) && img->ncolors)
     {
       /* W32_TODO: color table support.  */
 #ifdef HAVE_X_WINDOWS
@@ -1300,7 +1313,8 @@ static void
 x_clear_image (struct frame *f, struct image *img)
 {
   block_input ();
-  x_clear_image_1 (f, img, 1, 1, 1);
+  x_clear_image_1 (f, img,
+                   CLEAR_IMAGE_PIXMAP | CLEAR_IMAGE_MASK | CLEAR_IMAGE_COLORS);
   unblock_input ();
 }
 
@@ -1631,10 +1645,7 @@ postprocess_image (struct frame *f, struct image *img)
                 x_build_heuristic_mask (f, img, XCDR (mask));
             }
           else if (NILP (mask) && found_p && img->mask)
-            {
-              Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
-              img->mask = NO_PIXMAP;
-            }
+            x_clear_image_1 (f, img, CLEAR_IMAGE_MASK);
         }
 
 
@@ -2092,6 +2103,134 @@ x_put_x_image (struct frame *f, XImagePtr ximg, Pixmap pixmap, int width, int he
 #endif
 }
 
+/* Thin wrapper for x_create_x_image_and_pixmap, so that it matches
+   with image_put_x_image.  */
+
+static bool
+image_create_x_image_and_pixmap (struct frame *f, struct image *img,
+                                 int width, int height, int depth,
+                                 XImagePtr *ximg, bool mask_p)
+{
+  eassert ((!mask_p ? img->pixmap : img->mask) == NO_PIXMAP);
+
+  return x_create_x_image_and_pixmap (f, width, height, depth, ximg,
+                                      !mask_p ? &img->pixmap : &img->mask);
+}
+
+/* Put X image XIMG into image IMG on frame F, as a mask if and only
+   if MASK_P.  On X, this simply records XIMG on a member of IMG, so
+   it can be put into the pixmap afterwards via image_sync_to_pixmaps.
+   On the other platforms, it puts XIMG into the pixmap, then frees
+   the X image and its buffer.  */
+
+static void
+image_put_x_image (struct frame *f, struct image *img, XImagePtr ximg,
+                   bool mask_p)
+{
+#ifdef HAVE_X_WINDOWS
+  if (!mask_p)
+    {
+      eassert (img->ximg == NULL);
+      img->ximg = ximg;
+    }
+  else
+    {
+      eassert (img->mask_img == NULL);
+      img->mask_img = ximg;
+    }
+#else
+  x_put_x_image (f, ximg, !mask_p ? img->pixmap : img->mask,
+                 img->width, img->height);
+  x_destroy_x_image (ximg);
+#endif
+}
+
+#ifdef HAVE_X_WINDOWS
+/* Put the X images recorded in IMG on frame F into pixmaps, then free
+   the X images and their buffers.  */
+
+static void
+image_sync_to_pixmaps (struct frame *f, struct image *img)
+{
+  if (img->ximg)
+    {
+      x_put_x_image (f, img->ximg, img->pixmap, img->width, img->height);
+      x_destroy_x_image (img->ximg);
+      img->ximg = NULL;
+    }
+  if (img->mask_img)
+    {
+      x_put_x_image (f, img->mask_img, img->mask, img->width, img->height);
+      x_destroy_x_image (img->mask_img);
+      img->mask_img = NULL;
+    }
+}
+#endif
+
+#ifdef HAVE_NTGUI
+/* Create a memory device context for IMG on frame F.  It stores the
+   currently selected GDI object into *PREV for future restoration by
+   image_unget_x_image_or_dc.  */
+
+static XImagePtr_or_DC
+image_get_x_image_or_dc (struct frame *f, struct image *img, bool mask_p,
+                         HGDIOBJ *prev)
+{
+  HDC frame_dc = get_frame_dc (f);
+  XImagePtr_or_DC ximg = CreateCompatibleDC (frame_dc);
+
+  release_frame_dc (f, frame_dc);
+  *prev = SelectObject (ximg, !mask_p ? img->pixmap : img->mask);
+
+  return ximg;
+}
+
+static void
+image_unget_x_image_or_dc (struct image *img, bool mask_p,
+                           XImagePtr_or_DC ximg, HGDIOBJ prev)
+{
+  SelectObject (ximg, prev);
+  DeleteDC (ximg);
+}
+#else  /* !HAVE_NTGUI */
+/* Get the X image for IMG on frame F.  The resulting X image data
+   should be treated as read-only at least on X.  */
+
+static XImagePtr
+image_get_x_image (struct frame *f, struct image *img, bool mask_p)
+{
+#ifdef HAVE_X_WINDOWS
+  XImagePtr ximg_in_img = !mask_p ? img->ximg : img->mask_img;
+
+  if (ximg_in_img)
+    return ximg_in_img;
+  else
+    return XGetImage (FRAME_X_DISPLAY (f), !mask_p ? img->pixmap : img->mask,
+                      0, 0, img->width, img->height, ~0, ZPixmap);
+#elif defined (HAVE_NS)
+  XImagePtr pixmap = !mask_p ? img->pixmap : img->mask;
+
+  ns_retain_object (pixmap);
+  return pixmap;
+#endif
+}
+
+static void
+image_unget_x_image (struct image *img, bool mask_p, XImagePtr ximg)
+{
+#ifdef HAVE_X_WINDOWS
+  XImagePtr ximg_in_img = !mask_p ? img->ximg : img->mask_img;
+
+  if (ximg_in_img)
+    eassert (ximg == ximg_in_img);
+  else
+    XDestroyImage (ximg);
+#elif defined (HAVE_NS)
+  ns_release_object (ximg);
+#endif
+}
+#endif  /* !HAVE_NTGUI */
+
 
 /***********************************************************************
                               File Handling
@@ -3057,7 +3196,7 @@ struct xpm_cached_color
   XColor color;
 
   /* Color name.  */
-  char name[1];
+  char name[FLEXIBLE_ARRAY_MEMBER];
 };
 
 /* The hash table used for the color cache, and its bucket vector
@@ -3459,9 +3598,9 @@ xpm_load (struct frame *f, struct image *img)
                                   &xpm_image, &xpm_mask,
                                   &attrs);
 #else
-      rc = XpmReadFileToPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                                SSDATA (file), &img->pixmap, &img->mask,
-                                &attrs);
+      rc = XpmReadFileToImage (FRAME_X_DISPLAY (f), SSDATA (file),
+                               &img->ximg, &img->mask_img,
+                               &attrs);
 #endif /* HAVE_NTGUI */
     }
   else
@@ -3482,13 +3621,38 @@ xpm_load (struct frame *f, struct image *img)
                                         &xpm_image, &xpm_mask,
                                         &attrs);
 #else
-      rc = XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                                      SSDATA (buffer),
-                                      &img->pixmap, &img->mask,
-                                      &attrs);
+      rc = XpmCreateImageFromBuffer (FRAME_X_DISPLAY (f), SSDATA (buffer),
+                                     &img->ximg, &img->mask_img,
+                                     &attrs);
 #endif /* HAVE_NTGUI */
     }
 
+#ifdef HAVE_X_WINDOWS
+  if (rc == XpmSuccess)
+    {
+      img->pixmap = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                                   img->ximg->width, img->ximg->height,
+                                   img->ximg->depth);
+      if (img->pixmap == NO_PIXMAP)
+        {
+          x_clear_image (f, img);
+          rc = XpmNoMemory;
+        }
+      else if (img->mask_img)
+        {
+          img->mask = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                                     img->mask_img->width,
+                                     img->mask_img->height,
+                                     img->mask_img->depth);
+          if (img->mask == NO_PIXMAP)
+            {
+              x_clear_image (f, img);
+              rc = XpmNoMemory;
+            }
+        }
+    }
+#endif
+
   if (rc == XpmSuccess)
     {
 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
@@ -3547,6 +3711,15 @@ xpm_load (struct frame *f, struct image *img)
 #else
       XpmFreeAttributes (&attrs);
 #endif /* HAVE_NTGUI */
+
+#ifdef HAVE_X_WINDOWS
+      /* Maybe fill in the background field while we have ximg handy.  */
+      IMAGE_BACKGROUND (img, f, img->ximg);
+      if (img->mask_img)
+        /* Fill in the background_transparent field while we have the
+           mask handy.  */
+        image_background_transparent (img, f, img->mask_img);
+#endif
     }
   else
     {
@@ -3845,11 +4018,10 @@ xpm_load_image (struct frame *f,
       goto failure;
     }
 
-  if (!x_create_x_image_and_pixmap (f, width, height, 0,
-                                    &ximg, &img->pixmap)
+  if (!image_create_x_image_and_pixmap (f, img, width, height, 0, &ximg, 0)
 #ifndef HAVE_NS
-      || !x_create_x_image_and_pixmap (f, width, height, 1,
-                                       &mask_img, &img->mask)
+      || !image_create_x_image_and_pixmap (f, img, width, height, 1,
+                                           &mask_img, 1)
 #endif
       )
     {
@@ -3984,8 +4156,7 @@ xpm_load_image (struct frame *f,
   if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
     IMAGE_BACKGROUND (img, f, ximg);
 
-  x_put_x_image (f, ximg, img->pixmap, width, height);
-  x_destroy_x_image (ximg);
+  image_put_x_image (f, img, ximg, 0);
 #ifndef HAVE_NS
   if (have_mask)
     {
@@ -3993,14 +4164,12 @@ xpm_load_image (struct frame *f,
          mask handy.  */
       image_background_transparent (img, f, mask_img);
 
-      x_put_x_image (f, mask_img, img->mask, width, height);
-      x_destroy_x_image (mask_img);
+      image_put_x_image (f, img, mask_img, 1);
     }
   else
     {
       x_destroy_x_image (mask_img);
-      Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
-      img->mask = NO_PIXMAP;
+      x_clear_image_1 (f, img, CLEAR_IMAGE_MASK);
     }
 #endif
   return 1;
@@ -4398,17 +4567,8 @@ x_to_xcolors (struct frame *f, struct image *img, bool rgb_p)
     memory_full (SIZE_MAX);
   colors = xmalloc (sizeof *colors * img->width * img->height);
 
-#ifndef HAVE_NTGUI
-  /* Get the X image IMG->pixmap.  */
-  ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
-                    0, 0, img->width, img->height, ~0, ZPixmap);
-#else
-  /* Load the image into a memory device context.  */
-  hdc = get_frame_dc (f);
-  ximg = CreateCompatibleDC (hdc);
-  release_frame_dc (f, hdc);
-  prev = SelectObject (ximg, img->pixmap);
-#endif /* HAVE_NTGUI */
+  /* Get the X image or create a memory device context for IMG. */
+  ximg = image_get_x_image_or_dc (f, img, 0, &prev);
 
   /* Fill the `pixel' members of the XColor array.  I wished there
      were an easy and portable way to circumvent XGetPixel.  */
@@ -4438,7 +4598,7 @@ x_to_xcolors (struct frame *f, struct image *img, bool rgb_p)
 #endif /* HAVE_X_WINDOWS */
     }
 
-  Destroy_Image (ximg, prev);
+  image_unget_x_image_or_dc (img, 0, ximg, prev);
 
   return colors;
 }
@@ -4498,13 +4658,13 @@ x_from_xcolors (struct frame *f, struct image *img, XColor *colors)
 {
   int x, y;
   XImagePtr oimg = NULL;
-  Pixmap pixmap;
   XColor *p;
 
   init_color_table ();
 
-  x_create_x_image_and_pixmap (f, img->width, img->height, 0,
-                               &oimg, &pixmap);
+  x_clear_image_1 (f, img, CLEAR_IMAGE_PIXMAP | CLEAR_IMAGE_COLORS);
+  image_create_x_image_and_pixmap (f, img, img->width, img->height, 0,
+                                   &oimg, 0);
   p = colors;
   for (y = 0; y < img->height; ++y)
     for (x = 0; x < img->width; ++x, ++p)
@@ -4515,11 +4675,8 @@ x_from_xcolors (struct frame *f, struct image *img, XColor *colors)
       }
 
   xfree (colors);
-  x_clear_image_1 (f, img, 1, 0, 1);
 
-  x_put_x_image (f, oimg, pixmap, img->width, img->height);
-  x_destroy_x_image (oimg);
-  img->pixmap = pixmap;
+  image_put_x_image (f, img, oimg, 0);
 #ifdef COLOR_TABLE_SUPPORT
   img->colors = colors_in_color_table (&img->ncolors);
   free_color_table ();
@@ -4704,7 +4861,10 @@ x_disable_image (struct frame *f, struct image *img)
 #define MaskForeground(f)  WHITE_PIX_DEFAULT (f)
 
       Display *dpy = FRAME_X_DISPLAY (f);
-      GC gc = XCreateGC (dpy, img->pixmap, 0, NULL);
+      GC gc;
+
+      image_sync_to_pixmaps (f, img);
+      gc = XCreateGC (dpy, img->pixmap, 0, NULL);
       XSetForeground (dpy, gc, BLACK_PIX_DEFAULT (f));
       XDrawLine (dpy, img->pixmap, gc, 0, 0,
                  img->width - 1, img->height - 1);
@@ -4779,37 +4939,25 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
   unsigned long bg = 0;
 
   if (img->mask)
-    {
-      Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
-      img->mask = NO_PIXMAP;
-      img->background_transparent_valid = 0;
-    }
+    x_clear_image_1 (f, img, CLEAR_IMAGE_MASK);
 
 #ifndef HAVE_NTGUI
 #ifndef HAVE_NS
   /* Create an image and pixmap serving as mask.  */
-  rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
-                                    &mask_img, &img->mask);
+  rc = image_create_x_image_and_pixmap (f, img, img->width, img->height, 1,
+                                        &mask_img, 1);
   if (!rc)
     return;
 #endif /* !HAVE_NS */
-
-  /* Get the X image of IMG->pixmap.  */
-  ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap, 0, 0,
-                    img->width, img->height,
-                    ~0, ZPixmap);
 #else
   /* Create the bit array serving as mask.  */
   row_width = (img->width + 7) / 8;
   mask_img = xzalloc (row_width * img->height);
-
-  /* Create a memory device context for IMG->pixmap.  */
-  frame_dc = get_frame_dc (f);
-  ximg = CreateCompatibleDC (frame_dc);
-  release_frame_dc (f, frame_dc);
-  prev = SelectObject (ximg, img->pixmap);
 #endif /* HAVE_NTGUI */
 
+  /* Get the X image or create a memory device context for IMG.  */
+  ximg = image_get_x_image_or_dc (f, img, 0, &prev);
+
   /* Determine the background color of ximg.  If HOW is `(R G B)'
      take that as color.  Otherwise, use the image's background color. */
   use_img_background = 1;
@@ -4856,9 +5004,8 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
   /* Fill in the background_transparent field while we have the mask handy. */
   image_background_transparent (img, f, mask_img);
 
-  /* Put mask_img into img->mask.  */
-  x_put_x_image (f, mask_img, img->mask, img->width, img->height);
-  x_destroy_x_image (mask_img);
+  /* Put mask_img into the image.  */
+  image_put_x_image (f, img, mask_img, 1);
 #endif /* !HAVE_NS */
 #else
   for (y = 0; y < img->height; ++y)
@@ -4880,7 +5027,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
   xfree (mask_img);
 #endif /* HAVE_NTGUI */
 
-  Destroy_Image (ximg, prev);
+  image_unget_x_image_or_dc (img, 0, ximg, prev);
 }
 
 
@@ -5108,8 +5255,7 @@ pbm_load (struct frame *f, struct image *img)
       goto error;
     }
 
-  if (!x_create_x_image_and_pixmap (f, width, height, 0,
-                                    &ximg, &img->pixmap))
+  if (!image_create_x_image_and_pixmap (f, img, width, height, 0, &ximg, 0))
     goto error;
 
   /* Initialize the color hash table.  */
@@ -5246,9 +5392,8 @@ pbm_load (struct frame *f, struct image *img)
     /* Casting avoids a GCC warning.  */
     IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
-  /* Put the image into a pixmap.  */
-  x_put_x_image (f, ximg, img->pixmap, width, height);
-  x_destroy_x_image (ximg);
+  /* Put ximg into the image.  */
+  image_put_x_image (f, img, ximg, 0);
 
   /* X and W32 versions did it here, MAC version above.  ++kfs
      img->width = width;
@@ -5686,8 +5831,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
   /* Create the X image and pixmap now, so that the work below can be
      omitted if the image is too large for X.  */
-  if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
-                                    &img->pixmap))
+  if (!image_create_x_image_and_pixmap (f, img, width, height, 0, &ximg, 0))
     goto error;
 
   /* If image contains simply transparency data, we prefer to
@@ -5799,12 +5943,11 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
      contains an alpha channel.  */
   if (channels == 4
       && !transparent_p
-      && !x_create_x_image_and_pixmap (f, width, height, 1,
-                                       &mask_img, &img->mask))
+      && !image_create_x_image_and_pixmap (f, img, width, height, 1,
+                                           &mask_img, 1))
     {
       x_destroy_x_image (ximg);
-      Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
-      img->pixmap = NO_PIXMAP;
+      x_clear_image_1 (f, img, CLEAR_IMAGE_PIXMAP);
       goto error;
     }
 
@@ -5878,9 +6021,8 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
      Casting avoids a GCC warning.  */
   IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
-  /* Put the image into the pixmap, then free the X image and its buffer.  */
-  x_put_x_image (f, ximg, img->pixmap, width, height);
-  x_destroy_x_image (ximg);
+  /* Put ximg into the image.  */
+  image_put_x_image (f, img, ximg, 0);
 
   /* Same for the mask.  */
   if (mask_img)
@@ -5889,8 +6031,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
          mask handy.  Casting avoids a GCC warning.  */
       image_background_transparent (img, f, (XImagePtr_or_DC)mask_img);
 
-      x_put_x_image (f, mask_img, img->mask, img->width, img->height);
-      x_destroy_x_image (mask_img);
+      image_put_x_image (f, img, mask_img, 1);
     }
 
   return 1;
@@ -6427,7 +6568,7 @@ jpeg_load_body (struct frame *f, struct image *img,
     }
 
   /* Create X image and pixmap.  */
-  if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
+  if (!image_create_x_image_and_pixmap (f, img, width, height, 0, &ximg, 0))
     {
       mgr->failure_code = MY_JPEG_CANNOT_CREATE_X;
       sys_longjmp (mgr->setjmp_buffer, 1);
@@ -6494,9 +6635,8 @@ jpeg_load_body (struct frame *f, struct image *img,
     /* Casting avoids a GCC warning.  */
     IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
-  /* Put the image into the pixmap.  */
-  x_put_x_image (f, ximg, img->pixmap, width, height);
-  x_destroy_x_image (ximg);
+  /* Put ximg into the image.  */
+  image_put_x_image (f, img, ximg, 0);
   return 1;
 }
 
@@ -6893,8 +7033,8 @@ tiff_load (struct frame *f, struct image *img)
 
   /* Create the X image and pixmap.  */
   if (! (height <= min (PTRDIFF_MAX, SIZE_MAX) / sizeof *buf / width
-         && x_create_x_image_and_pixmap (f, width, height, 0,
-                                         &ximg, &img->pixmap)))
+         && image_create_x_image_and_pixmap (f, img, width, height, 0,
+                                             &ximg, 0)))
     {
       fn_TIFFClose (tiff);
       return 0;
@@ -6953,9 +7093,8 @@ tiff_load (struct frame *f, struct image *img)
     /* Casting avoids a GCC warning on W32.  */
     IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
-  /* Put the image into the pixmap, then free the X image and its buffer.  */
-  x_put_x_image (f, ximg, img->pixmap, width, height);
-  x_destroy_x_image (ximg);
+  /* Put ximg into the image.  */
+  image_put_x_image (f, img, ximg, 0);
   xfree (buf);
 
   return 1;
@@ -7283,7 +7422,7 @@ gif_load (struct frame *f, struct image *img)
     }
 
   /* Create the X image and pixmap.  */
-  if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
+  if (!image_create_x_image_and_pixmap (f, img, width, height, 0, &ximg, 0))
     {
       fn_DGifCloseFile (gif);
       return 0;
@@ -7467,9 +7606,8 @@ gif_load (struct frame *f, struct image *img)
     /* Casting avoids a GCC warning.  */
     IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
-  /* Put the image into the pixmap, then free the X image and its buffer.  */
-  x_put_x_image (f, ximg, img->pixmap, width, height);
-  x_destroy_x_image (ximg);
+  /* Put ximg into the image.  */
+  image_put_x_image (f, img, ximg, 0);
 
   return 1;
 }
@@ -7489,6 +7627,76 @@ gif_load (struct frame *f, struct image *img)
 #endif /* HAVE_GIF */
 
 
+static void
+compute_image_size (size_t width, size_t height,
+                    Lisp_Object spec,
+                    int *d_width, int *d_height)
+{
+  Lisp_Object value;
+  int desired_width, desired_height;
+
+  /* If width and/or height is set in the display spec assume we want
+     to scale to those values.  If either h or w is unspecified, the
+     unspecified should be calculated from the specified to preserve
+     aspect ratio.  */
+  value = image_spec_value (spec, QCwidth, NULL);
+  desired_width = (INTEGERP (value)  ? XFASTINT (value) : -1);
+  value = image_spec_value (spec, QCheight, NULL);
+  desired_height = (INTEGERP (value) ? XFASTINT (value) : -1);
+
+  if (desired_width == -1)
+    {
+      value = image_spec_value (spec, QCmax_width, NULL);
+      if (INTEGERP (value) &&
+          width > XFASTINT (value))
+        {
+          /* The image is wider than :max-width. */
+          desired_width = XFASTINT (value);
+          if (desired_height == -1)
+            {
+              value = image_spec_value (spec, QCmax_height, NULL);
+              if (INTEGERP (value))
+                {
+                  /* We have no specified height, but we have a
+                     :max-height value, so check that we satisfy both
+                     conditions. */
+                  desired_height = (double) desired_width / width * height;
+                  if (desired_height > XFASTINT (value))
+                    {
+                      desired_height = XFASTINT (value);
+                      desired_width = (double) desired_height / height * width;
+                    }
+                }
+              else
+                {
+                  /* We have no specified height and no specified
+                     max-height, so just compute the height. */
+                  desired_height = (double) desired_width / width * height;
+                }
+            }
+        }
+    }
+
+  if (desired_height == -1)
+    {
+      value = image_spec_value (spec, QCmax_height, NULL);
+      if (INTEGERP (value) &&
+          height > XFASTINT (value))
+          desired_height = XFASTINT (value);
+    }
+
+  if (desired_width != -1 && desired_height == -1)
+    /* w known, calculate h.  */
+    desired_height = (double) desired_width / width * height;
+
+  if (desired_width == -1 && desired_height != -1)
+    /* h known, calculate w.  */
+    desired_width = (double) desired_height / height * width;
+
+  *d_width = desired_width;
+  *d_height = desired_height;
+}
+
 /***********************************************************************
                                  ImageMagick
 ***********************************************************************/
@@ -7516,6 +7724,8 @@ enum imagemagick_keyword_index
     IMAGEMAGICK_BACKGROUND,
     IMAGEMAGICK_HEIGHT,
     IMAGEMAGICK_WIDTH,
+    IMAGEMAGICK_MAX_HEIGHT,
+    IMAGEMAGICK_MAX_WIDTH,
     IMAGEMAGICK_ROTATION,
     IMAGEMAGICK_CROP,
     IMAGEMAGICK_LAST
@@ -7538,6 +7748,8 @@ static struct image_keyword imagemagick_format[IMAGEMAGICK_LAST] =
     {":background",     IMAGE_STRING_OR_NIL_VALUE,              0},
     {":height",         IMAGE_INTEGER_VALUE,                    0},
     {":width",          IMAGE_INTEGER_VALUE,                    0},
+    {":max-height",     IMAGE_INTEGER_VALUE,                    0},
+    {":max-width",      IMAGE_INTEGER_VALUE,                    0},
     {":rotation",       IMAGE_NUMBER_VALUE,                     0},
     {":crop",           IMAGE_DONT_CHECK_VALUE_TYPE,            0}
   };
@@ -7726,24 +7938,10 @@ imagemagick_load_image (struct frame *f, struct image *img,
     PixelSetBlue  (bg_wand, (double) bgcolor.blue  / 65535);
   }
 
-  /* If width and/or height is set in the display spec assume we want
-     to scale to those values.  If either h or w is unspecified, the
-     unspecified should be calculated from the specified to preserve
-     aspect ratio.  */
-  value = image_spec_value (img->spec, QCwidth, NULL);
-  desired_width = (INTEGERP (value)  ? XFASTINT (value) : -1);
-  value = image_spec_value (img->spec, QCheight, NULL);
-  desired_height = (INTEGERP (value) ? XFASTINT (value) : -1);
-
-  height = MagickGetImageHeight (image_wand);
-  width = MagickGetImageWidth (image_wand);
+  compute_image_size (MagickGetImageWidth (image_wand),
+                      MagickGetImageHeight (image_wand),
+                      img->spec, &desired_width, &desired_height);
 
-  if (desired_width != -1 && desired_height == -1)
-    /* w known, calculate h.  */
-    desired_height = (double) desired_width / width * height;
-  if (desired_width == -1 && desired_height != -1)
-    /* h known, calculate w.  */
-    desired_width = (double) desired_height / height * width;
   if (desired_width != -1 && desired_height != -1)
     {
       status = MagickScaleImage (image_wand, desired_width, desired_height);
@@ -7847,8 +8045,8 @@ imagemagick_load_image (struct frame *f, struct image *img,
       int imagedepth = 24; /*MagickGetImageDepth(image_wand);*/
       const char *exportdepth = imagedepth <= 8 ? "I" : "BGRP"; /*"RGBP";*/
       /* Try to create a x pixmap to hold the imagemagick pixmap.  */
-      if (!x_create_x_image_and_pixmap (f, width, height, imagedepth,
-                                        &ximg, &img->pixmap))
+      if (!image_create_x_image_and_pixmap (f, img, width, height, imagedepth,
+                                            &ximg, 0))
         {
 #ifdef COLOR_TABLE_SUPPORT
           free_color_table ();
@@ -7886,8 +8084,8 @@ imagemagick_load_image (struct frame *f, struct image *img,
       size_t image_height;
 
       /* Try to create a x pixmap to hold the imagemagick pixmap.  */
-      if (!x_create_x_image_and_pixmap (f, width, height, 0,
-                                        &ximg, &img->pixmap))
+      if (!image_create_x_image_and_pixmap (f, img, width, height, 0,
+                                            &ximg, 0))
         {
 #ifdef COLOR_TABLE_SUPPORT
           free_color_table ();
@@ -7941,10 +8139,8 @@ imagemagick_load_image (struct frame *f, struct image *img,
   img->width  = width;
   img->height = height;
 
-  /* Put the image into the pixmap, then free the X image and its
-     buffer.  */
-  x_put_x_image (f, ximg, img->pixmap, width, height);
-  x_destroy_x_image (ximg);
+  /* Put ximg into the image.  */
+  image_put_x_image (f, img, ximg, 0);
 
   /* Final cleanup. image_wand should be the only resource left. */
   DestroyMagickWand (image_wand);
@@ -8338,7 +8534,7 @@ svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  *
   eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
 
   /* Try to create a x pixmap to hold the svg pixmap.  */
-  if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
+  if (!image_create_x_image_and_pixmap (f, img, width, height, 0, &ximg, 0))
     {
       fn_g_object_unref (pixbuf);
       return 0;
@@ -8413,10 +8609,8 @@ svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  *
      Casting avoids a GCC warning.  */
   IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
-  /* Put the image into the pixmap, then free the X image and its
-     buffer.  */
-  x_put_x_image (f, ximg, img->pixmap, width, height);
-  x_destroy_x_image (ximg);
+  /* Put ximg into the image.  */
+  image_put_x_image (f, img, ximg, 0);
 
   return 1;
 
@@ -8895,6 +9089,8 @@ non-numeric, there is no explicit limit on the size of images.  */);
   DEFSYM (Qheuristic, "heuristic");
 
   DEFSYM (Qpostscript, "postscript");
+  DEFSYM (QCmax_width, ":max-width");
+  DEFSYM (QCmax_height, ":max-height");
 #ifdef HAVE_GHOSTSCRIPT
   ADD_IMAGE_TYPE (Qpostscript);
   DEFSYM (QCloader, ":loader");