add imagemagick support to Windows version emacs.

emacs-24.5-mingw-imagemagick.diff

--- ./configure.ac.orig	2015-04-02 16:23:06.000000000 +0900
+++ ./configure.ac	2015-04-11 07:29:31.587123600 +0900
@@ -2269,9 +2269,13 @@
 
     if test $HAVE_IMAGEMAGICK = yes; then
       AC_DEFINE(HAVE_IMAGEMAGICK, 1, [Define to 1 if using imagemagick.])
+      OLD_CFLAGS=$CFLAGS
+      OLD_LIBS=$LIBS
       CFLAGS="$CFLAGS $IMAGEMAGICK_CFLAGS"
       LIBS="$IMAGEMAGICK_LIBS $LIBS"
       AC_CHECK_FUNCS(MagickExportImagePixels MagickMergeImageLayers)
+      CFLAGS=$OLD_CFLAGS
+      LIBS=$OLD_LIBS
     fi
   fi
 fi
--- ./lisp/loadup.el.orig	2015-04-02 16:23:06.000000000 +0900
+++ ./lisp/loadup.el	2015-04-11 07:29:31.591129000 +0900
@@ -251,6 +251,7 @@
       (load "disp-table")
       (load "w32-common-fns")
       (when (eq system-type 'windows-nt)
+        (load "image")
         (load "w32-fns")
         (load "ls-lisp")
         (load "dos-w32"))))
--- ./lisp/term/w32-win.el.orig	2015-04-02 16:23:06.000000000 +0900
+++ ./lisp/term/w32-win.el	2015-04-11 07:29:31.595124200 +0900
@@ -265,6 +265,8 @@
        '(gdk-pixbuf "libgdk_pixbuf-2.0-0.dll")
        '(glib "libglib-2.0-0.dll")
        '(gobject "libgobject-2.0-0.dll")
+       '(magickwand "libMagickWand-6.Q16HDRI-2.dll" "libMagickWand-6.Q16-2.dll")
+       '(magickcore "libMagickCore-6.Q16HDRI-2.dll" "libMagickCore-6.Q16-2.dll")
        '(gnutls "libgnutls-28.dll" "libgnutls-26.dll")
        '(libxml2 "libxml2-2.dll" "libxml2.dll")
        '(zlib "zlib1.dll" "libz-1.dll")))
--- ./src/image.c.orig	2015-04-02 16:23:06.000000000 +0900
+++ ./src/image.c	2015-04-11 07:29:31.604124200 +0900
@@ -7919,6 +7919,172 @@
 					    MagickPixelPacket *);
 #endif
 
