Update the headers for ImageMagick 6.8.9.ImageMagick_6.8.9

18 files changed, 273 insertions, 36 deletions

diff --git a/dmagick/Image.d b/dmagick/Image.d
index b4484b4..dc3597a 100644
--- a/dmagick/Image.d
+++ b/dmagick/Image.d
@@ -2264,21 +2264,6 @@ class Image
 	}
 
 	/**
-	 * Applies a radial blur to the image.
-	 * 
-	 * Params:
-	 *     angle   = The angle of the radial blur, in degrees.
-	 *     channel = If no channels are specified, blurs all the channels.
-	 */
-	void radialBlur(double angle, ChannelType channel = ChannelType.DefaultChannels)
-	{
-		MagickCoreImage* image = 
-			RadialBlurImageChannel(imageRef, channel, angle, DMagickExceptionInfo());
-
-		imageRef = ImageRef(image);
-	}
-
-	/**
 	 * Creates a simulated three-dimensional button-like effect by
 	 * lightening and darkening the edges of the image.
 	 * 
@@ -2441,9 +2426,8 @@ class Image
 	 *     storage = The pixel Staroage type (CharPixel,
 	 *               ShortPixel, IntegerPixel, FloatPixel, or DoublePixel).
 	 *     pixels  = The pixel data.
-	 * Bugs: DMD bug 2972 prevents readpixels from being named just read.
 	 */
