--- src/image.c.orig	2014-10-14 21:40:35.406433500 +0200
+++ src/image.c	2014-10-14 21:39:50.856516900 +0200
@@ -7919,6 +7919,156 @@
 					    MagickPixelPacket *);
 #endif
 
+#ifdef WINDOWSNT
+
+/* ImageMagick library details.  */
+DEF_IMGLIB_FN (MagickWand *, CloneMagickWand, (const MagickWand *));
+DEF_IMGLIB_FN (ExceptionInfo *, DestroyExceptionInfo, (ExceptionInfo *));
+DEF_IMGLIB_FN (MagickWand *, DestroyMagickWand, (MagickWand *));
+DEF_IMGLIB_FN (PixelIterator *, DestroyPixelIterator, (PixelIterator *));
+DEF_IMGLIB_FN (PixelWand *, DestroyPixelWand, (PixelWand *));
+DEF_IMGLIB_FN (char *, DestroyString, (char *));
+DEF_IMGLIB_FN (void, GetExceptionInfo, (ExceptionInfo *));
+DEF_IMGLIB_FN (char **, GetMagickList, (const char *, size_t *, ExceptionInfo *));
+DEF_IMGLIB_FN (MagickBooleanType, MagickCropImage, (MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t));
+DEF_IMGLIB_FN (MagickBooleanType, MagickExportImagePixels, (MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *));
+DEF_IMGLIB_FN (MagickWand *, MagickFlattenImages, (MagickWand *));
+DEF_IMGLIB_FN (char *, MagickGetException, (const MagickWand *, ExceptionType *));
+DEF_IMGLIB_FN (MagickWand *, MagickGetImage, (MagickWand *));
+DEF_IMGLIB_FN (size_t, MagickGetImageDelay, (MagickWand *));
+DEF_IMGLIB_FN (DisposeType, MagickGetImageDispose, (MagickWand *));
+DEF_IMGLIB_FN (size_t, MagickGetImageHeight, (MagickWand *));
+DEF_IMGLIB_FN (MagickBooleanType, MagickGetImagePage, (MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *));
+DEF_IMGLIB_FN (char *, MagickGetImageSignature, (MagickWand *));
+DEF_IMGLIB_FN (size_t, MagickGetImageWidth, (MagickWand *));
+DEF_IMGLIB_FN (size_t, MagickGetNumberImages, (MagickWand *));
+DEF_IMGLIB_FN (MagickWand *, MagickMergeImageLayers, (MagickWand *, const ImageLayerMethod));
+DEF_IMGLIB_FN (MagickBooleanType, MagickReadImage, (MagickWand *, const char *));
+DEF_IMGLIB_FN (MagickBooleanType, MagickReadImageBlob, (MagickWand *, const void *, const size_t));
+DEF_IMGLIB_FN (void *, MagickRelinquishMemory, (void *));
+DEF_IMGLIB_FN (MagickBooleanType, MagickRotateImage, (MagickWand *, const PixelWand *, const double));
+DEF_IMGLIB_FN (MagickBooleanType, MagickScaleImage, (MagickWand *, const size_t, const size_t));
+DEF_IMGLIB_FN (MagickBooleanType, MagickSetFilename, (MagickWand *, const char *));
+DEF_IMGLIB_FN (MagickBooleanType, MagickSetImageBackgroundColor, (MagickWand *, const PixelWand *));
+DEF_IMGLIB_FN (MagickBooleanType, MagickSetIteratorIndex, (MagickWand *, const ssize_t));
+DEF_IMGLIB_FN (void, MagickWandGenesis, (void));
+DEF_IMGLIB_FN (void, MagickWandTerminus, (void));
+DEF_IMGLIB_FN (MagickWand *, NewMagickWand, (void));
+DEF_IMGLIB_FN (PixelIterator *, NewPixelIterator, (MagickWand *));
+DEF_IMGLIB_FN (PixelWand *, NewPixelWand, (void));
+DEF_IMGLIB_FN (double, PixelGetAlpha, (const PixelWand *));
+DEF_IMGLIB_FN (void, PixelGetMagickColor, (PixelWand *, MagickPixelPacket *));
+DEF_IMGLIB_FN (PixelWand **, PixelGetNextIteratorRow, (PixelIterator *, size_t *));
+DEF_IMGLIB_FN (void, PixelSetBlue, (PixelWand *, const double));
+DEF_IMGLIB_FN (void, PixelSetGreen, (PixelWand *, const double));
+DEF_IMGLIB_FN (MagickBooleanType, PixelSetIteratorRow, (PixelIterator *, const ssize_t));
+DEF_IMGLIB_FN (void, PixelSetMagickColor, (PixelWand *, const MagickPixelPacket *));
+DEF_IMGLIB_FN (void, PixelSetRed, (PixelWand *, const double));
+DEF_IMGLIB_FN (MagickBooleanType, PixelSyncIterator, (PixelIterator *));
+
+static bool
+init_imagemagick_functions (void)
+{
+  HMODULE library;
+
+  if (!(library = w32_delayed_load (Qimagemagick)))
+   return 0;
+
+  LOAD_IMGLIB_FN (library, CloneMagickWand);
+  LOAD_IMGLIB_FN (library, DestroyExceptionInfo);
+  LOAD_IMGLIB_FN (library, DestroyMagickWand);
+  LOAD_IMGLIB_FN (library, DestroyPixelIterator);
+  LOAD_IMGLIB_FN (library, DestroyPixelWand);
+  LOAD_IMGLIB_FN (library, DestroyString);
+  LOAD_IMGLIB_FN (library, GetExceptionInfo);
+  LOAD_IMGLIB_FN (library, GetMagickList);
+  LOAD_IMGLIB_FN (library, MagickCropImage);
+  LOAD_IMGLIB_FN (library, MagickExportImagePixels);
+  LOAD_IMGLIB_FN (library, MagickFlattenImages);
+  LOAD_IMGLIB_FN (library, MagickGetException);
+  LOAD_IMGLIB_FN (library, MagickGetImage);
+  LOAD_IMGLIB_FN (library, MagickGetImageDelay);
+  LOAD_IMGLIB_FN (library, MagickGetImageDispose);
+  LOAD_IMGLIB_FN (library, MagickGetImageHeight);
+  LOAD_IMGLIB_FN (library, MagickGetImagePage);
+  LOAD_IMGLIB_FN (library, MagickGetImageSignature);
+  LOAD_IMGLIB_FN (library, MagickGetImageWidth);
+  LOAD_IMGLIB_FN (library, MagickGetNumberImages);
+  LOAD_IMGLIB_FN (library, MagickMergeImageLayers);
+  LOAD_IMGLIB_FN (library, MagickReadImage);
+  LOAD_IMGLIB_FN (library, MagickReadImageBlob);
+  LOAD_IMGLIB_FN (library, MagickRelinquishMemory);
+  LOAD_IMGLIB_FN (library, MagickRotateImage);
+  LOAD_IMGLIB_FN (library, MagickScaleImage);
+  LOAD_IMGLIB_FN (library, MagickSetFilename);
+  LOAD_IMGLIB_FN (library, MagickSetImageBackgroundColor);
+  LOAD_IMGLIB_FN (library, MagickSetIteratorIndex);
+  LOAD_IMGLIB_FN (library, MagickWandGenesis);
+  LOAD_IMGLIB_FN (library, MagickWandTerminus);
+  LOAD_IMGLIB_FN (library, NewMagickWand);
+  LOAD_IMGLIB_FN (library, NewPixelIterator);
+  LOAD_IMGLIB_FN (library, NewPixelWand);
+  LOAD_IMGLIB_FN (library, PixelGetAlpha);
+  LOAD_IMGLIB_FN (library, PixelGetMagickColor);
+  LOAD_IMGLIB_FN (library, PixelGetNextIteratorRow);
+  LOAD_IMGLIB_FN (library, PixelSetBlue);
+  LOAD_IMGLIB_FN (library, PixelSetGreen);
+  LOAD_IMGLIB_FN (library, PixelSetIteratorRow);
+  LOAD_IMGLIB_FN (library, PixelSetMagickColor);
+  LOAD_IMGLIB_FN (library, PixelSetRed);
+  LOAD_IMGLIB_FN (library, PixelSyncIterator);
+
+  return 1;
+}
+
+#else
+
+#define fn_CloneMagickWand               CloneMagickWand
+#define fn_DestroyExceptionInfo          DestroyExceptionInfo
+#define fn_DestroyMagickWand             DestroyMagickWand
+#define fn_DestroyPixelIterator          DestroyPixelIterator
+#define fn_DestroyPixelWand              DestroyPixelWand
+#define fn_DestroyString                 DestroyString
+#define fn_GetExceptionInfo              GetExceptionInfo
+#define fn_GetMagickList                 GetMagickList
+#define fn_MagickCropImage               MagickCropImage
+#define fn_MagickExportImagePixels       MagickExportImagePixels
+#define fn_MagickFlattenImages           MagickFlattenImages
+#define fn_MagickGetException            MagickGetException
+#define fn_MagickGetImage                MagickGetImage
+#define fn_MagickGetImageDelay           MagickGetImageDelay
+#define fn_MagickGetImageDispose         MagickGetImageDispose
+#define fn_MagickGetImageHeight          MagickGetImageHeight
+#define fn_MagickGetImagePage            MagickGetImagePage
+#define fn_MagickGetImageSignature       MagickGetImageSignature
+#define fn_MagickGetImageWidth           MagickGetImageWidth
+#define fn_MagickGetNumberImages         MagickGetNumberImages
+#define fn_MagickMergeImageLayers        MagickMergeImageLayers
+#define fn_MagickReadImage               MagickReadImage
+#define fn_MagickReadImageBlob           MagickReadImageBlob
+#define fn_MagickRelinquishMemory        MagickRelinquishMemory
+#define fn_MagickRotateImage             MagickRotateImage
+#define fn_MagickScaleImage              MagickScaleImage
+#define fn_MagickSetFilename             MagickSetFilename
+#define fn_MagickSetImageBackgroundColor MagickSetImageBackgroundColor
+#define fn_MagickSetIteratorIndex        MagickSetIteratorIndex
+#define fn_MagickWandGenesis             MagickWandGenesis
+#define fn_MagickWandTerminus            MagickWandTerminus
+#define fn_NewMagickWand                 NewMagickWand
+#define fn_NewPixelIterator              NewPixelIterator
+#define fn_NewPixelWand                  NewPixelWand
+#define fn_PixelGetAlpha                 PixelGetAlpha
+#define fn_PixelGetMagickColor           PixelGetMagickColor
+#define fn_PixelGetNextIteratorRow       PixelGetNextIteratorRow
+#define fn_PixelSetBlue                  PixelSetBlue
+#define fn_PixelSetGreen                 PixelSetGreen
+#define fn_PixelSetIteratorRow           PixelSetIteratorRow
+#define fn_PixelSetMagickColor           PixelSetMagickColor
+#define fn_PixelSetRed                   PixelSetRed
+#define fn_PixelSyncIterator             PixelSyncIterator
+
+#endif /* WINDOWSNT */
+
 /* Log ImageMagick error message.
    Useful when a ImageMagick function returns the status `MagickFalse'.  */
 