+#ifdef WINDOWSNT
+DEF_IMGLIB_FN (MagickWand *, CloneMagickWand, (const MagickWand *));
+DEF_IMGLIB_FN (MagickWand *, DestroyMagickWand, (MagickWand *));
+DEF_IMGLIB_FN (MagickWand *, DestroyPixelIterator, (PixelIterator *));
+DEF_IMGLIB_FN (PixelWand *, DestroyPixelWand, (PixelWand *));
+DEF_IMGLIB_FN (MagickBooleanType, MagickCropImage, (MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t));
+#ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
+DEF_IMGLIB_FN (MagickBooleanType, MagickExportImagePixels, (MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *));
+#endif
+DEF_IMGLIB_FN (char *, MagickGetException, (const MagickWand *, ExceptionType *));
+DEF_IMGLIB_FN (MagickWand *, MagickGetImage, (MagickWand *));
+DEF_IMGLIB_FN (DisposeType, 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 *));
+#ifdef HAVE_MAGICKMERGEIMAGELAYERS
+DEF_IMGLIB_FN (MagickWand *, MagickMergeImageLayers, (MagickWand *, const ImageLayerMethod));
+#else
+DEF_IMGLIB_FN (MagickWand *, MagickFlattenImages, (MagickWand *));
+#endif
+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, (const PixelWand *, MagickPixelPacket *));
+DEF_IMGLIB_FN (PixelWand **, PixelGetNextIteratorRow, (PixelIterator *, size_t *));
+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 (void, PixelSetGreen, (PixelWand *, const double));
+DEF_IMGLIB_FN (void, PixelSetBlue, (PixelWand *, const double));
+DEF_IMGLIB_FN (MagickBooleanType, PixelSyncIterator, (PixelIterator *));
+
+DEF_IMGLIB_FN (ExceptionInfo *, DestroyExceptionInfo, (ExceptionInfo *));
+DEF_IMGLIB_FN (char *, DestroyString, (char *));
+DEF_IMGLIB_FN (void, GetExceptionInfo, (ExceptionInfo *));
+DEF_IMGLIB_FN (char **, GetMagickList, (const char *, size_t *, ExceptionInfo *));
+
+Lisp_Object Qmagickwand, Qmagickcore;
+
+static bool
+init_imagemagick_functions (void)
+{
+  HMODULE magickwand, magickcore;
+
+  if (!(magickcore = w32_delayed_load (Qmagickcore))
+      || !(magickwand = w32_delayed_load (Qmagickwand)))
+    return 0;
+
+  LOAD_IMGLIB_FN (magickwand, CloneMagickWand);
+  LOAD_IMGLIB_FN (magickwand, DestroyMagickWand);
+  LOAD_IMGLIB_FN (magickwand, DestroyPixelIterator);
+  LOAD_IMGLIB_FN (magickwand, DestroyPixelWand);
+  LOAD_IMGLIB_FN (magickwand, MagickCropImage);
+#ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
+  LOAD_IMGLIB_FN (magickwand, MagickExportImagePixels);
+#endif
+  LOAD_IMGLIB_FN (magickwand, MagickGetException);
+  LOAD_IMGLIB_FN (magickwand, MagickGetImage);
+  LOAD_IMGLIB_FN (magickwand, MagickGetImageDelay);
+  LOAD_IMGLIB_FN (magickwand, MagickGetImageDispose);
+  LOAD_IMGLIB_FN (magickwand, MagickGetImageHeight);
+  LOAD_IMGLIB_FN (magickwand, MagickGetImagePage);
+  LOAD_IMGLIB_FN (magickwand, MagickGetImageSignature);
+  LOAD_IMGLIB_FN (magickwand, MagickGetImageWidth);
+  LOAD_IMGLIB_FN (magickwand, MagickGetNumberImages);
+#ifdef HAVE_MAGICKMERGEIMAGELAYERS
+  LOAD_IMGLIB_FN (magickwand, MagickMergeImageLayers);
+#else
+  LOAD_IMGLIB_FN (magickwand, MagickFlattenImages);
+#endif
+  LOAD_IMGLIB_FN (magickwand, MagickReadImage);
+  LOAD_IMGLIB_FN (magickwand, MagickReadImageBlob);
+  LOAD_IMGLIB_FN (magickwand, MagickRelinquishMemory);
+  LOAD_IMGLIB_FN (magickwand, MagickRotateImage);
+  LOAD_IMGLIB_FN (magickwand, MagickScaleImage);
+  LOAD_IMGLIB_FN (magickwand, MagickSetFilename);
+  LOAD_IMGLIB_FN (magickwand, MagickSetImageBackgroundColor);
+  LOAD_IMGLIB_FN (magickwand, MagickSetIteratorIndex);
+  LOAD_IMGLIB_FN (magickwand, MagickWandGenesis);
+  LOAD_IMGLIB_FN (magickwand, MagickWandTerminus);
+  LOAD_IMGLIB_FN (magickwand, NewMagickWand);
+  LOAD_IMGLIB_FN (magickwand, NewPixelIterator);
+  LOAD_IMGLIB_FN (magickwand, NewPixelWand);
+  LOAD_IMGLIB_FN (magickwand, PixelGetAlpha);
+  LOAD_IMGLIB_FN (magickwand, PixelGetMagickColor);
+  LOAD_IMGLIB_FN (magickwand, PixelGetNextIteratorRow);
+  LOAD_IMGLIB_FN (magickwand, PixelSetIteratorRow);
+  LOAD_IMGLIB_FN (magickwand, PixelSetMagickColor);
+  LOAD_IMGLIB_FN (magickwand, PixelSetRed);
+  LOAD_IMGLIB_FN (magickwand, PixelSetGreen);
+  LOAD_IMGLIB_FN (magickwand, PixelSetBlue);
+  LOAD_IMGLIB_FN (magickwand, PixelSyncIterator);
+
+  LOAD_IMGLIB_FN (magickcore, DestroyExceptionInfo);
+  LOAD_IMGLIB_FN (magickcore, DestroyString);
+  LOAD_IMGLIB_FN (magickcore, GetExceptionInfo);
+  LOAD_IMGLIB_FN (magickcore, GetMagickList);
+
+  return 1;
+}
+#else
+#define fn_CloneMagickWand               CloneMagickWand
+#define fn_DestroyMagickWand             DestroyMagickWand
+#define fn_DestroyPixelIterator          DestroyPixelIterator
+#define fn_DestroyPixelWand              DestroyPixelWand
+#define fn_MagickCropImage               MagickCropImage
+#ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
+#define fn_MagickExportImagePixels       MagickExportImagePixels
+#endif
+#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
+#ifdef HAVE_MAGICKMERGEIMAGELAYERS
+#define fn_MagickMergeImageLayers        MagickMergeImageLayers
+#else
+#define fn_MagickFlattenImages           MagickFlattenImages
+#endif
+#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_PixelSetIteratorRow           PixelSetIteratorRow
+#define fn_PixelSetMagickColor           PixelSetMagickColor
+#define fn_PixelSetRed                   PixelSetRed
+#define fn_PixelSetGreen                 PixelSetGreen
+#define fn_PixelSetBlue                  PixelSetBlue
+#define fn_PixelSyncIterator             PixelSyncIterator
+
+#define fn_DestroyExceptionInfo DestroyExceptionInfo
+#define fn_DestroyString        DestroyString
+#define fn_GetExceptionInfo     GetExceptionInfo
+#define fn_GetMagickList        GetMagickList
+#endif /* !WINDOWSNT */
+
 /* Log ImageMagick error message.
    Useful when a ImageMagick function returns the status `MagickFalse'.  */
 