-	void readPixels(T)(size_t width, size_t height, string map, T[] pixels)
+	void read(T)(size_t width, size_t height, string map, T[] pixels)
 	{
 		StorageType storage = getStorageType!(T);
 
@@ -2566,6 +2550,31 @@ class Image
 	}
 
 	/**
+	 * Applies a rotational blur to the image.
+	 * 
+	 * Params:
+	 *     angle   = The angle of the rotational blur, in degrees.
+	 *     channel = If no channels are specified, blurs all the channels.
+	 */
+	void rotationalBlur(double angle, ChannelType channel = ChannelType.DefaultChannels)
+	{
+		static if ( is(typeof(RotationalBlurImage)) )
+		{
+			MagickCoreImage* image = 
+				RotationalBlurImageChannel(imageRef, channel, angle, DMagickExceptionInfo());
+		}
+		else
+		{
+			MagickCoreImage* image = 
+				RadialBlurImageChannel(imageRef, channel, angle, DMagickExceptionInfo());
+		}
+
+		imageRef = ImageRef(image);
+	}
+	/** ditto */
+	alias rotationalBlur radialBlur;
+
+	/**
 	 * scales an image to the desired dimensions with pixel sampling.
 	 * Unlike other scaling methods, this method does not introduce any
 	 * additional color into the scaled image.
diff --git a/dmagick/c/accelerate.d b/dmagick/c/accelerate.d
index 3302691..3f477f0 100644
--- a/dmagick/c/accelerate.d
+++ b/dmagick/c/accelerate.d
@@ -1,18 +1,30 @@
 module dmagick.c.accelerate;
 
 import dmagick.c.colorspace;
+import dmagick.c.composite;
 import dmagick.c.exception;
 import dmagick.c.fx;
+import dmagick.c.geometry;
 import dmagick.c.image;
 import dmagick.c.magickType;
 import dmagick.c.magickVersion;
 import dmagick.c.morphology;
+import dmagick.c.pixel;
 import dmagick.c.statistic;
 
 extern(C)
 {
 	MagickBooleanType AccelerateConvolveImage(const(Image)*, const(KernelInfo)*, Image*, ExceptionInfo*);
 
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		MagickBooleanType AccelerateCompositeImage(Image*, const ChannelType, const CompositeOperator, const(Image)*, const ssize_t, const ssize_t, const float, const float, ExceptionInfo*);
+		MagickBooleanType AccelerateContrastStretchImageChannel(Image*, const ChannelType, const double, const double, ExceptionInfo*);
+		MagickBooleanType AccelerateGrayscaleImage(Image*, const PixelIntensityMethod, ExceptionInfo*);
+		MagickBooleanType AccelerateNegateImageChannel(Image*, const ChannelType, const MagickBooleanType, ExceptionInfo*);
+		MagickBooleanType AccelerateRandomImage(Image*, ExceptionInfo*);
+	}
+
 	static if ( MagickLibVersion >= 0x688 )
 	{
 		MagickBooleanType AccelerateContrastImage(Image*, const MagickBooleanType, ExceptionInfo*);
@@ -31,4 +43,9 @@ extern(C)
 	{
 		Image* AccelerateConvolveImageChannel(const(Image)*, const ChannelType, const(KernelInfo)*, ExceptionInfo*);
 	}
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		Image* AccelerateMotionBlurImage(const Image*, const ChannelType, const(double)*, const size_t, const(OffsetInfo)*, ExceptionInfo*);
+	}
 }
diff --git a/dmagick/c/compare.d b/dmagick/c/compare.d
index b42ed20..b214120 100644
--- a/dmagick/c/compare.d
+++ b/dmagick/c/compare.d
@@ -20,7 +20,8 @@ extern(C)
 		RootMeanSquaredErrorMetric,
 		NormalizedCrossCorrelationErrorMetric,
 		FuzzErrorMetric,
-		UndefinedErrorMetric = 0
+		UndefinedErrorMetric = 0,
+		PerceptualHashErrorMetric = 0xff
 	}
 
 	double* GetImageChannelDistortions(Image*, const(Image)*, const MetricType, ExceptionInfo*);
diff --git a/dmagick/c/constitute.d b/dmagick/c/constitute.d
index d8bbcb5..837712e 100644
--- a/dmagick/c/constitute.d
+++ b/dmagick/c/constitute.d
@@ -3,6 +3,7 @@ module dmagick.c.constitute;
 import dmagick.c.exception;
 import dmagick.c.image;
 import dmagick.c.magickType;
+import dmagick.c.magickVersion;
 
 extern(C)
 {
@@ -28,9 +29,16 @@ extern(C)
 	Image* ReadImages(const(ImageInfo)*, ExceptionInfo*);
 	Image* ReadInlineImage(const(ImageInfo)*, const(char)*, ExceptionInfo*);
 
-	MagickBooleanType ConstituteComponentGenesis();
+
+	static if ( MagickLibVersion < 0x689 )
+	{
+		MagickBooleanType ConstituteComponentGenesis();
+	}
 	MagickBooleanType WriteImage(const(ImageInfo)*, Image*);
 	MagickBooleanType WriteImages(const(ImageInfo)*, Image*, const(char)*, ExceptionInfo*);
 
-	void ConstituteComponentTerminus();
+	static if ( MagickLibVersion < 0x689 )
+	{
+		void ConstituteComponentTerminus();
+	}
 }
diff --git a/dmagick/c/deprecate.d b/dmagick/c/deprecate.d
index e2d64fb..0be9391 100644
--- a/dmagick/c/deprecate.d
+++ b/dmagick/c/deprecate.d
@@ -31,6 +31,13 @@ deprecated extern(C)
 	alias MagickOffsetType ExtendedSignedIntegralType;
 	alias MagickSizeType   ExtendedUnsignedIntegralType;
 	alias MagickRealType   ExtendedRationalType;
+	/// The Quantum depth ImageMagick / DMagick is compiled with.
+	alias MagickQuantumDepth MAGICKCORE_QUANTUM_DEPTH;
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		enum MagickRealType MagickHuge    = 3.4e+38;
+	}
 
 	struct ViewInfo {}
 
@@ -107,6 +114,12 @@ deprecated extern(C)
 	Image* MosaicImages(Image*, ExceptionInfo*);
 	Image* PopImageList(Image**);
 
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		Image* RadialBlurImage(const(Image)*, const double, ExceptionInfo*);
+		Image* RadialBlurImageChannel(const(Image)*, const ChannelType, const double, ExceptionInfo*);
+	}
+
 	static if ( MagickLibVersion >= 0x661 )
 	{
 		Image* RecolorImage(const(Image)*, const size_t, const(double)*, ExceptionInfo*);
@@ -140,6 +153,12 @@ deprecated extern(C)
 	MagickBooleanType ClipPathImage(Image*, const(char)*, const MagickBooleanType);
 	MagickBooleanType CloneImageAttributes(Image*, const(Image)*);
 	MagickBooleanType ColorFloodfillImage(Image*, const(DrawInfo)*, const PixelPacket, const ssize_t, const ssize_t, const PaintMethod);
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		MagickBooleanType ConstituteComponentGenesis();
+	}
+
 	MagickBooleanType DeleteImageAttribute(Image*, const(char)*);
 	MagickBooleanType DeleteMagickRegistry(const ssize_t);
 	MagickBooleanType DescribeImage(Image*, FILE*, const MagickBooleanType);
@@ -153,7 +172,20 @@ deprecated extern(C)
 
 	MagickBooleanType FuzzyColorCompare(const(Image)*, const(PixelPacket)*, const(PixelPacket)*);
 	MagickBooleanType FuzzyOpacityCompare(const(Image)*, const(PixelPacket)*, const(PixelPacket)*);
+
+	static if (MagickLibVersion >= 0x689)
+	{
+		MagickBooleanType InitializeModuleList(ExceptionInfo*);
+		MagickBooleanType IsMagickInstantiated();
+	}
+
 	MagickBooleanType LevelImageColors(Image*, const ChannelType, const(MagickPixelPacket)*, const(MagickPixelPacket)*, const MagickBooleanType);
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		MagickBooleanType LoadMimeLists(const(char)*, ExceptionInfo*);
+	}
+
 	MagickBooleanType MagickMonitor(const(char)*, const MagickOffsetType, const MagickSizeType, void*);
 	MagickBooleanType MapImage(Image*, const(Image)*, const MagickBooleanType);
 	MagickBooleanType MapImages(Image*, const(Image)*, const MagickBooleanType);
@@ -220,7 +252,19 @@ deprecated extern(C)
 	uint UnshiftImageList(Image**, const(Image)*, ExceptionInfo*);
 
 	void* AcquireMemory(const size_t);
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		void AcquireSemaphoreInfo(SemaphoreInfo**);
+	}
+
 	void  AllocateNextImage(const(ImageInfo)*, Image*);
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		void ConstituteComponentTerminus();
+	}
+
 	void* CloneMemory(void*, const(void)*, const size_t);
 
 	static if ( MagickLibVersion >= 0x655 )
@@ -243,6 +287,12 @@ deprecated extern(C)
 	void  InitializeMagick(const(char)*);
 	void  MagickIncarnate(const(char)*);
 	void  ReacquireMemory(void**, const size_t);
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		void RelinquishSemaphoreInfo(SemaphoreInfo*);
+	}
+
 	void  ResetImageAttributeIterator(const(Image)*);
 	void  SetCacheThreshold(const size_t);
 	void  SetImage(Image*, const Quantum);
diff --git a/dmagick/c/effect.d b/dmagick/c/effect.d
index e9e84a8..3e4e112 100644
--- a/dmagick/c/effect.d
+++ b/dmagick/c/effect.d
@@ -51,6 +51,12 @@ extern(C)
 	Image* AdaptiveSharpenImageChannel(const(Image)*, const ChannelType, const double, const double, ExceptionInfo*);
 	Image* BlurImage(const(Image)*, const double, const double, ExceptionInfo*);
 	Image* BlurImageChannel(const(Image)*, const ChannelType, const double, const double, ExceptionInfo*);
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		Image* CannyEdgeImage(const(Image)*, const double, const double, const double, const double, ExceptionInfo*);
+	}
+
 	Image* ConvolveImage(const(Image)*, const size_t, const(double)*, ExceptionInfo*);
 	Image* ConvolveImageChannel(const(Image)*, const ChannelType, const size_t, const(double)*, ExceptionInfo*);
 	Image* DespeckleImage(const(Image)*, ExceptionInfo*);
@@ -74,8 +80,18 @@ extern(C)
 	Image* MotionBlurImage(const(Image)*, const double, const double, const double, ExceptionInfo*);
 	Image* MotionBlurImageChannel(const(Image)*, const ChannelType, const double, const double, const double, ExceptionInfo*);
 	Image* PreviewImage(const(Image)*, const PreviewType, ExceptionInfo*);
-	Image* RadialBlurImage(const(Image)*, const double, ExceptionInfo*);
-	Image* RadialBlurImageChannel(const(Image)*, const ChannelType, const double, ExceptionInfo*);
+	
+	static if ( MagickLibVersion < 0x689 )
+	{
+		Image* RadialBlurImage(const(Image)*, const double, ExceptionInfo*);
+		Image* RadialBlurImageChannel(const(Image)*, const ChannelType, const double, ExceptionInfo*);
+	}
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		Image* RotationalBlurImage(const(Image)*, const double, ExceptionInfo*);
+		Image* RotationalBlurImageChannel(const(Image)*, const ChannelType, const double, ExceptionInfo*);
+	}
 
 	static if ( MagickLibVersion < 0x669 )
 	{
diff --git a/dmagick/c/exception.d b/dmagick/c/exception.d
index 57bdb13..2e3642e 100644
--- a/dmagick/c/exception.d
+++ b/dmagick/c/exception.d
@@ -3,6 +3,7 @@ module dmagick.c.exception;
 import core.vararg;
 
 import dmagick.c.magickType;
+import dmagick.c.magickVersion;
 import dmagick.c.semaphore;
 
 extern(C)
@@ -117,6 +118,12 @@ extern(C)
 	ErrorHandler SetErrorHandler(ErrorHandler);
 
 	ExceptionInfo* AcquireExceptionInfo();
+
+	static if ( MagickLibVersion >= 0x669 )
+	{
+		ExceptionInfo* CloneExceptionInfo(ExceptionInfo*);
+	}
+
 	ExceptionInfo* DestroyExceptionInfo(ExceptionInfo*);
 
 	FatalErrorHandler SetFatalErrorHandler(FatalErrorHandler);
diff --git a/dmagick/c/image.d b/dmagick/c/image.d
index b008ce9..71d6a3b 100644
--- a/dmagick/c/image.d
+++ b/dmagick/c/image.d
@@ -483,6 +483,12 @@ extern(C)
 			PixelIntensityMethod
 				intensity;      /* method to generate an intensity value from a pixel */
 		}