@@ -7928,11 +8078,11 @@
   char *description;
   ExceptionType severity;
 
-  description = MagickGetException (wand, &severity);
+  description = fn_MagickGetException (wand, &severity);
   image_error ("ImageMagick error: %s",
 	       build_string (description),
 	       Qnil);
-  MagickRelinquishMemory (description);
+  fn_MagickRelinquishMemory (description);
 }
 
 /* Possibly give ImageMagick some extra help to determine the image
@@ -8011,7 +8161,7 @@
       else
 	{
 	  if (cache->wand)
-	    DestroyMagickWand (cache->wand);
+	    fn_DestroyMagickWand (cache->wand);
 	  *pcache = cache->next;
 	  xfree (cache);
 	}
@@ -8021,7 +8171,7 @@
 static struct animation_cache *
 imagemagick_get_animation_cache (MagickWand *wand)
 {
-  char *signature = MagickGetImageSignature (wand);
+  char *signature = fn_MagickGetImageSignature (wand);
   struct animation_cache *cache;
   struct animation_cache **pcache = &animation_cache;
 
@@ -8040,7 +8190,7 @@
       pcache = &cache->next;
     }
 
-  DestroyString (signature);
+  fn_DestroyString (signature);
   cache->update_time = current_timespec ();
   return cache;
 }
@@ -8053,18 +8203,18 @@
   size_t dest_width, dest_height;
   struct animation_cache *cache = imagemagick_get_animation_cache (super_wand);
 
-  MagickSetIteratorIndex (super_wand, 0);
+  fn_MagickSetIteratorIndex (super_wand, 0);
 
   if (ino == 0 || cache->wand == NULL || cache->index > ino)
     {
-      composite_wand = MagickGetImage (super_wand);
+      composite_wand = fn_MagickGetImage (super_wand);
       if (cache->wand)
-	DestroyMagickWand (cache->wand);
+	fn_DestroyMagickWand (cache->wand);
     }
   else
     composite_wand = cache->wand;
 
-  dest_height = MagickGetImageHeight (composite_wand);
+  dest_height = fn_MagickGetImageHeight (composite_wand);
 
   for (i = max (1, cache->index + 1); i <= ino; i++)
     {
@@ -8077,32 +8227,32 @@
       DisposeType dispose;
       ptrdiff_t lines = 0;
 
-      MagickSetIteratorIndex (super_wand, i);
-      sub_wand = MagickGetImage (super_wand);
+      fn_MagickSetIteratorIndex (super_wand, i);
+      sub_wand = fn_MagickGetImage (super_wand);
 
-      MagickGetImagePage (sub_wand, &source_width, &source_height,
+      fn_MagickGetImagePage (sub_wand, &source_width, &source_height,
 			  &source_left, &source_top);
 
       /* This flag says how to handle transparent pixels.  */