@@ -7928,11 +8094,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 +8177,7 @@
       else
 	{
 	  if (cache->wand)
-	    DestroyMagickWand (cache->wand);
+	    fn_DestroyMagickWand (cache->wand);
 	  *pcache = cache->next;
 	  xfree (cache);
 	}
@@ -8021,7 +8187,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 +8206,7 @@
       pcache = &cache->next;
     }
 
-  DestroyString (signature);
+  fn_DestroyString (signature);
   cache->update_time = current_timespec ();
   return cache;
 }
@@ -8053,19 +8219,19 @@
   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_width = MagickGetImageWidth (composite_wand);
-  dest_height = MagickGetImageHeight (composite_wand);
+  dest_width = fn_MagickGetImageWidth (composite_wand);
+  dest_height = fn_MagickGetImageHeight (composite_wand);
 
   for (i = max (1, cache->index + 1); i <= ino; i++)
     {
@@ -8078,32 +8244,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);
@@ -8114,11 +8280,11 @@
 	 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))
+      while ((source = fn_PixelGetNextIteratorRow (source_iterator, &source_width))
 	     != NULL)
 	{
 	  ptrdiff_t x;
@@ -8128,7 +8294,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
@@ -8139,23 +8305,23 @@
 		 but if the disposal method is "Background", then we
 		 copy over all pixels.  */
 	      if (dispose == BackgroundDispose ||
-		  PixelGetAlpha (source[x]))
+		  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;
@@ -8203,57 +8369,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.  */
@@ -8273,19 +8439,19 @@
 #endif
       }
 
-    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);
@@ -8318,7 +8484,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);
 		}
 	    }
@@ -8335,7 +8501,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);
@@ -8350,20 +8516,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.  */
-  height = MagickGetImageHeight (image_wand);
-  width = MagickGetImageWidth (image_wand);
+  height = fn_MagickGetImageHeight (image_wand);
+  width = fn_MagickGetImageWidth (image_wand);
 
   if (! (width <= INT_MAX && height <= INT_MAX
 	 && check_image_size (f, width, height)))
@@ -8416,7 +8582,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
@@ -8440,7 +8606,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
@@ -8452,15 +8618,15 @@
           goto imagemagick_error;
         }
 
-      image_height = MagickGetImageHeight (image_wand);
+      image_height = fn_MagickGetImageHeight (image_wand);
       for (y = 0; y < image_height; y++)
         {
-          pixels = PixelGetNextIteratorRow (iterator, &width);
+          pixels = fn_PixelGetNextIteratorRow (iterator, &width);
           if (! pixels)
             break;
           for (x = 0; x < (long) width; x++)
             {
-              PixelGetMagickColor (pixels[x], &pixel);
+              fn_PixelGetMagickColor (pixels[x], &pixel);
               XPutPixel (ximg, x, y,
                          lookup_rgb_color (f,
                                            pixel.red,
@@ -8468,7 +8634,7 @@
                                            pixel.blue));
             }
         }
-      DestroyPixelIterator (iterator);
+      fn_DestroyPixelIterator (iterator);
     }
 
 #ifdef COLOR_TABLE_SUPPORT
@@ -8484,19 +8650,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;
@@ -8568,18 +8734,23 @@
   size_t i;
   Lisp_Object Qimagemagicktype;
 
-  GetExceptionInfo(&ex);
-  imtypes = GetMagickList ("*", &numf, &ex);
-  DestroyExceptionInfo(&ex);
+#if WINDOWSNT
+  if (!init_imagemagick_functions ())
+    return Qnil;
+#endif
+
+  fn_GetExceptionInfo(&ex);
+  imtypes = fn_GetMagickList ("*", &numf, &ex);
+  fn_DestroyExceptionInfo(&ex);
 
   for (i = 0; i < numf; i++)
     {
       Qimagemagicktype = intern (imtypes[i]);
       typelist = Fcons (Qimagemagicktype, typelist);
-      imtypes[i] = MagickRelinquishMemory (imtypes[i]);
+      imtypes[i] = fn_MagickRelinquishMemory (imtypes[i]);
     }
 
-  MagickRelinquishMemory (imtypes);
+  fn_MagickRelinquishMemory (imtypes);
   return Fnreverse (typelist);
 }
 
@@ -9518,6 +9689,10 @@
 #if defined (HAVE_IMAGEMAGICK)
   DEFSYM (Qimagemagick, "imagemagick");
   ADD_IMAGE_TYPE (Qimagemagick);
+#if defined HAVE_NTGUI && !defined CYGWIN
+  DEFSYM (Qmagickwand, "magickwand");
+  DEFSYM (Qmagickcore, "magickcore");
+#endif /* HAVE_NTGUI */
 #endif
 
 #if defined (HAVE_RSVG)