+
+		static if ( MagickLibVersion >= 0x689 )
+		{
+			/** Total animation duration sum(delay*iterations) */
+			size_t duration;
+		}
 	}
 
 	struct ImageInfo
diff --git a/dmagick/c/log.d b/dmagick/c/log.d
index 767f402..9383b0b 100644
--- a/dmagick/c/log.d
+++ b/dmagick/c/log.d
@@ -66,6 +66,11 @@ extern(C)
 
 	struct LogInfo {}
 
+	static if (MagickLibVersion >= 0x689)
+	{
+		alias void function(const LogEventType, const(char)*) MagickLogMethod;
+	}
+
 	char** GetLogList(const(char)*, size_t*, ExceptionInfo*);
 
 	const(char)* GetLogName();
@@ -84,4 +89,9 @@ extern(C)
 	void CloseMagickLog();
 	void LogComponentTerminus();
 	void SetLogFormat(const(char)*);
+
+	static if (MagickLibVersion >= 0x689)
+	{
+		void SetLogMethod(MagickLogMethod);
+	}
 }
diff --git a/dmagick/c/magick.d b/dmagick/c/magick.d
index 06b5296..36fe03b 100644
--- a/dmagick/c/magick.d
+++ b/dmagick/c/magick.d
@@ -4,6 +4,7 @@ import dmagick.c.exception;
 import dmagick.c.image;
 import dmagick.c.magickType;
 import dmagick.c.magickVersion;