-      dispose = MagickGetImageDispose (sub_wand);
+      dispose = fn_MagickGetImageDispose (sub_wand);
 
-      source_iterator = NewPixelIterator (sub_wand);
+      source_iterator = fn_NewPixelIterator (sub_wand);
       if (! source_iterator)
 	{
-	  DestroyMagickWand (composite_wand);
-	  DestroyMagickWand (sub_wand);
+	  fn_DestroyMagickWand (composite_wand);
+	  fn_DestroyMagickWand (sub_wand);
 	  cache->wand = NULL;
 	  image_error ("Imagemagick pixel iterator creation failed",
 		       Qnil, Qnil);
 	  return NULL;
 	}
 
-      dest_iterator = NewPixelIterator (composite_wand);
+      dest_iterator = fn_NewPixelIterator (composite_wand);
       if (! dest_iterator)
 	{
-	  DestroyMagickWand (composite_wand);
-	  DestroyMagickWand (sub_wand);
-	  DestroyPixelIterator (source_iterator);
+	  fn_DestroyMagickWand (composite_wand);
+	  fn_DestroyMagickWand (sub_wand);
+	  fn_DestroyPixelIterator (source_iterator);
 	  cache->wand = NULL;
 	  image_error ("Imagemagick pixel iterator creation failed",
 		       Qnil, Qnil);
@@ -8113,12 +8263,12 @@
 	 iterator to where the sub-image should start. */
       if (source_top > 0)
 	{
-	  PixelSetIteratorRow (dest_iterator, source_top);
+	  fn_PixelSetIteratorRow (dest_iterator, source_top);
 	  lines = source_top;
 	}
 
-      while ((source = PixelGetNextIteratorRow (source_iterator, &source_width))
-	     != NULL)
+      while ((source = fn_PixelGetNextIteratorRow (source_iterator,
+	     &source_width)) != NULL)
 	{
 	  ptrdiff_t x;
 
@@ -8127,7 +8277,7 @@
 	  if (++lines >= dest_height)
 	    break;
 
-	  dest = PixelGetNextIteratorRow (dest_iterator, &dest_width);
+	  dest = fn_PixelGetNextIteratorRow (dest_iterator, &dest_width);
 	  for (x = 0; x < source_width; x++)
 	    {
 	      /* Sanity check.  This shouldn't happen, but apparently
@@ -8137,23 +8287,23 @@
 	      /* Normally we only copy over non-transparent pixels,
 		 but if the disposal method is "Background", then we
 		 copy over all pixels.  */
-	      if (dispose == BackgroundDispose || PixelGetAlpha (source[x]))
+	      if (dispose == BackgroundDispose || fn_PixelGetAlpha (source[x]))
 		{
-		  PixelGetMagickColor (source[x], &pixel);
-		  PixelSetMagickColor (dest[x + source_left], &pixel);
+		  fn_PixelGetMagickColor (source[x], &pixel);
+		  fn_PixelSetMagickColor (dest[x + source_left], &pixel);
 		}
 	    }
-	  PixelSyncIterator (dest_iterator);
+	  fn_PixelSyncIterator (dest_iterator);
 	}
 
-      DestroyPixelIterator (source_iterator);
-      DestroyPixelIterator (dest_iterator);
-      DestroyMagickWand (sub_wand);
+      fn_DestroyPixelIterator (source_iterator);
+      fn_DestroyPixelIterator (dest_iterator);
+      fn_DestroyMagickWand (sub_wand);
     }
 
   /* Cache a copy for the next iteration.  The current wand will be
      destroyed by the caller. */