+import dmagick.c.semaphore;
 
 extern(C)
 {
@@ -77,6 +78,12 @@ extern(C)
 			char*
 				mime_type;
 		}
+
+		static if (MagickLibVersion >= 0x689)
+		{
+			SemaphoreInfo*
+				semaphore;
+		}
 	}
 
 	char** GetMagickList(const(char)*, size_t*, ExceptionInfo*);
@@ -101,7 +108,17 @@ extern(C)
 	MagickBooleanType GetMagickEndianSupport(const(MagickInfo)*);
 	MagickBooleanType GetMagickRawSupport(const(MagickInfo)*);
 	MagickBooleanType GetMagickSeekableStream(const(MagickInfo)*);
-	MagickBooleanType IsMagickInstantiated();
+	
+	static if (MagickLibVersion < 0x689)
+	{
+		MagickBooleanType IsMagickInstantiated();
+	}
+
+	static if (MagickLibVersion >= 0x689)
+	{
+		MagickBooleanType IsMagickCoreInstantiated();
+	}
+
 	MagickBooleanType MagickComponentGenesis();
 	MagickBooleanType UnregisterMagickInfo(const(char)*);
 
diff --git a/dmagick/c/magickDelegate.d b/dmagick/c/magickDelegate.d
index 98223a4..d194eb2 100644
--- a/dmagick/c/magickDelegate.d
+++ b/dmagick/c/magickDelegate.d
@@ -5,6 +5,8 @@ import core.stdc.stdio;
 import dmagick.c.exception;
 import dmagick.c.image;
 import dmagick.c.magickType;
+import dmagick.c.magickVersion;
+import dmagick.c.semaphore;
 
 alias ptrdiff_t ssize_t;
 
@@ -32,6 +34,11 @@ extern(C)
 
 		size_t
 			signature;
+
+		static if ( MagickLibVersion >= 0x689 )
+		{
+			SemaphoreInfo* semaphore;
+		}
 	}
 
 	char*  GetDelegateCommand(const(ImageInfo)*, Image*, const(char)*, const(char)*, ExceptionInfo*);
diff --git a/dmagick/c/magickModule.d b/dmagick/c/magickModule.d
index 364d511..8aa3a6e 100644
--- a/dmagick/c/magickModule.d
+++ b/dmagick/c/magickModule.d
@@ -6,6 +6,7 @@ import core.stdc.time;
 import dmagick.c.exception;
 import dmagick.c.image;
 import dmagick.c.magickType;
+import dmagick.c.magickVersion;
 
 extern(C)
 {
@@ -50,7 +51,11 @@ extern(C)
 
 	const(ModuleInfo)** GetModuleInfoList(const(char)*, size_t*, ExceptionInfo*);
 
-	MagickBooleanType InitializeModuleList(ExceptionInfo*);
+	static if ( MagickLibVersion < 0x689 )
+	{
+		MagickBooleanType InitializeModuleList(ExceptionInfo*);
+	}
+
 	MagickBooleanType InvokeDynamicImageFilter(const(char)*, Image**, const int, const(char)**, ExceptionInfo*);
 	MagickBooleanType ListModuleInfo(FILE*, ExceptionInfo*);
 	MagickBooleanType ModuleComponentGenesis();
diff --git a/dmagick/c/magickType.d b/dmagick/c/magickType.d
index b3cacb6..89e1cec 100644
--- a/dmagick/c/magickType.d
+++ b/dmagick/c/magickType.d
@@ -40,7 +40,7 @@ extern (C)
 		 * as Quantum.max except when the Quantum dept is 64 bits.
 		 */
 		enum QuantumRange = ubyte.max;
-		enum MAGICKCORE_QUANTUM_DEPTH = 8;
+		enum MagickQuantumDepth = 8;
 		enum MaxColormapSize = 256;
 
 		static if ( MagickLibVersion < 0x678 )
@@ -72,7 +72,7 @@ extern (C)
 		 * as Quantum.max except when the Quantum dept is 64 bits.
 		 */
 		enum QuantumRange = uint.max;
-		enum MAGICKCORE_QUANTUM_DEPTH = 32;
+		enum MagickQuantumDepth = 32;
 		enum MaxColormapSize = 65536;
 
 		static if ( MagickLibVersion < 0x678 )
@@ -98,7 +98,7 @@ extern (C)
 		 * as Quantum.max except when the Quantum dept is 64 bits.
 		 */
 		enum QuantumRange = 18446744073709551615.0;
-		enum MAGICKCORE_QUANTUM_DEPTH = 64;
+		enum MagickQuantumDepth = 64;
 		enum MaxColormapSize = 65536;
 
 		static if ( MagickLibVersion < 0x678 )
@@ -132,7 +132,7 @@ extern (C)
 		 * as Quantum.max except when the Quantum dept is 64 bits.
 		 */
 		enum QuantumRange = ushort.max;
-		enum MAGICKCORE_QUANTUM_DEPTH = 16;
+		enum MagickQuantumDepth = 16;
 		enum MaxColormapSize = 65536;
 
 		static if ( MagickLibVersion < 0x678 )
@@ -157,11 +157,15 @@ extern (C)
 		enum MagickRealType MagickEpsilon = 1.0e-16;
 		enum MagickRealType MagickHuge    = 3.4e+38;
 	}