-  cache->wand = CloneMagickWand (composite_wand);
+  cache->wand = fn_CloneMagickWand (composite_wand);
   cache->index = ino;
 
   return composite_wand;
@@ -8202,57 +8352,57 @@
      find out things about it.  */
 
   /* Initialize the imagemagick environment.  */
-  MagickWandGenesis ();
+  fn_MagickWandGenesis ();
   image = image_spec_value (img->spec, QCindex, NULL);
   ino = INTEGERP (image) ? XFASTINT (image) : 0;
-  image_wand = NewMagickWand ();
+  image_wand = fn_NewMagickWand ();
 
   if (filename)
-    status = MagickReadImage (image_wand, filename);
+    status = fn_MagickReadImage (image_wand, filename);
   else
     {
       filename_hint = imagemagick_filename_hint (img->spec, hint_buffer);
-      MagickSetFilename (image_wand, filename_hint);
-      status = MagickReadImageBlob (image_wand, contents, size);
+      fn_MagickSetFilename (image_wand, filename_hint);
+      status = fn_MagickReadImageBlob (image_wand, contents, size);
     }
 
   if (status == MagickFalse)
     {
       imagemagick_error (image_wand);
-      DestroyMagickWand (image_wand);
+      fn_DestroyMagickWand (image_wand);
       return 0;
     }
 