-	else static if ( MagickLibVersion >= 0x681 )
+	else static if ( MagickLibVersion >= 0x681 && MagickLibVersion < 0x689 )
 	{
 		enum MagickRealType MagickEpsilon = 1.0e-15;
 		enum MagickRealType MagickHuge    = 3.4e+38;
 	}
+	else static if ( MagickLibVersion >= 0x689 )
+	{
+		enum MagickRealType MagickEpsilon = 1.0e-15;
+	}
 
 	alias uint  MagickStatusType;
 	alias long  MagickOffsetType;
@@ -172,8 +176,8 @@ extern (C)
 	alias MaxColormapSize MaxMap;
 	enum  MaxTextExtent = 4096;
 
-	/// The Quantum depth ImageMagick / DMagick is compiled with.
-	alias MAGICKCORE_QUANTUM_DEPTH MagickQuantumDepth;
+	enum MagickMaximumValue = 1.79769313486231570E+308;
+	enum MagickMinimumValue = 2.22507385850720140E-308;
 
 	enum  QuantumScale  = (1.0/ cast(double)QuantumRange);
 	alias QuantumRange    TransparentOpacity; /// Fully transparent Quantum.
diff --git a/dmagick/c/magickVersion.d b/dmagick/c/magickVersion.d
index 5a1890e..8898e5b 100644
--- a/dmagick/c/magickVersion.d
+++ b/dmagick/c/magickVersion.d
@@ -201,13 +201,20 @@ extern(C)
 		///ditto
 		enum MagickLibVersionText = "6.8.7";
 	}
-	else
+	else version(MagickCore_688)
 	{
 		/// Defines the version of ImageMagick where these headers are based on.
 		enum MagickLibVersion = 0x688;
 		///ditto
 		enum MagickLibVersionText = "6.8.8";
 	}