-  if (ino < 0 || ino >= MagickGetNumberImages (image_wand))
+  if (ino < 0 || ino >= fn_MagickGetNumberImages (image_wand))
     {
       image_error ("Invalid image number `%s' in image `%s'",
 		   image, img->spec);
-      DestroyMagickWand (image_wand);
+      fn_DestroyMagickWand (image_wand);
       return 0;
     }
 
-  if (MagickGetImageDelay (image_wand) > 0)
+  if (fn_MagickGetImageDelay (image_wand) > 0)
     img->lisp_data =
       Fcons (Qdelay,
-             Fcons (make_float (MagickGetImageDelay (image_wand) / 100.0),
+             Fcons (make_float (fn_MagickGetImageDelay (image_wand) / 100.0),
                     img->lisp_data));
 
-  if (MagickGetNumberImages (image_wand) > 1)
+  if (fn_MagickGetNumberImages (image_wand) > 1)
     img->lisp_data =
       Fcons (Qcount,
-             Fcons (make_number (MagickGetNumberImages (image_wand)),
+             Fcons (make_number (fn_MagickGetNumberImages (image_wand)),
                     img->lisp_data));
 
   /* If we have an animated image, get the new wand based on the
      "super-wand". */
-  if (MagickGetNumberImages (image_wand) > 1)
+  if (fn_MagickGetNumberImages (image_wand) > 1)
     {
       MagickWand *super_wand = image_wand;
       image_wand = imagemagick_compute_animated_image (super_wand, ino);
       if (! image_wand)
 	image_wand = super_wand;
       else
-	DestroyMagickWand (super_wand);
+	fn_DestroyMagickWand (super_wand);
     }
 
   /* Retrieve the frame's background color, for use later.  */
@@ -8265,19 +8415,19 @@
 	|| !x_defined_color (f, SSDATA (specified_bg), &bgcolor, 0))
       x_query_frame_background_color (f, &bgcolor);
 
-    bg_wand = NewPixelWand ();
-    PixelSetRed   (bg_wand, (double) bgcolor.red   / 65535);
-    PixelSetGreen (bg_wand, (double) bgcolor.green / 65535);
-    PixelSetBlue  (bg_wand, (double) bgcolor.blue  / 65535);
+    bg_wand = fn_NewPixelWand ();
+    fn_PixelSetRed   (bg_wand, (double) bgcolor.red   / 65535);
+    fn_PixelSetGreen (bg_wand, (double) bgcolor.green / 65535);
+    fn_PixelSetBlue  (bg_wand, (double) bgcolor.blue  / 65535);
   }
 