+	else
+	{
+		/// Defines the version of ImageMagick where these headers are based on.
+		enum MagickLibVersion = 0x689;
+		///ditto
+		enum MagickLibVersionText = "6.8.9";
+	}
 
 	/*
 	 * With ImageMagick 6.6.3 long and unsinged long were changed to
diff --git a/dmagick/c/matrix.d b/dmagick/c/matrix.d
index db4c5e2..52f2d14 100644
--- a/dmagick/c/matrix.d
+++ b/dmagick/c/matrix.d
@@ -1,13 +1,32 @@
 module dmagick.c.matrix;
 
+import dmagick.c.exception;
 import dmagick.c.magickType;
+import dmagick.c.magickVersion;
+
+alias ptrdiff_t ssize_t;
 
 extern(C)
 {
+	struct MatrixInfo;
+
 	double** AcquireMagickMatrix(const size_t, const size_t);
 	double** RelinquishMagickMatrix(double**, const size_t);
 
 	MagickBooleanType GaussJordanElimination(double**, double**, const size_t, const size_t);
 
+	static if ( MagickLibVersion >= 0x669 )
+	{
+		MagickBooleanType GetMatrixElement(const(MatrixInfo)*, const ssize_t, const ssize_t, void*);
+		MagickBooleanType NullMatrix(MatrixInfo*);
+		MagickBooleanType SetMatrixElement(const(MatrixInfo)*, const ssize_t, const ssize_t, const(void)*);
+
+		MatrixInfo* AcquireMatrixInfo(const size_t, const size_t, const size_t, ExceptionInfo*);
+		MatrixInfo* DestroyMatrixInfo(MatrixInfo*);
+
+		size_t GetMatrixColumns(const(MatrixInfo)*);
+		size_t GetMatrixRows(const(MatrixInfo)*);
+	}
+
 	void LeastSquaresAddTerms(double**, double**, const(double)*, const(double)*, const size_t, const size_t);
 }
diff --git a/dmagick/c/mime.d b/dmagick/c/mime.d
index 9fb66fb..dc20214 100644
--- a/dmagick/c/mime.d
+++ b/dmagick/c/mime.d
@@ -4,6 +4,7 @@ import core.stdc.stdio;
 
 import dmagick.c.exception;
 import dmagick.c.magickType;
+import dmagick.c.magickVersion;
 
 extern(C)
 {
@@ -16,7 +17,12 @@ extern(C)
 	const(char)* GetMimeType(const(MimeInfo)*);
 
 	MagickBooleanType ListMimeInfo(FILE*, ExceptionInfo*);
-	MagickBooleanType LoadMimeLists(const(char)*, ExceptionInfo*);
+
+	static if ( MagickLibVersion < 0x689 )
+	{
+		MagickBooleanType LoadMimeLists(const(char)*, ExceptionInfo*);
+	}
+
 	MagickBooleanType MimeComponentGenesis();
 
 	const(MimeInfo)*  GetMimeInfo(const(char)*, const(ubyte)*, const size_t, ExceptionInfo*);
diff --git a/dmagick/c/semaphore.d b/dmagick/c/semaphore.d
index 92ed1ed..ca9b902 100644
--- a/dmagick/c/semaphore.d
+++ b/dmagick/c/semaphore.d
@@ -1,6 +1,7 @@
 module dmagick.c.semaphore;
 
 import dmagick.c.magickType;
+import dmagick.c.magickVersion;
 
 extern(C)
 {
@@ -10,10 +11,24 @@ extern(C)
 
 	SemaphoreInfo* AllocateSemaphoreInfo();
 
-	void AcquireSemaphoreInfo(SemaphoreInfo**);
+	static if ( MagickLibVersion < 0x689 )
+	{
+		void AcquireSemaphoreInfo(SemaphoreInfo**);
+	}
+
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		void ActivateSemaphoreInfo(SemaphoreInfo**);
+	}
+
 	void DestroySemaphoreInfo(SemaphoreInfo**);
 	void LockSemaphoreInfo(SemaphoreInfo*);
-	void RelinquishSemaphoreInfo(SemaphoreInfo*);
+
+	static if ( MagickLibVersion < 0x689 )
+	{
+		void RelinquishSemaphoreInfo(SemaphoreInfo*);
+	}
+
 	void SemaphoreComponentTerminus();
 	void UnlockSemaphoreInfo(SemaphoreInfo*);
 }
diff --git a/dmagick/c/statistic.d b/dmagick/c/statistic.d
index 6577ab5..485a152 100644
--- a/dmagick/c/statistic.d
+++ b/dmagick/c/statistic.d
@@ -1,5 +1,6 @@
 module dmagick.c.statistic;
 
+import dmagick.c.draw;
 import dmagick.c.exception;
 import dmagick.c.image;
 import dmagick.c.magickType;
@@ -39,6 +40,31 @@ extern(C)
 		}
 	}
 
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		struct ChannelMoments
+		{
+			double[32]
+				I;
+
+			PointInfo
+				centroid,
+				ellipse_axis;
+
+			double
+				ellipse_angle,
+				ellipse_eccentricity,
+				ellipse_intensity;
+		}
+
+		struct ChannelPerceptualHash
+		{
+			double[32]
+				P,
+				Q;
+		}
+	}
+
 	/**
 	 * Alter channel pixels by evaluating an arithmetic, relational,
 	 * or logical expression.
@@ -146,6 +172,13 @@ extern(C)
 
 	ChannelStatistics* GetImageChannelStatistics(const(Image)*, ExceptionInfo*);
 
+	static if ( MagickLibVersion >= 0x689 )
+	{
+		ChannelMoments* GetImageChannelMoments(const(Image)*, ExceptionInfo*);
+
+		ChannelPerceptualHash* GetImageChannelPerceptualHash(const(Image)*, ExceptionInfo*);
+	}
+
 	static if ( MagickLibVersion < 0x661 )
 	{
 		Image* AverageImages(const(Image)*, ExceptionInfo*);
@@ -177,7 +210,7 @@ extern(C)
 	MagickBooleanType GetImageChannelKurtosis(const(Image)*, const ChannelType, double*, double*, ExceptionInfo*);
 	MagickBooleanType GetImageChannelRange(const(Image)*, const ChannelType, double*, double*, ExceptionInfo*);
 	MagickBooleanType GetImageExtrema(const(Image)*, size_t*, size_t*, ExceptionInfo*);
-	MagickBooleanType GetImageRange(const(Image)*, double*, double*, ExceptionInfo*);
 	MagickBooleanType GetImageMean(const(Image)*, double*, double*, ExceptionInfo*);
 	MagickBooleanType GetImageKurtosis(const(Image)*, double*, double*, ExceptionInfo*);
+	MagickBooleanType GetImageRange(const(Image)*, double*, double*, ExceptionInfo*);
 }