-  compute_image_size (MagickGetImageWidth (image_wand),
-		      MagickGetImageHeight (image_wand),
+  compute_image_size (fn_MagickGetImageWidth (image_wand),
+		      fn_MagickGetImageHeight (image_wand),
 		      img->spec, &desired_width, &desired_height);
 
   if (desired_width != -1 && desired_height != -1)
     {
-      status = MagickScaleImage (image_wand, desired_width, desired_height);
+      status = fn_MagickScaleImage (image_wand, desired_width, desired_height);
       if (status == MagickFalse)
 	{
 	  image_error ("Imagemagick scale failed", Qnil, Qnil);
@@ -8310,7 +8460,7 @@
 	      if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
 		{
 		  ssize_t crop_y = XINT (XCAR (crop));
-		  MagickCropImage (image_wand, crop_width, crop_height,
+		  fn_MagickCropImage (image_wand, crop_width, crop_height,
 				   crop_x, crop_y);
 		}
 	    }
@@ -8327,7 +8477,7 @@
   if (FLOATP (value))
     {
       rotation = extract_float (value);
-      status = MagickRotateImage (image_wand, bg_wand, rotation);
+      status = fn_MagickRotateImage (image_wand, bg_wand, rotation);
       if (status == MagickFalse)
         {
           image_error ("Imagemagick image rotate failed", Qnil, Qnil);
@@ -8342,20 +8492,20 @@
      (e.g. etc/images/splash.svg shows a white background always).  */
   {
     MagickWand *new_wand;
-    MagickSetImageBackgroundColor (image_wand, bg_wand);
+    fn_MagickSetImageBackgroundColor (image_wand, bg_wand);
 #ifdef HAVE_MAGICKMERGEIMAGELAYERS
-    new_wand = MagickMergeImageLayers (image_wand, MergeLayer);
+    new_wand = fn_MagickMergeImageLayers (image_wand, MergeLayer);
 #else
-    new_wand = MagickFlattenImages (image_wand);
+    new_wand = fn_MagickFlattenImages (image_wand);
 #endif
-    DestroyMagickWand (image_wand);
+    fn_DestroyMagickWand (image_wand);
     image_wand = new_wand;
   }
 
   /* Finally we are done manipulating the image.  Figure out the
      resulting width/height and transfer ownership to Emacs.  */
-  image_height = MagickGetImageHeight (image_wand);
-  image_width = MagickGetImageWidth (image_wand);
+  image_height = fn_MagickGetImageHeight (image_wand);
+  image_width = fn_MagickGetImageWidth (image_wand);
 
   if (! (image_width <= INT_MAX && image_height <= INT_MAX
 	 && check_image_size (f, image_width, image_height)))
@@ -8411,7 +8561,7 @@
         seems about 3 times as fast as pixel pushing(not carefully measured)
       */
       pixelwidth = CharPixel; /*??? TODO figure out*/
-      MagickExportImagePixels (image_wand, 0, 0, width, height,
+      fn_MagickExportImagePixels (image_wand, 0, 0, width, height,
 			       exportdepth, pixelwidth, ximg->data);
     }
   else
@@ -8436,7 +8586,7 @@
          images.  */
 
       /* Copy pixels from the imagemagick image structure to the x image map. */
-      iterator = NewPixelIterator (image_wand);
+      iterator = fn_NewPixelIterator (image_wand);
       if (! iterator)
         {
 #ifdef COLOR_TABLE_SUPPORT
@@ -8448,17 +8598,17 @@
           goto imagemagick_error;
         }
 
-      image_height = MagickGetImageHeight (image_wand);
+      image_height = fn_MagickGetImageHeight (image_wand);
       for (y = 0; y < image_height; y++)
         {
 	  size_t row_width;
-	  pixels = PixelGetNextIteratorRow (iterator, &row_width);
+	  pixels = fn_PixelGetNextIteratorRow (iterator, &row_width);
           if (! pixels)
             break;
 	  int xlim = min (row_width, width);
 	  for (x = 0; x < xlim; x++)
             {
-              PixelGetMagickColor (pixels[x], &pixel);
+              fn_PixelGetMagickColor (pixels[x], &pixel);
               XPutPixel (ximg, x, y,
                          lookup_rgb_color (f,
 					   color_scale * pixel.red,
@@ -8466,7 +8616,7 @@
 					   color_scale * pixel.blue));
             }
         }
-      DestroyPixelIterator (iterator);
+      fn_DestroyPixelIterator (iterator);
     }
 
 #ifdef COLOR_TABLE_SUPPORT
@@ -8482,19 +8632,19 @@
   image_put_x_image (f, img, ximg, 0);
 
   /* Final cleanup. image_wand should be the only resource left. */
-  DestroyMagickWand (image_wand);
-  if (bg_wand) DestroyPixelWand (bg_wand);
+  fn_DestroyMagickWand (image_wand);
+  if (bg_wand) fn_DestroyPixelWand (bg_wand);
 
   /* `MagickWandTerminus' terminates the imagemagick environment.  */
-  MagickWandTerminus ();
+  fn_MagickWandTerminus ();
 
   return 1;
 
  imagemagick_error:
-  DestroyMagickWand (image_wand);
-  if (bg_wand) DestroyPixelWand (bg_wand);
+  fn_DestroyMagickWand (image_wand);
+  if (bg_wand) fn_DestroyPixelWand (bg_wand);
 
-  MagickWandTerminus ();
+  fn_MagickWandTerminus ();
   /* TODO more cleanup.  */
   image_error ("Error parsing IMAGEMAGICK image `%s'", img->spec, Qnil);
   return 0;
@@ -8565,18 +8715,18 @@
   char **imtypes;
   size_t i;
 
-  GetExceptionInfo(&ex);
-  imtypes = GetMagickList ("*", &numf, &ex);
-  DestroyExceptionInfo(&ex);
+  fn_GetExceptionInfo(&ex);
+  imtypes = fn_GetMagickList ("*", &numf, &ex);
+  fn_DestroyExceptionInfo(&ex);
 
   for (i = 0; i < numf; i++)
     {
       Lisp_Object imagemagicktype = intern (imtypes[i]);
       typelist = Fcons (imagemagicktype, typelist);
-      imtypes[i] = MagickRelinquishMemory (imtypes[i]);
+      imtypes[i] = fn_MagickRelinquishMemory (imtypes[i]);
     }
 
-  MagickRelinquishMemory (imtypes);
+  fn_MagickRelinquishMemory (imtypes);
   return Fnreverse (typelist);
 }
 
