- Add ImageMagick 6.8.3-1 sources

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/ImageMagick.h

@@ -0,0 +1,34 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  Deprecated as of ImageMagick 6.2.3.
+
+  MagickCore Application Programming Interface declarations.
+*/
+
+#ifndef _MAGICKCORE_IMAGEMAGICK_DEPRECATED_H
+#define _MAGICKCORE_IMAGEMAGICK_DEPRECATED_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/MagickCore.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/MagickCore.h

@@ -0,0 +1,153 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore Application Programming Interface declarations.
+*/
+
+#ifndef _MAGICKCORE_CORE_H
+#define _MAGICKCORE_CORE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if !defined(_MAGICKCORE_CONFIG_H)
+# define _MAGICKCORE_CONFIG_H
+# if !defined(vms) && !defined(macintosh)
+#  include "magick/magick-config.h"
+# else
+#  include "magick-config.h"
+# endif
+#if defined(_magickcore_const) && !defined(const)
+# define const _magickcore_const
+#endif
+#if defined(_magickcore_inline) && !defined(inline)
+# define inline _magickcore_inline
+#endif
+#if defined(_magickcore_restrict) && !defined(restrict)
+# define restrict  _magickcore_restrict
+#endif
+# if defined(__cplusplus) || defined(c_plusplus)
+#  undef inline
+# endif
+#endif
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+#if defined(WIN32) || defined(WIN64)
+#  define MAGICKCORE_WINDOWS_SUPPORT
+#else
+#  define MAGICKCORE_POSIX_SUPPORT
+#endif 
+
+#include "magick/method-attribute.h"
+
+#if defined(MAGICKCORE_NAMESPACE_PREFIX)
+# include "magick/methods.h"
+#endif
+#include "magick/magick-type.h"
+#include "magick/accelerate.h"
+#include "magick/animate.h"
+#include "magick/annotate.h"
+#include "magick/artifact.h"
+#include "magick/attribute.h"
+#include "magick/blob.h"
+#include "magick/cache.h"
+#include "magick/cache-view.h"
+#include "magick/channel.h"
+#include "magick/cipher.h"
+#include "magick/client.h"
+#include "magick/coder.h"
+#include "magick/color.h"
+#include "magick/colorspace.h"
+#include "magick/colormap.h"
+#include "magick/compare.h"
+#include "magick/composite.h"
+#include "magick/compress.h"
+#include "magick/configure.h"
+#include "magick/constitute.h"
+#include "magick/decorate.h"
+#include "magick/delegate.h"
+#include "magick/deprecate.h"
+#include "magick/display.h"
+#include "magick/distort.h"
+#include "magick/distribute-cache.h"
+#include "magick/draw.h"
+#include "magick/effect.h"
+#include "magick/enhance.h"
+#include "magick/exception.h"
+#include "magick/feature.h"
+#include "magick/fourier.h"
+#include "magick/fx.h"
+#include "magick/gem.h"
+#include "magick/geometry.h"
+#include "magick/hashmap.h"
+#include "magick/histogram.h"
+#include "magick/identify.h"
+#include "magick/image.h"
+#include "magick/image-view.h"
+#include "magick/layer.h"
+#include "magick/list.h"
+#include "magick/locale_.h"
+#include "magick/log.h"
+#include "magick/magic.h"
+#include "magick/magick.h"
+#include "magick/matrix.h"
+#include "magick/memory_.h"
+#include "magick/module.h"
+#include "magick/mime.h"
+#include "magick/monitor.h"
+#include "magick/montage.h"
+#include "magick/morphology.h"
+#include "magick/option.h"
+#include "magick/paint.h"
+#include "magick/pixel.h"
+#include "magick/pixel-accessor.h"
+#include "magick/policy.h"
+#include "magick/prepress.h"
+#include "magick/profile.h"
+#include "magick/property.h"
+#include "magick/quantize.h"
+#include "magick/quantum.h"
+#include "magick/registry.h"
+#include "magick/random_.h"
+#include "magick/resample.h"
+#include "magick/resize.h"
+#include "magick/resource_.h"
+#include "magick/segment.h"
+#include "magick/shear.h"
+#include "magick/signature.h"
+#include "magick/splay-tree.h"
+#include "magick/stream.h"
+#include "magick/statistic.h"
+#include "magick/string_.h"
+#include "magick/timer.h"
+#include "magick/token.h"
+#include "magick/transform.h"
+#include "magick/threshold.h"
+#include "magick/type.h"
+#include "magick/utility.h"
+#include "magick/version.h"
+#include "magick/xml-tree.h"
+#include "magick/xwindow.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/PreRvIcccm.h

@@ -0,0 +1,115 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore X11 compatibility methods.
+*/
+#ifndef _MAGICKCORE_PRER5ICCCM_H
+#define _MAGICKCORE_PRER5ICCCM_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if defined(PRE_R6_ICCCM)
+/*
+  Compatability defines for pre X11R6 ICCCM.
+*/
+#define XK_KP_Home              0xFF95
+#define XK_KP_Left              0xFF96
+#define XK_KP_Up                0xFF97
+#define XK_KP_Right             0xFF98
+#define XK_KP_Down              0xFF99
+#define XK_KP_Prior             0xFF9A
+#define XK_KP_Page_Up           0xFF9A
+#define XK_KP_Next              0xFF9B
+#define XK_KP_Page_Down         0xFF9B
+#define XK_KP_End               0xFF9C
+#define XK_KP_Delete            0xFF9F
+
+extern MagickExport Status
+  XInitImage(XImage *ximage);
+#endif
+
+#if defined(PRE_R5_ICCCM)
+extern MagickExport XrmDatabase
+  XrmGetDatabase();
+#endif
+
+#if defined(PRE_R4_ICCCM)
+#if defined(vms)
+#define XMaxRequestSize(display)  16384
+#endif
+
+#define WithdrawnState  0
+
+typedef struct _XTextProperty
+{
+  unsigned char
+    *value;
+
+  Atom
+    encoding;
+
+  int
+    format;
+
+  size_t
+    nitems;
+} XTextProperty;
+
+char
+  *XResourceManagerString();
+
+extern MagickExport int
+  XWMGeometry();
+
+extern MagickExport Status
+  XGetRGBColormaps(),
+  XGetWMName(),
+  XReconfigureWMWindow(),
+  XSetWMProtocols(),
+  XWithdrawWindow();
+
+extern MagickExport XClassHint
+  *XAllocClassHint();
+
+extern MagickExport XIconSize
+  *XAllocIconSize();
+
+extern MagickExport XSizeHints
+  *XAllocSizeHints();
+
+extern MagickExport XStandardColormap
+  *XAllocStandardColormap();
+
+extern MagickExport XWMHints
+  *XAllocWMHints();
+
+extern MagickExport VisualID
+  XVisualIDFromVisual();
+
+extern MagickExport void
+  XrmDestroyDatabase(),
+  XSetWMIconName(),
+  XSetWMName(),
+  XSetWMProperties();
+#else
+#endif
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/accelerate.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore acceleration methods.
+*/
+#ifndef _MAGICKCORE_ACCELERATE_H
+#define _MAGICKCORE_ACCELERATE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/morphology.h"
+
+extern MagickExport MagickBooleanType
+  AccelerateConvolveImage(const Image *,const KernelInfo *,Image *,
+    ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/animate.h

@@ -0,0 +1,32 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore methods to interactively animate an image sequence.
+*/
+#ifndef _MAGICKCORE_ANIMATE_H
+#define _MAGICKCORE_ANIMATE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  AnimateImages(const ImageInfo *,Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/annotate.h

@@ -0,0 +1,44 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image annotation methods.
+*/
+#ifndef _MAGICKCORE_ANNOTATE_H
+#define _MAGICKCORE_ANNOTATE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/draw.h"
+
+extern MagickExport MagickBooleanType
+  AnnotateComponentGenesis(void),
+  AnnotateImage(Image *,const DrawInfo *),
+  GetMultilineTypeMetrics(Image *,const DrawInfo *,TypeMetric *),
+  GetTypeMetrics(Image *,const DrawInfo *,TypeMetric *);
+
+extern MagickExport ssize_t
+  FormatMagickCaption(Image *,DrawInfo *,const MagickBooleanType,TypeMetric *,
+    char **);
+
+extern MagickExport void
+  AnnotateComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/api.h

@@ -0,0 +1,34 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  Deprecated as of ImageMagick 6.2.3.
+
+  MagickCore Application Programming Interface declarations.
+*/
+
+#ifndef _MAGICKCORE_API_DEPRECATED_H
+#define _MAGICKCORE_API_DEPRECATED_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/MagickCore.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/artifact.h

@@ -0,0 +1,46 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore artifact methods.
+*/
+#ifndef _MAGICKCORE_ARTIFACT_H
+#define _MAGICKCORE_ARTIFACT_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport char
+  *GetNextImageArtifact(const Image *),
+  *RemoveImageArtifact(Image *,const char *);
+
+extern MagickExport const char
+  *GetImageArtifact(const Image *,const char *);
+
+extern MagickExport MagickBooleanType
+  CloneImageArtifacts(Image *,const Image *),
+  DefineImageArtifact(Image *,const char *),
+  DeleteImageArtifact(Image *,const char *),
+  SetImageArtifact(Image *,const char *,const char *);
+
+extern MagickExport void
+  DestroyImageArtifacts(Image *),
+  ResetImageArtifactIterator(const Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/attribute.h

@@ -0,0 +1,51 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore methods to set or get image attributes.
+*/
+#ifndef _MAGICKCORE_ATTRIBUTE_H
+#define _MAGICKCORE_ATTRIBUTE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/image.h"
+#include "magick/exception.h"
+
+extern MagickExport ImageType
+  GetImageType(const Image *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  IsGrayImage(const Image *,ExceptionInfo *),
+  IsMonochromeImage(const Image *,ExceptionInfo *),
+  IsOpaqueImage(const Image *,ExceptionInfo *),
+  SetImageChannelDepth(Image *,const ChannelType,const size_t),
+  SetImageDepth(Image *,const size_t),
+  SetImageType(Image *,const ImageType);
+
+extern MagickExport RectangleInfo
+  GetImageBoundingBox(const Image *,ExceptionInfo *exception);
+
+extern MagickExport size_t
+  GetImageChannelDepth(const Image *,const ChannelType,ExceptionInfo *),
+  GetImageDepth(const Image *,ExceptionInfo *),
+  GetImageQuantumDepth(const Image *,const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/blob.h

@@ -0,0 +1,76 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore Binary Large OBjects methods.
+*/
+#ifndef _MAGICKCORE_BLOB_H
+#define _MAGICKCORE_BLOB_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/image.h"
+#include "magick/stream.h"
+
+#define MagickMaxBufferExtent  (32*8192-2)
+
+typedef enum
+{
+  ReadMode,
+  WriteMode,
+  IOMode
+} MapMode;
+
+extern MagickExport FILE
+  *GetBlobFileHandle(const Image *);
+
+extern MagickExport Image
+  *BlobToImage(const ImageInfo *,const void *,const size_t,ExceptionInfo *),
+  *PingBlob(const ImageInfo *,const void *,const size_t,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  BlobToFile(char *,const void *,const size_t,ExceptionInfo *),
+  FileToImage(Image *,const char *),
+  GetBlobError(const Image *),
+  ImageToFile(Image *,char *,ExceptionInfo *),
+  InjectImageBlob(const ImageInfo *,Image *,Image *,const char *,
+    ExceptionInfo *),
+  IsBlobExempt(const Image *),
+  IsBlobSeekable(const Image *),
+  IsBlobTemporary(const Image *);
+
+extern MagickExport MagickSizeType
+  GetBlobSize(const Image *);
+
+extern MagickExport StreamHandler
+  GetBlobStreamHandler(const Image *);
+
+extern MagickExport unsigned char
+  *FileToBlob(const char *,const size_t,size_t *,ExceptionInfo *),
+  *GetBlobStreamData(const Image *),
+  *ImageToBlob(const ImageInfo *,Image *,size_t *,ExceptionInfo *),
+  *ImagesToBlob(const ImageInfo *,Image *,size_t *,ExceptionInfo *);
+
+extern MagickExport void
+  DestroyBlob(Image *),
+  DuplicateBlob(Image *,const Image *),
+  SetBlobExempt(Image *,const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/cache-view.h

@@ -0,0 +1,108 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore cache view methods.
+*/
+#ifndef _MAGICKCORE_CACHE_VIEW_H
+#define _MAGICKCORE_CACHE_VIEW_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/pixel.h"
+
+typedef enum
+{
+  UndefinedVirtualPixelMethod,
+  BackgroundVirtualPixelMethod,
+  ConstantVirtualPixelMethod,  /* deprecated */
+  DitherVirtualPixelMethod,
+  EdgeVirtualPixelMethod,
+  MirrorVirtualPixelMethod,
+  RandomVirtualPixelMethod,
+  TileVirtualPixelMethod,
+  TransparentVirtualPixelMethod,
+  MaskVirtualPixelMethod,
+  BlackVirtualPixelMethod,
+  GrayVirtualPixelMethod,
+  WhiteVirtualPixelMethod,
+  HorizontalTileVirtualPixelMethod,
+  VerticalTileVirtualPixelMethod,
+  HorizontalTileEdgeVirtualPixelMethod,
+  VerticalTileEdgeVirtualPixelMethod,
+  CheckerTileVirtualPixelMethod
+} VirtualPixelMethod;
+
+typedef struct _CacheView
+  CacheView;
+
+extern MagickExport CacheView
+  *AcquireAuthenticCacheView(const Image *,ExceptionInfo *),
+  *AcquireCacheView(const Image *),
+  *AcquireVirtualCacheView(const Image *,ExceptionInfo *),
+  *CloneCacheView(const CacheView *),
+  *DestroyCacheView(CacheView *);
+
+extern MagickExport ClassType
+  GetCacheViewStorageClass(const CacheView *);
+
+extern MagickExport ColorspaceType
+  GetCacheViewColorspace(const CacheView *);
+
+extern MagickExport const IndexPacket
+  *GetCacheViewVirtualIndexQueue(const CacheView *);
+
+extern MagickExport const PixelPacket
+  *GetCacheViewVirtualPixels(const CacheView *,const ssize_t,const ssize_t,
+    const size_t,const size_t,ExceptionInfo *) magick_hot_spot,
+  *GetCacheViewVirtualPixelQueue(const CacheView *) magick_hot_spot;
+
+extern MagickExport ExceptionInfo
+  *GetCacheViewException(const CacheView *);
+
+extern MagickExport IndexPacket
+  *GetCacheViewAuthenticIndexQueue(CacheView *);
+
+extern MagickExport MagickBooleanType
+  GetOneCacheViewVirtualPixel(const CacheView *,const ssize_t,const ssize_t,
+    PixelPacket *,ExceptionInfo *),
+  GetOneCacheViewVirtualMethodPixel(const CacheView *,
+    const VirtualPixelMethod,const ssize_t,const ssize_t,PixelPacket *,
+    ExceptionInfo *),
+  GetOneCacheViewAuthenticPixel(const CacheView *,const ssize_t,const ssize_t,
+    PixelPacket *,ExceptionInfo *),
+  SetCacheViewStorageClass(CacheView *,const ClassType),
+  SetCacheViewVirtualPixelMethod(CacheView *,const VirtualPixelMethod),
+  SyncCacheViewAuthenticPixels(CacheView *,ExceptionInfo *) magick_hot_spot;
+
+extern MagickExport MagickSizeType
+  GetCacheViewExtent(const CacheView *);
+
+extern MagickExport size_t
+  GetCacheViewChannels(const CacheView *);
+
+extern MagickExport PixelPacket
+  *GetCacheViewAuthenticPixelQueue(CacheView *) magick_hot_spot,
+  *GetCacheViewAuthenticPixels(CacheView *,const ssize_t,const ssize_t,
+    const size_t,const size_t,ExceptionInfo *) magick_hot_spot,
+  *QueueCacheViewAuthenticPixels(CacheView *,const ssize_t,const ssize_t,
+    const size_t,const size_t,ExceptionInfo *) magick_hot_spot;
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/cache.h

@@ -0,0 +1,90 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore cache methods.
+*/
+#ifndef _MAGICKCORE_CACHE_H
+#define _MAGICKCORE_CACHE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/blob.h"
+
+typedef enum
+{
+  UndefinedCache,
+  MemoryCache,
+  MapCache,
+  DiskCache,
+  PingCache,
+  DistributedCache
+} CacheType;
+
+extern MagickExport CacheType
+  GetImagePixelCacheType(const Image *);
+
+extern MagickExport const IndexPacket
+  *GetVirtualIndexQueue(const Image *);
+
+extern MagickExport const PixelPacket
+  *GetVirtualPixels(const Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,ExceptionInfo *),
+  *GetVirtualPixelQueue(const Image *);
+
+extern MagickExport const void
+  *AcquirePixelCachePixels(const Image *,MagickSizeType *,ExceptionInfo *);
+
+extern MagickExport IndexPacket
+  *GetAuthenticIndexQueue(const Image *);
+
+extern MagickExport MagickBooleanType
+  CacheComponentGenesis(void),
+  GetOneVirtualMagickPixel(const Image *,const ssize_t,const ssize_t,
+    MagickPixelPacket *,ExceptionInfo *),
+  GetOneVirtualPixel(const Image *,const ssize_t,const ssize_t,PixelPacket *,
+    ExceptionInfo *),
+  GetOneVirtualMethodPixel(const Image *,const VirtualPixelMethod,const ssize_t,
+    const ssize_t,PixelPacket *,ExceptionInfo *),
+  GetOneAuthenticPixel(Image *,const ssize_t,const ssize_t,PixelPacket *,
+    ExceptionInfo *),
+  PersistPixelCache(Image *,const char *,const MagickBooleanType,
+    MagickOffsetType *,ExceptionInfo *),
+  SyncAuthenticPixels(Image *,ExceptionInfo *);
+
+extern MagickExport MagickSizeType
+  GetImageExtent(const Image *);
+
+extern MagickExport PixelPacket
+  *GetAuthenticPixels(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,ExceptionInfo *),
+  *GetAuthenticPixelQueue(const Image *),
+  *QueueAuthenticPixels(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,ExceptionInfo *);
+
+extern MagickExport VirtualPixelMethod
+  GetPixelCacheVirtualMethod(const Image *),
+  SetPixelCacheVirtualMethod(const Image *,const VirtualPixelMethod);
+
+extern MagickExport void
+  CacheComponentTerminus(void),
+  *GetPixelCachePixels(Image *,MagickSizeType *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/channel.h

@@ -0,0 +1,41 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image channel methods.
+*/
+#ifndef _MAGICKCORE_CHANNEL_H
+#define _MAGICKCORE_CHANNEL_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/image.h"
+
+extern MagickExport Image
+  *CombineImages(const Image *,const ChannelType,ExceptionInfo *),
+  *SeparateImage(const Image *,const ChannelType,ExceptionInfo *),
+  *SeparateImages(const Image *,const ChannelType,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  GetImageAlphaChannel(const Image *),
+  SeparateImageChannel(Image *,const ChannelType),
+  SetImageAlphaChannel(Image *,const AlphaChannelType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/cipher.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore cipher methods.
+*/
+#ifndef _MAGICKCORE_CIPHER_H
+#define _MAGICKCORE_CIPHER_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  DecipherImage(Image *,const char *,ExceptionInfo *),
+  EncipherImage(Image *,const char *,ExceptionInfo *),
+  PasskeyDecipherImage(Image *,const StringInfo *,ExceptionInfo *),
+  PasskeyEncipherImage(Image *,const StringInfo *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/client.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore client methods.
+*/
+#ifndef _MAGICKCORE_CLIENT_H
+#define _MAGICKCORE_CLIENT_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport const char
+  *GetClientPath(void),
+  *GetClientName(void),
+  *SetClientName(const char *),
+  *SetClientPath(const char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/coder.h

@@ -0,0 +1,62 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image coder methods.
+*/
+#ifndef _MAGICKCORE_CODER_H
+#define _MAGICKCORE_CODER_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _CoderInfo
+{
+  char
+    *path,
+    *magick,
+    *name;
+                                                                                
+  MagickBooleanType
+    exempt,
+    stealth;
+                                                                                
+  struct _CoderInfo
+    *previous,
+    *next;  /* deprecated, use GetCoderInfoList() */
+
+  size_t
+    signature;
+} CoderInfo;
+
+extern MagickExport char
+  **GetCoderList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const CoderInfo
+  *GetCoderInfo(const char *,ExceptionInfo *),
+  **GetCoderInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  CoderComponentGenesis(void),
+  ListCoderInfo(FILE *,ExceptionInfo *);
+
+MagickExport void
+  CoderComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/color.h

@@ -0,0 +1,109 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image color methods.
+*/
+#ifndef _MAGICKCORE_COLOR_H
+#define _MAGICKCORE_COLOR_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/pixel.h"
+#include "magick/exception.h"
+
+typedef enum
+{
+  UndefinedCompliance,
+  NoCompliance = 0x0000,
+  SVGCompliance = 0x0001,
+  X11Compliance = 0x0002,
+  XPMCompliance = 0x0004,
+  AllCompliance = 0x7fffffff
+} ComplianceType;
+
+typedef struct _ColorInfo
+{
+  char
+    *path,
+    *name;
+
+  ComplianceType
+    compliance;
+
+  MagickPixelPacket
+    color;
+
+  MagickBooleanType
+    exempt,
+    stealth;
+
+  struct _ColorInfo
+    *previous,
+    *next;  /* deprecated, use GetColorInfoList() */
+
+  size_t
+    signature;
+} ColorInfo;
+
+typedef struct _ErrorInfo
+{
+  double
+    mean_error_per_pixel,
+    normalized_mean_error,
+    normalized_maximum_error;
+} ErrorInfo;
+
+extern MagickExport char
+  **GetColorList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const ColorInfo
+  *GetColorInfo(const char *,ExceptionInfo *),
+  **GetColorInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  ColorComponentGenesis(void),
+  IsColorSimilar(const Image *,const PixelPacket *,const PixelPacket *),
+  IsGrayImage(const Image *,ExceptionInfo *),
+  IsImageSimilar(const Image *,const Image *,ssize_t *x,ssize_t *y,
+    ExceptionInfo *),
+  IsMagickColorSimilar(const MagickPixelPacket *,const MagickPixelPacket *),
+  IsMonochromeImage(const Image *,ExceptionInfo *),
+  IsOpacitySimilar(const Image *,const PixelPacket *,const PixelPacket *),
+  IsOpaqueImage(const Image *,ExceptionInfo *),
+  ListColorInfo(FILE *,ExceptionInfo *),
+  QueryColorCompliance(const char *,const ComplianceType,PixelPacket *,
+    ExceptionInfo *),
+  QueryColorDatabase(const char *,PixelPacket *,ExceptionInfo *),
+  QueryColorname(const Image *,const PixelPacket *,const ComplianceType,char *,
+    ExceptionInfo *),
+  QueryMagickColorCompliance(const char *,const ComplianceType,
+    MagickPixelPacket *,ExceptionInfo *),
+  QueryMagickColor(const char *,MagickPixelPacket *,ExceptionInfo *),
+  QueryMagickColorname(const Image *,const MagickPixelPacket *,
+    const ComplianceType,char *,ExceptionInfo *);
+
+extern MagickExport void
+  ColorComponentTerminus(void),
+  ConcatenateColorComponent(const MagickPixelPacket *,const ChannelType,
+    const ComplianceType,char *),
+  GetColorTuple(const MagickPixelPacket *,const MagickBooleanType,char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/colormap.h

@@ -0,0 +1,34 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image colormap methods.
+*/
+#ifndef _MAGICKCORE_COLORMAP_H
+#define _MAGICKCORE_COLORMAP_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  AcquireImageColormap(Image *,const size_t),
+  CycleColormapImage(Image *,const ssize_t),
+  SortColormapByIntensity(Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/colorspace.h

@@ -0,0 +1,66 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image colorspace methods.
+*/
+#ifndef _MAGICKCORE_COLORSPACE_H
+#define _MAGICKCORE_COLORSPACE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedColorspace,
+  RGBColorspace,
+  GRAYColorspace,
+  TransparentColorspace,
+  OHTAColorspace,
+  LabColorspace,
+  XYZColorspace,
+  YCbCrColorspace,
+  YCCColorspace,
+  YIQColorspace,
+  YPbPrColorspace,
+  YUVColorspace,
+  CMYKColorspace,
+  sRGBColorspace,
+  HSBColorspace,
+  HSLColorspace,
+  HWBColorspace,
+  Rec601LumaColorspace,
+  Rec601YCbCrColorspace,
+  Rec709LumaColorspace,
+  Rec709YCbCrColorspace,
+  LogColorspace,
+  CMYColorspace,
+  LuvColorspace,
+  HCLColorspace,
+  LCHColorspace,
+  LMSColorspace
+} ColorspaceType;
+
+extern MagickExport MagickBooleanType
+  RGBTransformImage(Image *,const ColorspaceType),
+  SetImageColorspace(Image *,const ColorspaceType),
+  TransformImageColorspace(Image *,const ColorspaceType),
+  TransformRGBImage(Image *,const ColorspaceType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/compare.h

@@ -0,0 +1,66 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image compare methods.
+*/
+#ifndef _MAGICKCORE_COMPARE_H
+#define _MAGICKCORE_COMPARE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/image.h"
+
+typedef enum
+{
+  UndefinedMetric,
+  AbsoluteErrorMetric,
+  MeanAbsoluteErrorMetric,
+  MeanErrorPerPixelMetric,
+  MeanSquaredErrorMetric,
+  PeakAbsoluteErrorMetric,
+  PeakSignalToNoiseRatioMetric,
+  RootMeanSquaredErrorMetric,
+  NormalizedCrossCorrelationErrorMetric,
+  FuzzErrorMetric
+} MetricType;
+
+extern MagickExport double
+  *GetImageChannelDistortions(Image *,const Image *,const MetricType,
+    ExceptionInfo *);
+
+extern MagickExport Image
+  *CompareImageChannels(Image *,const Image *,const ChannelType,
+    const MetricType,double *,ExceptionInfo *),
+  *CompareImages(Image *,const Image *,const MetricType,double *,
+    ExceptionInfo *),
+  *SimilarityImage(Image *,const Image *,RectangleInfo *,double *,
+    ExceptionInfo *),
+  *SimilarityMetricImage(Image *,const Image *,const MetricType,
+    RectangleInfo *,double *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  GetImageChannelDistortion(Image *,const Image *,const ChannelType,
+    const MetricType,double *,ExceptionInfo *),
+  GetImageDistortion(Image *,const Image *,const MetricType,double *,
+    ExceptionInfo *),
+  IsImagesEqual(Image *,const Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/composite.h

@@ -0,0 +1,120 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image composite methods.
+*/
+#ifndef _MAGICKCORE_COMPOSITE_H
+#define _MAGICKCORE_COMPOSITE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedCompositeOp,
+  NoCompositeOp,
+  ModulusAddCompositeOp,
+  AtopCompositeOp,
+  BlendCompositeOp,
+  BumpmapCompositeOp,
+  ChangeMaskCompositeOp,
+  ClearCompositeOp,
+  ColorBurnCompositeOp,
+  ColorDodgeCompositeOp,
+  ColorizeCompositeOp,
+  CopyBlackCompositeOp,
+  CopyBlueCompositeOp,
+  CopyCompositeOp,
+  CopyCyanCompositeOp,
+  CopyGreenCompositeOp,
+  CopyMagentaCompositeOp,
+  CopyOpacityCompositeOp,
+  CopyRedCompositeOp,
+  CopyYellowCompositeOp,
+  DarkenCompositeOp,
+  DstAtopCompositeOp,
+  DstCompositeOp,
+  DstInCompositeOp,
+  DstOutCompositeOp,
+  DstOverCompositeOp,
+  DifferenceCompositeOp,
+  DisplaceCompositeOp,
+  DissolveCompositeOp,
+  ExclusionCompositeOp,
+  HardLightCompositeOp,
+  HueCompositeOp,
+  InCompositeOp,
+  LightenCompositeOp,
+  LinearLightCompositeOp,
+  LuminizeCompositeOp,
+  MinusDstCompositeOp,
+  ModulateCompositeOp,
+  MultiplyCompositeOp,
+  OutCompositeOp,
+  OverCompositeOp,
+  OverlayCompositeOp,
+  PlusCompositeOp,
+  ReplaceCompositeOp,
+  SaturateCompositeOp,
+  ScreenCompositeOp,
+  SoftLightCompositeOp,
+  SrcAtopCompositeOp,
+  SrcCompositeOp,
+  SrcInCompositeOp,
+  SrcOutCompositeOp,
+  SrcOverCompositeOp,
+  ModulusSubtractCompositeOp,
+  ThresholdCompositeOp,
+  XorCompositeOp,
+  /* These are new operators, added after the above was last sorted.
+   * The list should be re-sorted only when a new library version is
+   * created.
+   */
+  DivideDstCompositeOp,
+  DistortCompositeOp,
+  BlurCompositeOp,
+  PegtopLightCompositeOp,
+  VividLightCompositeOp,
+  PinLightCompositeOp,
+  LinearDodgeCompositeOp,
+  LinearBurnCompositeOp,
+  MathematicsCompositeOp,
+  DivideSrcCompositeOp,
+  MinusSrcCompositeOp,
+  DarkenIntensityCompositeOp,
+  LightenIntensityCompositeOp
+} CompositeOperator;
+
+/* Depreciated (renamed) Method Names for backward compatibility
+ * However the CompositeOp value has not changed, just renamed.
+ */
+#define AddCompositeOp       ModulusAddCompositeOp
+#define SubtractCompositeOp  ModulusSubtractCompositeOp
+#define MinusCompositeOp     MinusDstCompositeOp
+#define DivideCompositeOp    DivideDstCompositeOp
+
+extern MagickExport MagickBooleanType
+  CompositeImage(Image *,const CompositeOperator,const Image *,const ssize_t,
+    const ssize_t),
+  CompositeImageChannel(Image *,const ChannelType,const CompositeOperator,
+    const Image *,const ssize_t,const ssize_t),
+  TextureImage(Image *,const Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/compress.h

@@ -0,0 +1,70 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image compression/decompression methods.
+*/
+#ifndef _MAGICKCORE_COMPRESS_H
+#define _MAGICKCORE_COMPRESS_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedCompression,
+  NoCompression,
+  BZipCompression,
+  DXT1Compression,
+  DXT3Compression,
+  DXT5Compression,
+  FaxCompression,
+  Group4Compression,
+  JPEGCompression,
+  JPEG2000Compression,      /* ISO/IEC std 15444-1 */
+  LosslessJPEGCompression,
+  LZWCompression,
+  RLECompression,
+  ZipCompression,
+  ZipSCompression,
+  PizCompression,
+  Pxr24Compression,
+  B44Compression,
+  B44ACompression,
+  LZMACompression,            /* Lempel-Ziv-Markov chain algorithm */
+  JBIG1Compression,           /* ISO/IEC std 11544 / ITU-T rec T.82 */
+  JBIG2Compression            /* ISO/IEC std 14492 / ITU-T rec T.88 */
+} CompressionType;
+
+typedef struct _Ascii85Info
+  Ascii85Info;
+
+extern MagickExport MagickBooleanType
+  HuffmanDecodeImage(Image *),
+  HuffmanEncodeImage(const ImageInfo *,Image *,Image *),
+  LZWEncodeImage(Image *,const size_t,unsigned char *),
+  PackbitsEncodeImage(Image *,const size_t,unsigned char *),
+  ZLIBEncodeImage(Image *,const size_t,unsigned char *);
+
+extern MagickExport void
+  Ascii85Encode(Image *,const unsigned char),
+  Ascii85Flush(Image *),
+  Ascii85Initialize(Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/configure.h

@@ -0,0 +1,73 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore configure methods.
+*/
+#ifndef _MAGICKCORE_CONFIGURE_H
+#define _MAGICKCORE_CONFIGURE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/hashmap.h"
+
+typedef struct _ConfigureInfo
+{
+  char
+    *path,
+    *name,
+    *value;
+                                                                                
+  MagickBooleanType
+    exempt,
+    stealth;
+                                                                                
+  struct _ConfigureInfo
+    *previous,
+    *next;  /* deprecated, use GetConfigureInfoList() */
+
+  size_t
+    signature;
+} ConfigureInfo;
+
+extern MagickExport char
+  **GetConfigureList(const char *,size_t *,ExceptionInfo *),
+  *GetConfigureOption(const char *);
+
+extern MagickExport const char
+  *GetConfigureValue(const ConfigureInfo *);
+
+extern MagickExport const ConfigureInfo
+  *GetConfigureInfo(const char *,ExceptionInfo *),
+  **GetConfigureInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport LinkedListInfo
+  *DestroyConfigureOptions(LinkedListInfo *),
+  *GetConfigurePaths(const char *,ExceptionInfo *),
+  *GetConfigureOptions(const char *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  ConfigureComponentGenesis(void),
+  ListConfigureInfo(FILE *,ExceptionInfo *);
+
+extern MagickExport void
+  ConfigureComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/constitute.h

@@ -0,0 +1,58 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image constitute methods.
+*/
+#ifndef _MAGICKCORE_CONSTITUTE_H
+#define _MAGICKCORE_CONSTITUTE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedPixel,
+  CharPixel,
+  DoublePixel,
+  FloatPixel,
+  IntegerPixel,
+  LongPixel,
+  QuantumPixel,
+  ShortPixel
+} StorageType;
+
+extern MagickExport Image
+  *ConstituteImage(const size_t,const size_t,const char *,const StorageType,
+    const void *,ExceptionInfo *),
+  *PingImage(const ImageInfo *,ExceptionInfo *),
+  *PingImages(const ImageInfo *,ExceptionInfo *),
+  *ReadImage(const ImageInfo *,ExceptionInfo *),
+  *ReadImages(const ImageInfo *,ExceptionInfo *),
+  *ReadInlineImage(const ImageInfo *,const char *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  ConstituteComponentGenesis(void),
+  WriteImage(const ImageInfo *,Image *),
+  WriteImages(const ImageInfo *,Image *,const char *,ExceptionInfo *);
+
+extern MagickExport void
+  ConstituteComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/decorate.h

@@ -0,0 +1,49 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image decorate methods.
+*/
+#ifndef _MAGICKCORE_DECORATE_H
+#define _MAGICKCORE_DECORATE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _FrameInfo
+{
+  size_t
+    width,
+    height;
+
+  ssize_t
+    x,
+    y,
+    inner_bevel,
+    outer_bevel;
+} FrameInfo;
+
+extern MagickExport Image
+  *BorderImage(const Image *,const RectangleInfo *,ExceptionInfo *),
+  *FrameImage(const Image *,const FrameInfo *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  RaiseImage(Image *,const RectangleInfo *,const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/delegate.h

@@ -0,0 +1,77 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore delegates methods.
+*/
+#ifndef _MAGICKCORE_DELEGATE_H
+#define _MAGICKCORE_DELEGATE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _DelegateInfo
+{
+  char
+    *path,
+    *decode,
+    *encode,
+    *commands;
+                                                                                
+  ssize_t
+    mode;
+                                                                                
+  MagickBooleanType
+    thread_support,
+    spawn,
+    stealth;
+                                                                                
+  struct _DelegateInfo
+    *previous,
+    *next;  /* deprecated, use GetDelegateInfoList() */
+
+  size_t
+    signature;
+} DelegateInfo;
+
+extern MagickExport char
+  *GetDelegateCommand(const ImageInfo *,Image *,const char *,const char *,
+    ExceptionInfo *),
+  **GetDelegateList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const char
+  *GetDelegateCommands(const DelegateInfo *);
+
+extern MagickExport const DelegateInfo
+  *GetDelegateInfo(const char *,const char *,ExceptionInfo *exception),
+  **GetDelegateInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport ssize_t
+  GetDelegateMode(const DelegateInfo *);
+
+extern MagickExport MagickBooleanType
+  DelegateComponentGenesis(void),
+  GetDelegateThreadSupport(const DelegateInfo *),
+  InvokeDelegate(ImageInfo *,Image *,const char *,const char *,ExceptionInfo *),
+  ListDelegateInfo(FILE *,ExceptionInfo *);
+
+extern MagickExport void
+  DelegateComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/deprecate.h

@@ -0,0 +1,367 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore deprecated methods.
+*/
+#ifndef _MAGICKCORE_DEPRECATE_H
+#define _MAGICKCORE_DEPRECATE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
+
+#include <stdarg.h>
+#include "magick/blob.h"
+#include "magick/cache-view.h"
+#include "magick/draw.h"
+#include "magick/constitute.h"
+#include "magick/magick-config.h"
+#include "magick/pixel.h"
+#include "magick/quantize.h"
+#include "magick/quantum.h"
+#include "magick/registry.h"
+#include "magick/semaphore.h"
+
+#if !defined(magick_attribute)
+#  if !defined(__GNUC__)
+#    define magick_attribute(x) /*nothing*/
+#  else
+#    define magick_attribute __attribute__
+#  endif
+#endif
+
+#define Downscale(quantum)  ScaleQuantumToChar(quantum)
+#define LABColorspace LabColorspace
+#define CompressPixelGamma(pixel)  DecodePixelGamma(pixel)
+#define DecodesRGBGamma(pixel)  DecodePixelGamma(pixel)
+#define EncodesRGBGamma(pixel)  EncodePixelGamma(pixel)
+#define ExpandPixelGamma(pixel)  EncodePixelGamma(pixel)
+#define Intensity(color)  PixelIntensityToQuantum(color)
+#define LiberateUniqueFileResource(resource) \
+  RelinquishUniqueFileResource(resource)
+#define LiberateMagickResource(resource)  RelinquishMagickResource(resource)
+#define LiberateSemaphore(semaphore)  RelinquishSemaphore(semaphore)
+#define QuantumDepth  MAGICKCORE_QUANTUM_DEPTH
+#define MaxRGB  QuantumRange  /* deprecated */
+#define RunlengthEncodedCompression  RLECompression
+#define Upscale(value)  ScaleCharToQuantum(value)
+#define XDownscale(value)  ScaleShortToQuantum(value)
+#define XUpscale(quantum)  ScaleQuantumToShort(quantum)
+
+typedef enum
+{
+  UndefinedMagickLayerMethod
+} MagickLayerMethod;
+
+typedef MagickOffsetType ExtendedSignedIntegralType;
+typedef MagickSizeType ExtendedUnsignedIntegralType;
+typedef MagickRealType ExtendedRationalType;
+typedef struct _ViewInfo ViewInfo;
+
+typedef MagickBooleanType
+  (*MonitorHandler)(const char *,const MagickOffsetType,const MagickSizeType,
+    ExceptionInfo *);
+
+typedef struct _ImageAttribute
+{
+  char
+    *key,
+    *value;
+                                                                                
+  MagickBooleanType
+    compression;
+                                                                                
+  struct _ImageAttribute
+    *previous,
+    *next;  /* deprecated */
+} ImageAttribute;
+
+extern MagickExport CacheView
+  *CloseCacheView(CacheView *) magick_attribute((deprecated)),
+  *OpenCacheView(const Image *) magick_attribute((deprecated));
+
+extern MagickExport char
+  *AllocateString(const char *) magick_attribute((deprecated)),
+  *InterpretImageAttributes(const ImageInfo *,Image *,const char *)
+    magick_attribute((deprecated)),
+  *PostscriptGeometry(const char *) magick_attribute((deprecated)),
+  *TranslateText(const ImageInfo *,Image *,const char *)
+     magick_attribute((deprecated));
+
+extern MagickExport const ImageAttribute
+  *GetImageAttribute(const Image *,const char *),
+  *GetImageClippingPathAttribute(Image *) magick_attribute((deprecated)),
+  *GetNextImageAttribute(const Image *) magick_attribute((deprecated));
+
+extern MagickExport const IndexPacket
+  *AcquireCacheViewIndexes(const CacheView *) magick_attribute((deprecated)),
+  *AcquireIndexes(const Image *) magick_attribute((deprecated));
+
+extern MagickExport const PixelPacket
+  *AcquirePixels(const Image *) magick_attribute((deprecated)),
+  *AcquireCacheViewPixels(const CacheView *,const ssize_t,const ssize_t,
+    const size_t,const size_t,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  *AcquireImagePixels(const Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,ExceptionInfo *) magick_attribute((deprecated));
+
+extern MagickExport FILE
+  *OpenMagickStream(const char *,const char *);
+
+extern MagickExport Image
+  *AllocateImage(const ImageInfo *) magick_attribute((deprecated)),
+  *AverageImages(const Image *,ExceptionInfo *),
+  *ExtractSubimageFromImage(Image *,const Image *,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  *GetImageFromMagickRegistry(const char *,ssize_t *id,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  *GetImageList(const Image *,const ssize_t,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  *GetNextImage(const Image *) magick_attribute((deprecated)),
+  *GetPreviousImage(const Image *) magick_attribute((deprecated)),
+  *FlattenImages(Image *,ExceptionInfo *) magick_attribute((deprecated)),
+  *MaximumImages(const Image *,ExceptionInfo *),
+  *MedianFilterImage(const Image *,const double,ExceptionInfo *),
+  *ModeImage(const Image *,const double,ExceptionInfo *),
+  *MinimumImages(const Image *,ExceptionInfo *),
+  *MosaicImages(Image *,ExceptionInfo *) magick_attribute((deprecated)),
+  *PopImageList(Image **) magick_attribute((deprecated)),
+  *RecolorImage(const Image *,const size_t,const double *,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  *ReduceNoiseImage(const Image *,const double,ExceptionInfo *),
+  *ShiftImageList(Image **) magick_attribute((deprecated)),
+  *SpliceImageList(Image *,const ssize_t,const size_t,const Image *,
+    ExceptionInfo *) magick_attribute((deprecated)),
+  *ZoomImage(const Image *,const size_t,const size_t,ExceptionInfo *)
+    magick_attribute((deprecated));
+
+extern MagickExport IndexPacket
+  *GetCacheViewIndexes(CacheView *) magick_attribute((deprecated)),
+  *GetIndexes(const Image *) magick_attribute((deprecated)),
+  ValidateColormapIndex(Image *,const size_t) magick_attribute((deprecated));
+
+extern MagickExport int
+  GetImageGeometry(Image *,const char *,const unsigned int,RectangleInfo *)
+    magick_attribute((deprecated)),
+  ParseImageGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *)
+    magick_attribute((deprecated));
+
+extern MagickExport MagickBooleanType
+  AcquireOneCacheViewPixel(const CacheView *,const ssize_t,const ssize_t,
+    PixelPacket *,ExceptionInfo *) magick_attribute((deprecated)),
+  AcquireOneCacheViewVirtualPixel(const CacheView *,const VirtualPixelMethod,
+    const ssize_t,const ssize_t,PixelPacket *,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  AffinityImage(const QuantizeInfo *,Image *,const Image *)
+    magick_attribute((deprecated)),
+  AffinityImages(const QuantizeInfo *,Image *,const Image *)
+    magick_attribute((deprecated)),
+  AllocateImageColormap(Image *,const size_t)
+    magick_attribute((deprecated)),
+  ClipPathImage(Image *,const char *,const MagickBooleanType)
+    magick_attribute((deprecated)),
+  CloneImageAttributes(Image *,const Image *) magick_attribute((deprecated)),
+  ColorFloodfillImage(Image *,const DrawInfo *,const PixelPacket,const ssize_t,
+    const ssize_t,const PaintMethod) magick_attribute((deprecated)),
+  DeleteImageAttribute(Image *,const char *) magick_attribute((deprecated)),
+  DeleteMagickRegistry(const ssize_t) magick_attribute((deprecated)),
+  DescribeImage(Image *,FILE *,const MagickBooleanType)
+    magick_attribute((deprecated)),
+  FormatImageAttribute(Image *,const char *,const char *,...)
+    magick_attribute((__format__ (__printf__,3,4)))
+    magick_attribute((deprecated)),
+  FormatImageAttributeList(Image *,const char *,const char *,va_list)
+    magick_attribute((__format__ (__printf__,3,0)))
+    magick_attribute((deprecated)),
+  FormatImagePropertyList(Image *,const char *,const char *,va_list)
+    magick_attribute((__format__ (__printf__,3,0))),
+  FuzzyColorCompare(const Image *,const PixelPacket *,const PixelPacket *)
+    magick_attribute((deprecated)),
+  FuzzyOpacityCompare(const Image *,const PixelPacket *,const PixelPacket *)
+    magick_attribute((deprecated)),
+  LevelImageColors(Image *,const ChannelType,const MagickPixelPacket *,
+    const MagickPixelPacket *, const MagickBooleanType)
+    magick_attribute((deprecated)),
+  MagickMonitor(const char *,const MagickOffsetType,const MagickSizeType,
+    void *) magick_attribute((deprecated)),
+  MapImage(Image *,const Image *,const MagickBooleanType)
+    magick_attribute((deprecated)),
+  MapImages(Image *,const Image *,const MagickBooleanType)
+    magick_attribute((deprecated)),
+  MatteFloodfillImage(Image *,const PixelPacket,const Quantum,const ssize_t,
+    const ssize_t,const PaintMethod) magick_attribute((deprecated)),
+  OpaqueImage(Image *,const PixelPacket,const PixelPacket)
+    magick_attribute((deprecated)),
+  PaintFloodfillImage(Image *,const ChannelType,const MagickPixelPacket *,
+    const ssize_t,const ssize_t,const DrawInfo *,const PaintMethod)
+    magick_attribute((deprecated)),
+  PaintOpaqueImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *)
+    magick_attribute((deprecated)),
+  PaintOpaqueImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
+    const MagickPixelPacket *) magick_attribute((deprecated)),
+  PaintTransparentImage(Image *,const MagickPixelPacket *,const Quantum)
+    magick_attribute((deprecated)),
+  SetExceptionInfo(ExceptionInfo *,ExceptionType)
+    magick_attribute((deprecated)),
+  SetImageAttribute(Image *,const char *,const char *)
+    magick_attribute((deprecated)),
+  SyncCacheViewPixels(CacheView *) magick_attribute((deprecated)),
+  SyncImagePixels(Image *) magick_attribute((deprecated)),
+  TransparentImage(Image *,const PixelPacket,const Quantum)
+    magick_attribute((deprecated));
+
+extern MagickExport MagickPixelPacket
+  AcquireOneMagickPixel(const Image *,const ssize_t,const ssize_t,
+    ExceptionInfo *) magick_attribute((deprecated));
+
+extern MagickExport MonitorHandler
+  GetMonitorHandler(void) magick_attribute((deprecated)),
+  SetMonitorHandler(MonitorHandler) magick_attribute((deprecated));
+
+extern MagickExport MagickOffsetType
+  SizeBlob(Image *image) magick_attribute((deprecated));
+
+extern MagickExport MagickPixelPacket
+  InterpolatePixelColor(const Image *,CacheView *,const InterpolatePixelMethod,
+    const double,const double,ExceptionInfo *) magick_attribute((deprecated));
+
+extern MagickExport MagickStatusType
+  ParseSizeGeometry(const Image *,const char *,RectangleInfo *)
+    magick_attribute((deprecated));
+
+extern MagickExport PixelPacket
+  AcquireOnePixel(const Image *,const ssize_t,const ssize_t,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  AcquireOneVirtualPixel(const Image *,const VirtualPixelMethod,const ssize_t,
+    const ssize_t,ExceptionInfo *) magick_attribute((deprecated)),
+  *GetCacheView(CacheView *,const ssize_t,const ssize_t,const size_t,
+    const size_t) magick_attribute((deprecated)),
+  *GetCacheViewPixels(CacheView *,const ssize_t,const ssize_t,const size_t,
+    const size_t) magick_attribute((deprecated)),
+  *GetImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t) magick_attribute((deprecated)),
+  GetOnePixel(Image *,const ssize_t,const ssize_t)
+    magick_attribute((deprecated)),
+  *GetPixels(const Image *) magick_attribute((deprecated)),
+  *SetCacheViewPixels(CacheView *,const ssize_t,const ssize_t,const size_t,
+    const size_t) magick_attribute((deprecated)),
+  *SetImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t) magick_attribute((deprecated));
+
+extern MagickExport MagickRealType
+  InversesRGBCompandor(const MagickRealType) magick_attribute((deprecated)),
+  sRGBCompandor(const MagickRealType) magick_attribute((deprecated));
+
+extern MagickExport size_t
+  GetImageListSize(const Image *) magick_attribute((deprecated)),
+  PopImagePixels(Image *,const QuantumType,unsigned char *)
+    magick_attribute((deprecated)),
+  PushImagePixels(Image *,const QuantumType,const unsigned char *)
+    magick_attribute((deprecated));
+
+extern MagickExport ssize_t
+  FormatMagickString(char *,const size_t,const char *,...)
+    magick_attribute((__format__ (__printf__,3,4)))
+    magick_attribute((deprecated)),
+  FormatMagickStringList(char *,const size_t,const char *,va_list)
+    magick_attribute((__format__ (__printf__,3,0))),
+  GetImageListIndex(const Image *) magick_attribute((deprecated)),
+  SetMagickRegistry(const RegistryType,const void *,const size_t,
+    ExceptionInfo *) magick_attribute((deprecated));
+
+extern MagickExport unsigned int
+  ChannelImage(Image *,const ChannelType) magick_attribute((deprecated)),
+  ChannelThresholdImage(Image *,const char *) magick_attribute((deprecated)),
+  DispatchImage(const Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,const char *,const StorageType,void *,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  FuzzyColorMatch(const PixelPacket *,const PixelPacket *,const double)
+    magick_attribute((deprecated)),
+  GetNumberScenes(const Image *) magick_attribute((deprecated)),
+  GetMagickGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *)
+    magick_attribute((deprecated)),
+  IsSubimage(const char *,const unsigned int) magick_attribute((deprecated)),
+  PushImageList(Image **,const Image *,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  QuantizationError(Image *) magick_attribute((deprecated)),
+  RandomChannelThresholdImage(Image *,const char *,const char *,
+    ExceptionInfo *) magick_attribute((deprecated)),
+  SetImageList(Image **,const Image *,const ssize_t,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  TransformColorspace(Image *,const ColorspaceType)
+    magick_attribute((deprecated)),
+  ThresholdImage(Image *,const double) magick_attribute((deprecated)),
+  ThresholdImageChannel(Image *,const char *) magick_attribute((deprecated)),
+  UnshiftImageList(Image **,const Image *,ExceptionInfo *)
+    magick_attribute((deprecated));
+
+extern MagickExport void
+  *AcquireMemory(const size_t) magick_attribute((deprecated)),
+  AllocateNextImage(const ImageInfo *,Image *) magick_attribute((deprecated)),
+  *CloneMemory(void *,const void *,const size_t) magick_attribute((deprecated)),
+  DestroyConstitute(void),
+  DestroyImageAttributes(Image *) magick_attribute((deprecated)),
+  DestroyImages(Image *) magick_attribute((deprecated)),
+  DestroyMagick(void) magick_attribute((deprecated)),
+  DestroyMagickRegistry(void) magick_attribute((deprecated)),
+  *GetConfigureBlob(const char *,char *,size_t *,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  *GetMagickRegistry(const ssize_t,RegistryType *,size_t *,ExceptionInfo *)
+    magick_attribute((deprecated)),
+  IdentityAffine(AffineMatrix *) magick_attribute((deprecated)),
+  LiberateMemory(void **) magick_attribute((deprecated)),
+  LiberateSemaphoreInfo(SemaphoreInfo **) magick_attribute((deprecated)),
+  FormatString(char *,const char *,...)
+    magick_attribute((__format__ (__printf__,2,3)))
+    magick_attribute((deprecated)),
+  FormatStringList(char *,const char *,va_list)
+    magick_attribute((__format__ (__printf__,2,0)))
+    magick_attribute((deprecated)),
+  HSLTransform(const double,const double,const double,Quantum *,Quantum *,
+    Quantum *) magick_attribute((deprecated)),
+  InitializeMagick(const char *) magick_attribute((deprecated)),
+  MagickIncarnate(const char *) magick_attribute((deprecated)),
+  ReacquireMemory(void **,const size_t) magick_attribute((deprecated)),
+  ResetImageAttributeIterator(const Image *) magick_attribute((deprecated)),
+  SetCacheThreshold(const size_t) magick_attribute((deprecated)),
+  SetImage(Image *,const Quantum) magick_attribute((deprecated)),
+  Strip(char *) magick_attribute((deprecated)),
+  TemporaryFilename(char *) magick_attribute((deprecated)),
+  TransformHSL(const Quantum,const Quantum,const Quantum,double *,double *,
+    double *) magick_attribute((deprecated));
+
+/*
+  Inline methods.
+*/
+static inline double MagickEpsilonReciprocal(const double x)
+{
+  double
+    sign;
+
+  sign=x < 0.0 ? -1.0 : 1.0;
+  if ((sign*x) >= MagickEpsilon)
+    return(1.0/x);
+  return(sign/MagickEpsilon);
+}
+
+#endif
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/display.h

@@ -0,0 +1,34 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore methods to interactively display and edit an image.
+*/
+#ifndef _MAGICKCORE_DISPLAY_H
+#define _MAGICKCORE_DISPLAY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  DisplayImages(const ImageInfo *,Image *),
+  RemoteDisplayCommand(const ImageInfo *,const char *,const char *,
+    ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/distort.h

@@ -0,0 +1,85 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image distortion methods.
+*/
+#ifndef _MAGICKCORE_DISTORT_H
+#define _MAGICKCORE_DISTORT_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/*
+  These two enum are linked, with common enumerated values.  Both
+  DistortImages() and SparseColor() often share code to determine functional
+  coefficients for common methods.
+
+  Caution should be taken to ensure that only the common methods contain the
+  same enumerated value, while all others remain unique across both
+  enumerations.
+*/
+typedef enum
+{
+  UndefinedDistortion,
+  AffineDistortion,
+  AffineProjectionDistortion,
+  ScaleRotateTranslateDistortion,
+  PerspectiveDistortion,
+  PerspectiveProjectionDistortion,
+  BilinearForwardDistortion,
+  BilinearDistortion = BilinearForwardDistortion,
+  BilinearReverseDistortion,
+  PolynomialDistortion,
+  ArcDistortion,
+  PolarDistortion,
+  DePolarDistortion,
+  Cylinder2PlaneDistortion,
+  Plane2CylinderDistortion,
+  BarrelDistortion,
+  BarrelInverseDistortion,
+  ShepardsDistortion,
+  ResizeDistortion,
+  SentinelDistortion
+} DistortImageMethod;
+
+typedef enum
+{
+  UndefinedColorInterpolate = UndefinedDistortion,
+  BarycentricColorInterpolate = AffineDistortion,
+  BilinearColorInterpolate = BilinearReverseDistortion,
+  PolynomialColorInterpolate = PolynomialDistortion,
+  ShepardsColorInterpolate = ShepardsDistortion,
+  /*
+    Methods unique to SparseColor().
+  */
+  VoronoiColorInterpolate = SentinelDistortion,
+  InverseColorInterpolate
+} SparseColorMethod;
+
+extern MagickExport Image
+  *AffineTransformImage(const Image *,const AffineMatrix *,ExceptionInfo *),
+  *DistortImage(const Image *,const DistortImageMethod,const size_t,
+    const double *,MagickBooleanType,ExceptionInfo *exception),
+  *DistortResizeImage(const Image *,const size_t,const size_t,ExceptionInfo *),
+  *RotateImage(const Image *,const double,ExceptionInfo *),
+  *SparseColorImage(const Image *,const ChannelType,const SparseColorMethod,
+    const size_t,const double *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/distribute-cache.h

@@ -0,0 +1,34 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore distributed cache methods.
+*/
+#ifndef _MAGICKCORE_DISTRIBUTE_CACHE_H
+#define _MAGICKCORE_DISTRIBUTE_CACHE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/exception.h"
+
+extern MagickExport void
+  DistributePixelCacheServer(const int,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/draw.h

@@ -0,0 +1,395 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore drawing methods.
+*/
+#ifndef _MAGICKCORE_DRAW_H
+#define _MAGICKCORE_DRAW_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/geometry.h"
+#include "magick/image.h"
+#include "magick/pixel.h"
+#include "magick/type.h"
+
+typedef enum
+{
+  UndefinedAlign,
+  LeftAlign,
+  CenterAlign,
+  RightAlign
+} AlignType;
+
+typedef enum
+{
+  UndefinedPathUnits,
+  UserSpace,
+  UserSpaceOnUse,
+  ObjectBoundingBox
+} ClipPathUnits;
+
+typedef enum
+{
+  UndefinedDecoration,
+  NoDecoration,
+  UnderlineDecoration,
+  OverlineDecoration,
+  LineThroughDecoration
+} DecorationType;
+
+typedef enum
+{
+  UndefinedDirection,
+  RightToLeftDirection,
+  LeftToRightDirection
+} DirectionType;
+
+typedef enum
+{
+  UndefinedRule,
+#undef EvenOddRule
+  EvenOddRule,
+  NonZeroRule
+} FillRule;
+
+typedef enum
+{
+  UndefinedGradient,
+  LinearGradient,
+  RadialGradient
+} GradientType;
+
+typedef enum
+{
+  UndefinedCap,
+  ButtCap,
+  RoundCap,
+  SquareCap
+} LineCap;
+
+typedef enum
+{
+  UndefinedJoin,
+  MiterJoin,
+  RoundJoin,
+  BevelJoin
+} LineJoin;
+
+typedef enum
+{
+  UndefinedMethod,
+  PointMethod,
+  ReplaceMethod,
+  FloodfillMethod,
+  FillToBorderMethod,
+  ResetMethod
+} PaintMethod;
+
+typedef enum
+{
+  UndefinedPrimitive,
+  PointPrimitive,
+  LinePrimitive,
+  RectanglePrimitive,
+  RoundRectanglePrimitive,
+  ArcPrimitive,
+  EllipsePrimitive,
+  CirclePrimitive,
+  PolylinePrimitive,
+  PolygonPrimitive,
+  BezierPrimitive,
+  ColorPrimitive,
+  MattePrimitive,
+  TextPrimitive,
+  ImagePrimitive,
+  PathPrimitive
+} PrimitiveType;
+
+typedef enum
+{
+  UndefinedReference,
+  GradientReference
+} ReferenceType;
+
+typedef enum
+{
+  UndefinedSpread,
+  PadSpread,
+  ReflectSpread,
+  RepeatSpread
+} SpreadMethod;
+
+typedef struct _PointInfo
+{ 
+  double
+    x,
+    y;
+} PointInfo;
+
+typedef struct _StopInfo
+{
+  MagickPixelPacket
+    color;
+
+  MagickRealType
+    offset;
+} StopInfo;
+
+typedef struct _GradientInfo
+{
+  GradientType
+    type;
+
+  RectangleInfo
+    bounding_box;
+
+  SegmentInfo
+    gradient_vector;
+
+  StopInfo
+    *stops;
+
+  size_t
+    number_stops;
+
+  SpreadMethod
+    spread;
+
+  MagickBooleanType
+    debug;
+
+  size_t
+    signature;
+
+  PointInfo
+    center;
+
+  MagickRealType
+    radius;
+} GradientInfo;
+
+typedef struct _ElementReference
+{
+  char
+    *id;
+
+  ReferenceType
+    type;
+
+  GradientInfo
+    gradient;
+
+  size_t
+    signature;
+
+  struct _ElementReference
+    *previous,
+    *next;
+} ElementReference;
+
+typedef struct _DrawInfo
+{
+  char
+    *primitive,
+    *geometry;
+
+  RectangleInfo
+    viewbox;
+
+  AffineMatrix
+    affine;
+
+  GravityType
+    gravity;
+
+  PixelPacket
+    fill,
+    stroke;
+
+  double
+    stroke_width;
+
+  GradientInfo
+    gradient;
+
+  Image
+    *fill_pattern,
+    *tile,
+    *stroke_pattern;
+
+  MagickBooleanType
+    stroke_antialias,
+    text_antialias;
+
+  FillRule
+    fill_rule;
+
+  LineCap
+    linecap;
+
+  LineJoin
+    linejoin;
+
+  size_t
+    miterlimit;
+
+  double
+    dash_offset;
+
+  DecorationType
+    decorate;
+
+  CompositeOperator
+    compose;
+
+  char
+    *text;
+
+  size_t
+    face;
+
+  char
+    *font,
+    *metrics,
+    *family;
+
+  StyleType
+    style;
+
+  StretchType
+    stretch;
+
+  size_t
+    weight;
+
+  char
+    *encoding;
+
+  double
+    pointsize;
+
+  char
+    *density;
+
+  AlignType
+    align;
+
+  PixelPacket
+    undercolor,
+    border_color;
+
+  char
+    *server_name;
+
+  double
+    *dash_pattern;
+
+  char
+    *clip_mask;
+
+  SegmentInfo
+    bounds;
+
+  ClipPathUnits
+    clip_units;
+
+  Quantum
+    opacity;
+
+  MagickBooleanType
+    render;
+
+  ElementReference
+    element_reference;
+
+  MagickBooleanType
+    debug;
+
+  size_t
+    signature;
+
+  double
+    kerning,
+    interword_spacing,
+    interline_spacing;
+
+  DirectionType
+    direction;
+} DrawInfo;
+
+typedef struct _PrimitiveInfo
+{
+  PointInfo
+    point;
+
+  size_t
+    coordinates;
+
+  PrimitiveType
+    primitive;
+
+  PaintMethod
+    method;
+
+  char
+    *text;
+} PrimitiveInfo;
+
+typedef struct _TypeMetric
+{
+  PointInfo
+    pixels_per_em;
+
+  double
+    ascent,
+    descent,
+    width,
+    height,
+    max_advance,
+    underline_position,
+    underline_thickness;
+
+  SegmentInfo
+    bounds;
+
+  PointInfo
+    origin;
+} TypeMetric;
+
+extern MagickExport DrawInfo
+  *AcquireDrawInfo(void),
+  *CloneDrawInfo(const ImageInfo *,const DrawInfo *),
+  *DestroyDrawInfo(DrawInfo *);
+
+extern MagickExport MagickBooleanType
+  DrawAffineImage(Image *,const Image *,const AffineMatrix *),
+  DrawClipPath(Image *,const DrawInfo *,const char *),
+  DrawGradientImage(Image *,const DrawInfo *),
+  DrawImage(Image *,const DrawInfo *),
+  DrawPatternPath(Image *,const DrawInfo *,const char *,Image **),
+  DrawPrimitive(Image *,const DrawInfo *,const PrimitiveInfo *);
+
+extern MagickExport void
+  GetAffineMatrix(AffineMatrix *),
+  GetDrawInfo(const ImageInfo *,DrawInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/effect.h

@@ -0,0 +1,111 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image effects methods.
+*/
+#ifndef _MAGICKCORE_EFFECT_H
+#define _MAGICKCORE_EFFECT_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/morphology.h"
+
+typedef enum
+{
+  UndefinedPreview,
+  RotatePreview,
+  ShearPreview,
+  RollPreview,
+  HuePreview,
+  SaturationPreview,
+  BrightnessPreview,
+  GammaPreview,
+  SpiffPreview,
+  DullPreview,
+  GrayscalePreview,
+  QuantizePreview,
+  DespecklePreview,
+  ReduceNoisePreview,
+  AddNoisePreview,
+  SharpenPreview,
+  BlurPreview,
+  ThresholdPreview,
+  EdgeDetectPreview,
+  SpreadPreview,
+  SolarizePreview,
+  ShadePreview,
+  RaisePreview,
+  SegmentPreview,
+  SwirlPreview,
+  ImplodePreview,
+  WavePreview,
+  OilPaintPreview,
+  CharcoalDrawingPreview,
+  JPEGPreview
+} PreviewType;
+
+extern MagickExport Image
+  *AdaptiveBlurImage(const Image *,const double,const double,ExceptionInfo *),
+  *AdaptiveBlurImageChannel(const Image *,const ChannelType,const double,
+    const double,ExceptionInfo *),
+  *AdaptiveSharpenImage(const Image *,const double,const double,
+     ExceptionInfo *),
+  *AdaptiveSharpenImageChannel(const Image *,const ChannelType,const double,
+    const double,ExceptionInfo *),
+  *BlurImage(const Image *,const double,const double,ExceptionInfo *),
+  *BlurImageChannel(const Image *,const ChannelType,const double,const double,
+    ExceptionInfo *),
+  *ConvolveImage(const Image *,const size_t,const double *,ExceptionInfo *),
+  *ConvolveImageChannel(const Image *,const ChannelType,const size_t,
+    const double *,ExceptionInfo *),
+  *DespeckleImage(const Image *,ExceptionInfo *),
+  *EdgeImage(const Image *,const double,ExceptionInfo *),
+  *EmbossImage(const Image *,const double,const double,ExceptionInfo *),
+  *FilterImage(const Image *,const KernelInfo *,ExceptionInfo *),
+  *FilterImageChannel(const Image *,const ChannelType,const KernelInfo *,
+     ExceptionInfo *),
+  *GaussianBlurImage(const Image *,const double,const double,ExceptionInfo *),
+  *GaussianBlurImageChannel(const Image *,const ChannelType,const double,
+    const double,ExceptionInfo *),
+  *MotionBlurImage(const Image *,const double,const double,const double,
+    ExceptionInfo *),
+  *MotionBlurImageChannel(const Image *,const ChannelType,const double,
+    const double,const double,ExceptionInfo *),
+  *PreviewImage(const Image *,const PreviewType,ExceptionInfo *),
+  *RadialBlurImage(const Image *,const double,ExceptionInfo *),
+  *RadialBlurImageChannel(const Image *,const ChannelType,const double,
+    ExceptionInfo *),
+  *SelectiveBlurImage(const Image *,const double,const double,const double,
+    ExceptionInfo *),
+  *SelectiveBlurImageChannel(const Image *,const ChannelType,const double,
+    const double,const double,ExceptionInfo *),
+  *ShadeImage(const Image *,const MagickBooleanType,const double,const double,
+    ExceptionInfo *),
+  *SharpenImage(const Image *,const double,const double,ExceptionInfo *),
+  *SharpenImageChannel(const Image *,const ChannelType,const double,
+    const double,ExceptionInfo *),
+  *SpreadImage(const Image *,const double,ExceptionInfo *),
+  *UnsharpMaskImage(const Image *,const double,const double,const double,
+    const double,ExceptionInfo *),
+  *UnsharpMaskImageChannel(const Image *,const ChannelType,const double,
+    const double,const double,const double,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/enhance.h

@@ -0,0 +1,73 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image enhance methods.
+*/
+#ifndef _MAGICKCORE_ENHANCE_H
+#define _MAGICKCORE_ENHANCE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  AutoGammaImage(Image *),
+  AutoGammaImageChannel(Image *,const ChannelType),
+  AutoLevelImage(Image *),
+  AutoLevelImageChannel(Image *,const ChannelType),
+  BrightnessContrastImage(Image *,const double,const double),
+  BrightnessContrastImageChannel(Image *,const ChannelType,const double,
+    const double),
+  ClutImage(Image *,const Image *),
+  ClutImageChannel(Image *,const ChannelType,const Image *),
+  ColorDecisionListImage(Image *,const char *),
+  ContrastImage(Image *,const MagickBooleanType),
+  ContrastStretchImage(Image *,const char *),
+  ContrastStretchImageChannel(Image *,const ChannelType,const double,
+    const double),
+  EqualizeImage(Image *image),
+  EqualizeImageChannel(Image *image,const ChannelType),
+  GammaImage(Image *,const char *),
+  GammaImageChannel(Image *,const ChannelType,const double),
+  HaldClutImage(Image *,const Image *),
+  HaldClutImageChannel(Image *,const ChannelType,const Image *),
+  LevelImage(Image *,const char *),
+  LevelImageChannel(Image *,const ChannelType,const double,const double,
+    const double),
+  LevelizeImage(Image *,const double,const double,const double),
+  LevelizeImageChannel(Image *,const ChannelType,const double,const double,
+    const double),
+  LevelColorsImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *,
+    const MagickBooleanType),
+  LevelColorsImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
+    const MagickPixelPacket *,const MagickBooleanType),
+  LinearStretchImage(Image *,const double,const double),
+  ModulateImage(Image *,const char *),
+  NegateImage(Image *,const MagickBooleanType),
+  NegateImageChannel(Image *,const ChannelType,const MagickBooleanType),
+  NormalizeImage(Image *),
+  NormalizeImageChannel(Image *,const ChannelType),
+  SigmoidalContrastImage(Image *,const MagickBooleanType,const char *),
+  SigmoidalContrastImageChannel(Image *,const ChannelType,
+    const MagickBooleanType,const double,const double);
+
+extern MagickExport Image
+  *EnhanceImage(const Image *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/exception.h

@@ -0,0 +1,178 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore exception methods.
+*/
+#ifndef _MAGICKCORE_EXCEPTION_H
+#define _MAGICKCORE_EXCEPTION_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include "magick/semaphore.h"
+
+typedef enum
+{
+  UndefinedException,
+  WarningException = 300,
+  ResourceLimitWarning = 300,
+  TypeWarning = 305,
+  OptionWarning = 310,
+  DelegateWarning = 315,
+  MissingDelegateWarning = 320,
+  CorruptImageWarning = 325,
+  FileOpenWarning = 330,
+  BlobWarning = 335,
+  StreamWarning = 340,
+  CacheWarning = 345,
+  CoderWarning = 350,
+  FilterWarning = 352,
+  ModuleWarning = 355,
+  DrawWarning = 360,
+  ImageWarning = 365,
+  WandWarning = 370,
+  RandomWarning = 375,
+  XServerWarning = 380,
+  MonitorWarning = 385,
+  RegistryWarning = 390,
+  ConfigureWarning = 395,
+  PolicyWarning = 399,
+  ErrorException = 400,
+  ResourceLimitError = 400,
+  TypeError = 405,
+  OptionError = 410,
+  DelegateError = 415,
+  MissingDelegateError = 420,
+  CorruptImageError = 425,
+  FileOpenError = 430,
+  BlobError = 435,
+  StreamError = 440,
+  CacheError = 445,
+  CoderError = 450,
+  FilterError = 452,
+  ModuleError = 455,
+  DrawError = 460,
+  ImageError = 465,
+  WandError = 470,
+  RandomError = 475,
+  XServerError = 480,
+  MonitorError = 485,
+  RegistryError = 490,
+  ConfigureError = 495,
+  PolicyError = 499,
+  FatalErrorException = 700,
+  ResourceLimitFatalError = 700,
+  TypeFatalError = 705,
+  OptionFatalError = 710,
+  DelegateFatalError = 715,
+  MissingDelegateFatalError = 720,
+  CorruptImageFatalError = 725,
+  FileOpenFatalError = 730,
+  BlobFatalError = 735,
+  StreamFatalError = 740,
+  CacheFatalError = 745,
+  CoderFatalError = 750,
+  FilterFatalError = 752,
+  ModuleFatalError = 755,
+  DrawFatalError = 760,
+  ImageFatalError = 765,
+  WandFatalError = 770,
+  RandomFatalError = 775,
+  XServerFatalError = 780,
+  MonitorFatalError = 785,
+  RegistryFatalError = 790,
+  ConfigureFatalError = 795,
+  PolicyFatalError = 799
+} ExceptionType;
+
+struct _ExceptionInfo
+{
+  ExceptionType
+    severity;
+
+  int
+    error_number;
+
+  char
+    *reason,
+    *description;
+
+  void
+    *exceptions;
+
+  MagickBooleanType
+    relinquish;
+
+  SemaphoreInfo
+    *semaphore;
+
+  size_t
+    signature;
+};
+
+typedef void
+  (*ErrorHandler)(const ExceptionType,const char *,const char *);
+
+typedef void
+  (*FatalErrorHandler)(const ExceptionType,const char *,const char *);
+
+typedef void
+  (*WarningHandler)(const ExceptionType,const char *,const char *);
+
+extern MagickExport char
+  *GetExceptionMessage(const int);
+
+extern MagickExport const char
+  *GetLocaleExceptionMessage(const ExceptionType,const char *);
+
+extern MagickExport ErrorHandler
+  SetErrorHandler(ErrorHandler);
+
+extern MagickExport ExceptionInfo
+  *AcquireExceptionInfo(void),
+  *DestroyExceptionInfo(ExceptionInfo *);
+
+extern MagickExport FatalErrorHandler
+  SetFatalErrorHandler(FatalErrorHandler);
+
+extern MagickExport MagickBooleanType
+  ThrowException(ExceptionInfo *,const ExceptionType,const char *,
+    const char *),
+  ThrowMagickException(ExceptionInfo *,const char *,const char *,const size_t,
+    const ExceptionType,const char *,const char *,...)
+    magick_attribute((__format__ (__printf__,7,8))),
+  ThrowMagickExceptionList(ExceptionInfo *,const char *,const char *,
+    const size_t,const ExceptionType,const char *,const char *,va_list)
+    magick_attribute((__format__ (__printf__,7,0)));
+
+extern MagickExport void
+  CatchException(ExceptionInfo *),
+  ClearMagickException(ExceptionInfo *),
+  GetExceptionInfo(ExceptionInfo *),
+  InheritException(ExceptionInfo *,const ExceptionInfo *),
+  MagickError(const ExceptionType,const char *,const char *),
+  MagickFatalError(const ExceptionType,const char *,const char *),
+  MagickWarning(const ExceptionType,const char *,const char *);
+
+extern MagickExport WarningHandler
+  SetWarningHandler(WarningHandler);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/feature.h

@@ -0,0 +1,54 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore feature methods.
+*/
+#ifndef _MAGICKCORE_FEATURE_H
+#define _MAGICKCORE_FEATURE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/*
+  Haralick texture features.
+*/
+typedef struct _ChannelFeatures
+{
+  double
+    angular_second_moment[4],
+    contrast[4],
+    correlation[4],
+    variance_sum_of_squares[4],
+    inverse_difference_moment[4],
+    sum_average[4],
+    sum_variance[4],
+    sum_entropy[4],
+    entropy[4],
+    difference_variance[4],
+    difference_entropy[4],
+    measure_of_correlation_1[4],
+    measure_of_correlation_2[4],
+    maximum_correlation_coefficient[4];
+} ChannelFeatures;
+
+extern MagickExport ChannelFeatures
+  *GetImageChannelFeatures(const Image *,const size_t,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/fourier.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore discrete Fourier transform (DFT) methods.
+*/
+#ifndef _MAGICKCORE_FFT_H
+#define _MAGICKCORE_FFT_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport Image
+ *ForwardFourierTransformImage(const Image *,const MagickBooleanType,
+   ExceptionInfo *),
+ *InverseFourierTransformImage(const Image *,const Image *,
+   const MagickBooleanType,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/fx.h

@@ -0,0 +1,76 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image f/x methods.
+*/
+#ifndef _MAGICKCORE_FX_H
+#define _MAGICKCORE_FX_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/draw.h"
+
+typedef enum
+{
+  UndefinedNoise,
+  UniformNoise,
+  GaussianNoise,
+  MultiplicativeGaussianNoise,
+  ImpulseNoise,
+  LaplacianNoise,
+  PoissonNoise,
+  RandomNoise
+} NoiseType;
+
+extern MagickExport Image
+  *AddNoiseImage(const Image *,const NoiseType,ExceptionInfo *),
+  *AddNoiseImageChannel(const Image *,const ChannelType,const NoiseType,
+    ExceptionInfo *),
+  *BlueShiftImage(const Image *,const double,ExceptionInfo *),
+  *CharcoalImage(const Image *,const double,const double,ExceptionInfo *),
+  *ColorizeImage(const Image *,const char *,const PixelPacket,ExceptionInfo *),
+  *ColorMatrixImage(const Image *,const KernelInfo *kernel,ExceptionInfo *),
+  *FxImage(const Image *,const char *,ExceptionInfo *),
+  *FxImageChannel(const Image *,const ChannelType,const char *,ExceptionInfo *),
+  *ImplodeImage(const Image *,const double,ExceptionInfo *),
+  *MorphImages(const Image *,const size_t,ExceptionInfo *),
+  *PolaroidImage(const Image *,const DrawInfo *,const double,ExceptionInfo *),
+  *SepiaToneImage(const Image *,const double,ExceptionInfo *),
+  *ShadowImage(const Image *,const double,const double,const ssize_t,
+    const ssize_t,ExceptionInfo *),
+  *SketchImage(const Image *,const double,const double,const double,
+    ExceptionInfo *),
+  *SteganoImage(const Image *,const Image *,ExceptionInfo *),
+  *StereoImage(const Image *,const Image *,ExceptionInfo *),
+  *StereoAnaglyphImage(const Image *,const Image *,const ssize_t,const ssize_t,
+     ExceptionInfo *),
+  *SwirlImage(const Image *,double,ExceptionInfo *),
+  *TintImage(const Image *,const char *,const PixelPacket,ExceptionInfo *),
+  *VignetteImage(const Image *,const double,const double,const ssize_t,
+    const ssize_t,ExceptionInfo *),
+  *WaveImage(const Image *,const double,const double,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  PlasmaImage(Image *,const SegmentInfo *,size_t,size_t),
+  SolarizeImage(Image *,const double),
+  SolarizeImageChannel(Image *,const ChannelType,const double,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/gem.h

@@ -0,0 +1,60 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore private graphic gems methods.
+*/
+#ifndef _MAGICKCORE_GEM_PRIVATE_H
+#define _MAGICKCORE_GEM_PRIVATE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/fx.h"
+#include "magick/random_.h"
+
+extern MagickExport double
+  ExpandAffine(const AffineMatrix *),
+  GenerateDifferentialNoise(RandomInfo *,const Quantum,const NoiseType,
+    const MagickRealType);
+
+extern MagickExport size_t
+  GetOptimalKernelWidth(const double,const double),
+  GetOptimalKernelWidth1D(const double,const double),
+  GetOptimalKernelWidth2D(const double,const double);
+
+extern MagickExport void
+  ConvertHCLToRGB(const double,const double,const double,Quantum *,Quantum *,
+    Quantum *),
+  ConvertHSBToRGB(const double,const double,const double,Quantum *,Quantum *,
+    Quantum *),
+  ConvertHSLToRGB(const double,const double,const double,Quantum *,Quantum *,
+    Quantum *),
+  ConvertHWBToRGB(const double,const double,const double,Quantum *,Quantum *,
+    Quantum *),
+  ConvertRGBToHCL(const Quantum,const Quantum,const Quantum,double *,double *,
+    double *),
+  ConvertRGBToHSB(const Quantum,const Quantum,const Quantum,double *,double *,
+    double *),
+  ConvertRGBToHSL(const Quantum,const Quantum,const Quantum,double *,double *,
+    double *),
+  ConvertRGBToHWB(const Quantum,const Quantum,const Quantum,double *,double *,
+    double *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/geometry.h

@@ -0,0 +1,161 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image geometry methods.
+*/
+#ifndef _MAGICKCORE_GEOMETRY_H
+#define _MAGICKCORE_GEOMETRY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+#undef NoValue
+  NoValue = 0x0000,
+#undef XValue
+  XValue = 0x0001,
+  XiValue = 0x0001,
+#undef YValue
+  YValue = 0x0002,
+  PsiValue = 0x0002,
+#undef WidthValue
+  WidthValue = 0x0004,
+  RhoValue = 0x0004,
+#undef HeightValue
+  HeightValue = 0x0008,
+  SigmaValue = 0x0008,
+  ChiValue = 0x0010,
+  XiNegative = 0x0020,
+#undef XNegative
+  XNegative = 0x0020,
+  PsiNegative = 0x0040,
+#undef YNegative
+  YNegative = 0x0040,
+  ChiNegative = 0x0080,
+  PercentValue = 0x1000,   /* '%'  percentage of something */
+  AspectValue = 0x2000,    /* '!'  resize no-aspect - special use flag */
+  NormalizeValue = 0x2000, /* '!'  ScaleKernelValue() in morphology.c */
+  LessValue = 0x4000,      /* '<'  resize smaller - special use flag */
+  GreaterValue = 0x8000,   /* '>'  resize larger - spacial use flag */
+  MinimumValue = 0x10000,  /* '^'  special handling needed */
+  CorrelateNormalizeValue = 0x10000, /* '^' see ScaleKernelValue() */
+  AreaValue = 0x20000,     /* '@'  resize to area - special use flag */
+  DecimalValue = 0x40000,  /* '.'  floating point numbers found */
+  SeparatorValue = 0x80000,  /* 'x'  separator found  */
+#undef AllValues
+  AllValues = 0x7fffffff
+} GeometryFlags;
+
+#if defined(ForgetGravity)
+#undef ForgetGravity
+#undef NorthWestGravity
+#undef NorthGravity
+#undef NorthEastGravity
+#undef WestGravity
+#undef CenterGravity
+#undef EastGravity
+#undef SouthWestGravity
+#undef SouthGravity
+#undef SouthEastGravity
+#undef StaticGravity
+#endif
+
+typedef enum
+{
+  UndefinedGravity,
+  ForgetGravity = 0,
+  NorthWestGravity = 1,
+  NorthGravity = 2,
+  NorthEastGravity = 3,
+  WestGravity = 4, 
+  CenterGravity = 5,
+  EastGravity = 6,
+  SouthWestGravity = 7,
+  SouthGravity = 8,
+  SouthEastGravity = 9,
+  StaticGravity = 10 
+} GravityType;
+
+typedef struct _AffineMatrix
+{
+  double
+    sx,
+    rx,
+    ry,
+    sy,
+    tx,
+    ty;
+} AffineMatrix;
+
+typedef struct _GeometryInfo
+{
+  double
+    rho,
+    sigma,
+    xi,
+    psi,
+    chi;
+} GeometryInfo;
+
+typedef struct _OffsetInfo
+{
+  ssize_t
+    x,
+    y;
+} OffsetInfo;
+
+typedef struct _RectangleInfo
+{
+  size_t
+    width,
+    height;
+
+  ssize_t
+    x,
+    y;
+} RectangleInfo;
+
+extern MagickExport char
+  *GetPageGeometry(const char *);
+
+extern MagickExport MagickBooleanType
+  IsGeometry(const char *),
+  IsSceneGeometry(const char *,const MagickBooleanType);
+
+extern MagickExport MagickStatusType
+  GetGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *),
+  ParseAbsoluteGeometry(const char *,RectangleInfo *),
+  ParseAffineGeometry(const char *,AffineMatrix *,ExceptionInfo *),
+  ParseGeometry(const char *,GeometryInfo *),
+  ParseGravityGeometry(const Image *,const char *,RectangleInfo *,
+    ExceptionInfo *),
+  ParseMetaGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *),
+  ParsePageGeometry(const Image *,const char *,RectangleInfo *,ExceptionInfo *),
+  ParseRegionGeometry(const Image *,const char *,RectangleInfo *,
+    ExceptionInfo *);
+
+extern MagickExport void
+  GravityAdjustGeometry(const size_t,const size_t,
+    const GravityType,RectangleInfo *),
+  SetGeometry(const Image *,RectangleInfo *),
+  SetGeometryInfo(GeometryInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/hashmap.h

@@ -0,0 +1,83 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore hash methods.
+*/
+#ifndef _MAGICKCORE_HASHMAP_H
+#define _MAGICKCORE_HASHMAP_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#define SmallHashmapSize  17
+#define MediumHashmapSize  509
+#define LargeHashmapSize  8191
+#define HugeHashmapSize  131071
+
+typedef struct _HashmapInfo
+  HashmapInfo;
+
+typedef struct _LinkedListInfo
+  LinkedListInfo;
+
+extern MagickExport HashmapInfo
+  *DestroyHashmap(HashmapInfo *),
+  *NewHashmap(const size_t,size_t (*)(const void *),MagickBooleanType (*)
+    (const void *,const void *),void *(*)(void *),void *(*)(void *));
+
+extern MagickExport LinkedListInfo
+  *DestroyLinkedList(LinkedListInfo *,void *(*)(void *)),
+  *NewLinkedList(const size_t);
+
+extern MagickExport MagickBooleanType
+  AppendValueToLinkedList(LinkedListInfo *,const void *),
+  CompareHashmapString(const void *,const void *),
+  CompareHashmapStringInfo(const void *,const void *),
+  InsertValueInLinkedList(LinkedListInfo *,const size_t,const void *),
+  InsertValueInSortedLinkedList(LinkedListInfo *,
+    int (*)(const void *,const void *),void **,const void *),
+  IsHashmapEmpty(const HashmapInfo *),
+  IsLinkedListEmpty(const LinkedListInfo *),
+  LinkedListToArray(LinkedListInfo *,void **),
+  PutEntryInHashmap(HashmapInfo *,const void *,const void *);
+
+extern MagickExport size_t
+  GetNumberOfElementsInLinkedList(const LinkedListInfo *),
+  GetNumberOfEntriesInHashmap(const HashmapInfo *),
+  HashPointerType(const void *),
+  HashStringType(const void *),
+  HashStringInfoType(const void *);
+
+extern MagickExport void
+  ClearLinkedList(LinkedListInfo *,void *(*)(void *)),
+  *GetLastValueInLinkedList(LinkedListInfo *),
+  *GetNextKeyInHashmap(HashmapInfo *),
+  *GetNextValueInHashmap(HashmapInfo *),
+  *GetNextValueInLinkedList(LinkedListInfo *),
+  *GetValueFromHashmap(HashmapInfo *,const void *),
+  *GetValueFromLinkedList(LinkedListInfo *,const size_t),
+  *RemoveElementByValueFromLinkedList(LinkedListInfo *,const void *),
+  *RemoveElementFromLinkedList(LinkedListInfo *,const size_t),
+  *RemoveEntryFromHashmap(HashmapInfo *,const void *),
+  *RemoveLastElementFromLinkedList(LinkedListInfo *),
+  ResetHashmapIterator(HashmapInfo *),
+  ResetLinkedListIterator(LinkedListInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/histogram.h

@@ -0,0 +1,55 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore histogram methods.
+*/
+#ifndef _MAGICKCORE_HISTOGRAM_H
+#define _MAGICKCORE_HISTOGRAM_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _ColorPacket
+{
+  PixelPacket
+    pixel;
+
+  IndexPacket
+    index;
+
+  MagickSizeType
+    count;
+} ColorPacket;
+
+extern MagickExport ColorPacket
+  *GetImageHistogram(const Image *,size_t *,ExceptionInfo *);
+
+extern MagickExport Image
+  *UniqueImageColors(const Image *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  IsHistogramImage(const Image *,ExceptionInfo *),
+  IsPaletteImage(const Image *,ExceptionInfo *),
+  MinMaxStretchImage(Image *,const ChannelType,const double,const double);
+
+extern MagickExport size_t
+  GetNumberColors(const Image *,FILE *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/identify.h

@@ -0,0 +1,32 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image identify method.
+*/
+#ifndef _MAGICKCORE_IDENTIFY_H
+#define _MAGICKCORE_IDENTIFY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  IdentifyImage(Image *,FILE *,const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/image-view.h

@@ -0,0 +1,83 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITTransferNS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image view methods.
+*/
+#ifndef _MAGICKIMAGE_IMAGE_VIEW_H
+#define _MAGICKIMAGE_IMAGE_VIEW_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _ImageView
+  ImageView;
+
+typedef MagickBooleanType
+  (*DuplexTransferImageViewMethod)(const ImageView *,const ImageView *,
+    ImageView *,const ssize_t,const int,void *),
+  (*GetImageViewMethod)(const ImageView *,const ssize_t,const int,void *),
+  (*SetImageViewMethod)(ImageView *,const ssize_t,const int,void *),
+  (*TransferImageViewMethod)(const ImageView *,ImageView *,const ssize_t,
+    const int,void *),
+  (*UpdateImageViewMethod)(ImageView *,const ssize_t,const int,void *);
+
+extern MagickExport char
+  *GetImageViewException(const ImageView *,ExceptionType *);
+
+extern MagickExport const IndexPacket
+  *GetImageViewVirtualIndexes(const ImageView *);
+
+extern MagickExport const PixelPacket
+  *GetImageViewVirtualPixels(const ImageView *);
+
+extern MagickExport Image
+  *GetImageViewImage(const ImageView *);
+
+extern MagickExport ImageView
+  *CloneImageView(const ImageView *),
+  *DestroyImageView(ImageView *),
+  *NewImageView(Image *),
+  *NewImageViewRegion(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t);
+
+extern MagickExport IndexPacket
+  *GetImageViewAuthenticIndexes(const ImageView *);
+
+extern MagickExport MagickBooleanType
+  DuplexTransferImageViewIterator(ImageView *,ImageView *,ImageView *,
+    DuplexTransferImageViewMethod,void *),
+  GetImageViewIterator(ImageView *,GetImageViewMethod,void *),
+  IsImageView(const ImageView *),
+  SetImageViewIterator(ImageView *,SetImageViewMethod,void *),
+  TransferImageViewIterator(ImageView *,ImageView *,TransferImageViewMethod,
+    void *),
+  UpdateImageViewIterator(ImageView *,UpdateImageViewMethod,void *);
+
+extern MagickExport PixelPacket
+  *GetImageViewAuthenticPixels(const ImageView *);
+
+extern MagickExport RectangleInfo
+  GetImageViewExtent(const ImageView *);
+
+extern MagickExport void
+  SetImageViewDescription(ImageView *,const char *),
+  SetImageViewThreads(ImageView *,const size_t);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/image.h

@@ -0,0 +1,568 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image methods.
+*/
+#ifndef _MAGICKCORE_IMAGE_H
+#define _MAGICKCORE_IMAGE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/color.h"
+
+#define OpaqueOpacity  ((Quantum) 0UL)
+#define TransparentOpacity  (QuantumRange)
+
+typedef enum
+{
+  UndefinedAlphaChannel,
+  ActivateAlphaChannel,
+  BackgroundAlphaChannel,
+  CopyAlphaChannel,
+  DeactivateAlphaChannel,
+  ExtractAlphaChannel,
+  OpaqueAlphaChannel,
+  ResetAlphaChannel,  /* deprecated */
+  SetAlphaChannel,
+  ShapeAlphaChannel,
+  TransparentAlphaChannel,
+  FlattenAlphaChannel,
+  RemoveAlphaChannel
+} AlphaChannelType;
+
+typedef enum
+{
+  UndefinedType,
+  BilevelType,
+  GrayscaleType,
+  GrayscaleMatteType,
+  PaletteType,
+  PaletteMatteType,
+  TrueColorType,
+  TrueColorMatteType,
+  ColorSeparationType,
+  ColorSeparationMatteType,
+  OptimizeType,
+  PaletteBilevelMatteType
+} ImageType;
+
+typedef enum
+{
+  UndefinedInterlace,
+  NoInterlace,
+  LineInterlace,
+  PlaneInterlace,
+  PartitionInterlace,
+  GIFInterlace,
+  JPEGInterlace,
+  PNGInterlace
+} InterlaceType;
+
+typedef enum
+{
+  UndefinedOrientation,
+  TopLeftOrientation,
+  TopRightOrientation,
+  BottomRightOrientation,
+  BottomLeftOrientation,
+  LeftTopOrientation,
+  RightTopOrientation,
+  RightBottomOrientation,
+  LeftBottomOrientation
+} OrientationType;
+
+typedef enum
+{
+  UndefinedResolution,
+  PixelsPerInchResolution,
+  PixelsPerCentimeterResolution
+} ResolutionType;
+
+typedef struct _PrimaryInfo
+{
+  double
+    x,
+    y,
+    z;
+} PrimaryInfo;
+
+typedef struct _SegmentInfo
+{
+  double
+    x1,
+    y1,
+    x2,
+    y2;
+} SegmentInfo;
+
+typedef enum
+{
+  UndefinedTransmitType,
+  FileTransmitType,
+  BlobTransmitType,
+  StreamTransmitType,
+  ImageTransmitType
+} TransmitType;
+
+typedef struct _ChromaticityInfo
+{
+  PrimaryInfo
+    red_primary,
+    green_primary,
+    blue_primary,
+    white_point;
+} ChromaticityInfo;
+
+#include "magick/blob.h"
+#include "magick/colorspace.h"
+#include "magick/cache-view.h"
+#include "magick/color.h"
+#include "magick/composite.h"
+#include "magick/compress.h"
+#include "magick/effect.h"
+#include "magick/geometry.h"
+#include "magick/layer.h"
+#include "magick/locale_.h"
+#include "magick/monitor.h"
+#include "magick/pixel.h"
+#include "magick/profile.h"
+#include "magick/quantum.h"
+#include "magick/resample.h"
+#include "magick/resize.h"
+#include "magick/semaphore.h"
+#include "magick/stream.h"
+#include "magick/timer.h"
+
+struct _Image
+{
+  ClassType
+    storage_class;
+
+  ColorspaceType
+    colorspace;      /* colorspace of image data */
+
+  CompressionType
+    compression;     /* compression of image when read/write */
+
+  size_t
+    quality;         /* compression quality setting, meaning varies */
+
+  OrientationType
+    orientation;     /* photo orientation of image */
+
+  MagickBooleanType
+    taint,           /* has image been modified since reading */
+    matte;           /* is transparency channel defined and active */
+
+  size_t
+    columns,         /* physical size of image */
+    rows,
+    depth,           /* depth of image on read/write */
+    colors;          /* size of color table on read */
+
+  PixelPacket
+    *colormap,
+    background_color, /* current background color attribute */
+    border_color,     /* current bordercolor attribute */
+    matte_color;      /* current mattecolor attribute */
+
+  double
+    gamma;
+
+  ChromaticityInfo
+    chromaticity;
+
+  RenderingIntent
+    rendering_intent;
+
+  void
+    *profiles;
+
+  ResolutionType
+    units;          /* resolution/density  ppi or ppc */
+
+  char
+    *montage,
+    *directory,
+    *geometry;
+
+  ssize_t
+    offset;
+
+  double
+    x_resolution,   /* image resolution/density */
+    y_resolution;
+
+  RectangleInfo
+    page,           /* virtual canvas size and offset of image */
+    extract_info,
+    tile_info;      /* deprecated */
+
+  double
+    bias,
+    blur,           /* deprecated */
+    fuzz;           /* current color fuzz attribute */
+
+  FilterTypes
+    filter;         /* resize/distort filter to apply */
+
+  InterlaceType
+    interlace;
+
+  EndianType
+    endian;         /* raw data integer ordering on read/write */
+
+  GravityType
+    gravity;        /* Gravity attribute for positioning in image */
+
+  CompositeOperator
+    compose;        /* alpha composition method for layered images */
+
+  DisposeType
+    dispose;        /* GIF animation disposal method */
+
+  struct _Image
+    *clip_mask;
+
+  size_t
+    scene,          /* index of image in multi-image file */
+    delay;          /* Animation delay time */
+
+  ssize_t
+    ticks_per_second;  /* units for delay time, default 100 for GIF */
+
+  size_t
+    iterations,
+    total_colors;
+
+  ssize_t
+    start_loop;
+
+  ErrorInfo
+    error;
+
+  TimerInfo
+    timer;
+
+  MagickProgressMonitor
+    progress_monitor;
+
+  void
+    *client_data,
+    *cache,
+    *attributes;      /* deprecated */
+
+  Ascii85Info
+    *ascii85;
+
+  BlobInfo
+    *blob;
+
+  char
+    filename[MaxTextExtent],         /* images input filename */
+    magick_filename[MaxTextExtent],  /* ditto with coders, and read_mods */
+    magick[MaxTextExtent];           /* Coder used to decode image */
+
+  size_t
+    magick_columns,
+    magick_rows;
+
+  ExceptionInfo
+    exception;        /* Error handling report */
+
+  MagickBooleanType
+    debug;            /* debug output attribute */
+
+  volatile ssize_t
+    reference_count;
+
+  SemaphoreInfo
+    *semaphore;
+
+  ProfileInfo
+    color_profile,
+    iptc_profile,
+    *generic_profile;
+
+  size_t
+    generic_profiles;  /* this & ProfileInfo is deprecated */
+
+  size_t
+    signature;
+
+  struct _Image
+    *previous,         /* Image list links */
+    *list,             /* Undo/Redo image processing list (for display) */
+    *next;             /* Image list links */
+
+  InterpolatePixelMethod
+    interpolate;       /* Interpolation of color for between pixel lookups */
+
+  MagickBooleanType
+    black_point_compensation;
+
+  PixelPacket
+    transparent_color; /* color for 'transparent' color index in GIF */
+
+  struct _Image
+    *mask;
+
+  RectangleInfo
+    tile_offset;
+
+  void
+    *properties,       /* per image properities */
+    *artifacts;        /* per image sequence image artifacts */
+
+  ImageType
+    type;
+
+  MagickBooleanType
+    dither;            /* dithering method during color reduction */
+
+  MagickSizeType
+    extent;
+
+  MagickBooleanType
+    ping;
+
+  size_t
+    channels;
+
+  time_t
+    timestamp;
+};
+
+struct _ImageInfo
+{
+  CompressionType
+    compression;
+
+  OrientationType
+    orientation;
+
+  MagickBooleanType
+    temporary,
+    adjoin,
+    affirm,
+    antialias;
+
+  char
+    *size,
+    *extract,
+    *page,
+    *scenes;
+
+  size_t
+    scene,
+    number_scenes,
+    depth;
+
+  InterlaceType
+    interlace;
+
+  EndianType
+    endian;
+
+  ResolutionType
+    units;
+
+  size_t
+    quality;
+
+  char
+    *sampling_factor,
+    *server_name,
+    *font,
+    *texture,
+    *density;
+
+  double
+    pointsize,
+    fuzz;
+
+  PixelPacket
+    background_color,
+    border_color,
+    matte_color;
+
+  MagickBooleanType
+    dither,
+    monochrome;
+
+  size_t
+    colors;
+
+  ColorspaceType
+    colorspace;
+
+  ImageType
+    type;
+
+  PreviewType
+    preview_type;
+
+  ssize_t
+    group;
+
+  MagickBooleanType
+    ping,
+    verbose;
+
+  char
+    *view,
+    *authenticate;
+
+  ChannelType
+    channel;
+
+  Image
+    *attributes;  /* deprecated */
+
+  void
+    *options;
+
+  MagickProgressMonitor
+    progress_monitor;
+
+  void
+    *client_data,
+    *cache;
+
+  StreamHandler
+    stream;
+
+  FILE
+    *file;
+
+  void
+    *blob;
+
+  size_t
+    length;
+
+  char
+    magick[MaxTextExtent],
+    unique[MaxTextExtent],
+    zero[MaxTextExtent],
+    filename[MaxTextExtent];
+
+  MagickBooleanType
+    debug;
+
+  char
+    *tile;  /* deprecated */
+
+  size_t
+    subimage,  /* deprecated */
+    subrange;  /* deprecated */
+
+  PixelPacket
+    pen;  /* deprecated */
+
+  size_t
+    signature;
+
+  VirtualPixelMethod
+    virtual_pixel_method;
+
+  PixelPacket
+    transparent_color;
+
+  void
+    *profile;
+
+  MagickBooleanType
+    synchronize;
+};
+
+extern MagickExport ExceptionType
+  CatchImageException(Image *);
+
+extern MagickExport FILE
+  *GetImageInfoFile(const ImageInfo *);
+
+extern MagickExport Image
+  *AcquireImage(const ImageInfo *),
+  *AppendImages(const Image *,const MagickBooleanType,ExceptionInfo *),
+  *CloneImage(const Image *,const size_t,const size_t,const MagickBooleanType,
+    ExceptionInfo *),
+  *DestroyImage(Image *),
+  *GetImageClipMask(const Image *,ExceptionInfo *),
+  *GetImageMask(const Image *,ExceptionInfo *),
+  *NewMagickImage(const ImageInfo *,const size_t,const size_t,
+    const MagickPixelPacket *),
+  *ReferenceImage(Image *),
+  *SmushImages(const Image *,const MagickBooleanType,const ssize_t,
+    ExceptionInfo *);
+
+extern MagickExport ImageInfo
+  *AcquireImageInfo(void),
+  *CloneImageInfo(const ImageInfo *),
+  *DestroyImageInfo(ImageInfo *);
+
+extern MagickExport MagickBooleanType
+  ClipImage(Image *),
+  ClipImagePath(Image *,const char *,const MagickBooleanType),
+  IsTaintImage(const Image *),
+  IsMagickConflict(const char *),
+  IsHighDynamicRangeImage(const Image *,ExceptionInfo *),
+  IsImageObject(const Image *),
+  ListMagickInfo(FILE *,ExceptionInfo *),
+  ModifyImage(Image **,ExceptionInfo *),
+  ResetImagePage(Image *,const char *),
+  SetImageBackgroundColor(Image *),
+  SetImageClipMask(Image *,const Image *),
+  SetImageColor(Image *,const MagickPixelPacket *),
+  SetImageExtent(Image *,const size_t,const size_t),
+  SetImageInfo(ImageInfo *,const unsigned int,ExceptionInfo *),
+  SetImageMask(Image *,const Image *),
+  SetImageOpacity(Image *,const Quantum),
+  SetImageChannels(Image *,const size_t),
+  SetImageStorageClass(Image *,const ClassType),
+  StripImage(Image *),
+  SyncImage(Image *),
+  SyncImageSettings(const ImageInfo *,Image *),
+  SyncImagesSettings(ImageInfo *,Image *);
+
+extern MagickExport size_t
+  InterpretImageFilename(const ImageInfo *,Image *,const char *,int,char *);
+
+extern MagickExport ssize_t
+  GetImageReferenceCount(Image *);
+
+extern MagickExport size_t
+  GetImageChannels(Image *);
+
+extern MagickExport VirtualPixelMethod
+  GetImageVirtualPixelMethod(const Image *),
+  SetImageVirtualPixelMethod(const Image *,const VirtualPixelMethod);
+
+extern MagickExport void
+  AcquireNextImage(const ImageInfo *,Image *),
+  DestroyImagePixels(Image *),
+  DisassociateImageStream(Image *),
+  GetImageException(Image *,ExceptionInfo *),
+  GetImageInfo(ImageInfo *),
+  SetImageInfoBlob(ImageInfo *,const void *,const size_t),
+  SetImageInfoFile(ImageInfo *,FILE *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/layer.h

@@ -0,0 +1,75 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image layer methods.
+*/
+#ifndef _MAGICKCORE_LAYER_H
+#define _MAGICKCORE_LAYER_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UnrecognizedDispose,
+  UndefinedDispose = 0,
+  NoneDispose = 1,
+  BackgroundDispose = 2,
+  PreviousDispose = 3
+} DisposeType;
+
+typedef enum
+{
+  UndefinedLayer,
+  CoalesceLayer,
+  CompareAnyLayer,
+  CompareClearLayer,
+  CompareOverlayLayer,
+  DisposeLayer,
+  OptimizeLayer,
+  OptimizeImageLayer,
+  OptimizePlusLayer,
+  OptimizeTransLayer,
+  RemoveDupsLayer,
+  RemoveZeroLayer,
+  CompositeLayer,
+  MergeLayer,
+  FlattenLayer,
+  MosaicLayer,
+  TrimBoundsLayer
+} ImageLayerMethod;
+
+extern MagickExport Image
+  *CoalesceImages(const Image *,ExceptionInfo *),
+  *DisposeImages(const Image *,ExceptionInfo *),
+  *CompareImageLayers(const Image *,const ImageLayerMethod,ExceptionInfo *),
+  *DeconstructImages(const Image *,ExceptionInfo *),
+  *MergeImageLayers(Image *,const ImageLayerMethod,ExceptionInfo *),
+  *OptimizeImageLayers(const Image *,ExceptionInfo *),
+  *OptimizePlusImageLayers(const Image *,ExceptionInfo *);
+
+extern MagickExport void
+  CompositeLayers(Image *,const CompositeOperator,Image *,const ssize_t,
+    const ssize_t,ExceptionInfo *),
+  OptimizeImageTransparency(const Image *,ExceptionInfo *),
+  RemoveDuplicateLayers(Image **,ExceptionInfo *),
+  RemoveZeroDelayLayers(Image **,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/list.h

@@ -0,0 +1,65 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image list methods.
+*/
+#ifndef _MAGICKCORE_LIST_H
+#define _MAGICKCORE_LIST_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport Image
+  *CloneImageList(const Image *,ExceptionInfo *),
+  *CloneImages(const Image *,const char *,ExceptionInfo *),
+  *DestroyImageList(Image *),
+  *DuplicateImages(Image *,const size_t,const char *,ExceptionInfo *),
+  *GetFirstImageInList(const Image *),
+  *GetImageFromList(const Image *,const ssize_t),
+  *GetLastImageInList(const Image *),
+  *GetNextImageInList(const Image *),
+  *GetPreviousImageInList(const Image *),
+  **ImageListToArray(const Image *,ExceptionInfo *),
+  *NewImageList(void),
+  *RemoveImageFromList(Image **),
+  *RemoveLastImageFromList(Image **),
+  *RemoveFirstImageFromList(Image **),
+  *SpliceImageIntoList(Image **,const size_t,const Image *),
+  *SplitImageList(Image *),
+  *SyncNextImageInList(const Image *);
+
+extern MagickExport size_t
+  GetImageListLength(const Image *);
+
+extern MagickExport ssize_t
+  GetImageIndexInList(const Image *);
+
+extern MagickExport void
+  AppendImageToList(Image **,const Image *),
+  DeleteImageFromList(Image **),
+  DeleteImages(Image **,const char *,ExceptionInfo *),
+  InsertImageInList(Image **,Image *),
+  PrependImageToList(Image **,Image *),
+  ReplaceImageInList(Image **,Image *),
+  ReplaceImageInListReturnLast(Image **,Image *),
+  ReverseImageList(Image **),
+  SyncImageList(Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/locale_.h

@@ -0,0 +1,83 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore locale methods.
+*/
+#ifndef _MAGICKCORE_LOCALE_H
+#define _MAGICKCORE_LOCALE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/hashmap.h"
+
+typedef struct _LocaleInfo
+{
+  char
+    *path,
+    *tag,
+    *message;
+                                                                                
+  MagickBooleanType
+    stealth;
+                                                                                
+  struct _LocaleInfo
+    *previous,
+    *next;  /* deprecated, use GetLocaleInfoList() */
+
+  size_t
+    signature;
+} LocaleInfo;
+
+extern MagickExport char
+  **GetLocaleList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const char
+  *GetLocaleMessage(const char *);
+
+extern MagickExport const LocaleInfo
+  *GetLocaleInfo_(const char *,ExceptionInfo *),
+  **GetLocaleInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport double
+  InterpretLocaleValue(const char *restrict,char **restrict);
+
+extern MagickExport LinkedListInfo
+  *DestroyLocaleOptions(LinkedListInfo *),
+  *GetLocaleOptions(const char *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  ListLocaleInfo(FILE *,ExceptionInfo *),
+  LocaleComponentGenesis(void);
+
+extern MagickExport ssize_t
+  FormatLocaleFile(FILE *,const char *restrict,...)
+    magick_attribute((__format__ (__printf__,2,3))),
+  FormatLocaleFileList(FILE *,const char *restrict,va_list)
+    magick_attribute((__format__ (__printf__,2,0))),
+  FormatLocaleString(char *restrict,const size_t,const char *restrict,...)
+    magick_attribute((__format__ (__printf__,3,4))),
+  FormatLocaleStringList(char *restrict,const size_t,const char *restrict,
+    va_list) magick_attribute((__format__ (__printf__,3,0)));
+
+extern MagickExport void
+  LocaleComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/log.h

@@ -0,0 +1,95 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore log methods.
+*/
+#ifndef _MAGICKCORE_LOG_H
+#define _MAGICKCORE_LOG_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include "magick/exception.h"
+
+#if !defined(GetMagickModule)
+# define GetMagickModule()  __FILE__,__func__,(unsigned long) __LINE__
+#endif
+
+#define MagickLogFilename  "log.xml"
+
+typedef enum
+{
+  UndefinedEvents,
+  NoEvents = 0x00000,
+  TraceEvent = 0x00001,
+  AnnotateEvent = 0x00002,
+  BlobEvent = 0x00004,
+  CacheEvent = 0x00008,
+  CoderEvent = 0x00010,
+  ConfigureEvent = 0x00020,
+  DeprecateEvent = 0x00040,
+  DrawEvent = 0x00080,
+  ExceptionEvent = 0x00100,
+  ImageEvent = 0x00200,
+  LocaleEvent = 0x00400,
+  ModuleEvent = 0x00800,
+  PolicyEvent = 0x01000,
+  ResourceEvent = 0x02000,
+  TransformEvent = 0x04000,
+  UserEvent = 0x09000,
+  WandEvent = 0x10000,
+  X11Event = 0x20000,
+  AccelerateEvent = 0x40000,
+  AllEvents = 0x7fffffff
+} LogEventType;
+
+typedef struct _LogInfo
+  LogInfo;
+
+extern MagickExport char
+  **GetLogList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const char
+  *GetLogName(void),
+  *SetLogName(const char *);
+                                                                                
+extern MagickExport const LogInfo
+  **GetLogInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport LogEventType
+  SetLogEventMask(const char *);
+
+extern MagickExport MagickBooleanType
+  IsEventLogging(void),
+  ListLogInfo(FILE *,ExceptionInfo *),
+  LogComponentGenesis(void),
+  LogMagickEvent(const LogEventType,const char *,const char *,const size_t,
+    const char *,...) 
+    magick_attribute((__format__ (__printf__,5,6))),
+  LogMagickEventList(const LogEventType,const char *,const char *,const size_t,
+    const char *,va_list) magick_attribute((__format__ (__printf__,5,0)));
+
+extern MagickExport void
+  CloseMagickLog(void),
+  LogComponentTerminus(void),
+  SetLogFormat(const char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/magic.h

@@ -0,0 +1,74 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore magic methods.
+*/
+#ifndef _MAGICKCORE_MAGIC_H
+#define _MAGICKCORE_MAGIC_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _MagicInfo
+{
+  char
+    *path,
+    *name,
+    *target;
+
+  unsigned char
+    *magic;
+
+  size_t
+    length;
+
+  MagickOffsetType
+    offset;
+
+  MagickBooleanType
+    exempt,
+    stealth;
+
+  struct _MagicInfo
+    *previous,
+    *next;  /* deprecated, use GetMagicInfoList() */
+
+  size_t
+    signature;
+} MagicInfo;
+
+extern MagickExport char
+  **GetMagicList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const char
+  *GetMagicName(const MagicInfo *);
+
+extern MagickExport MagickBooleanType
+  ListMagicInfo(FILE *,ExceptionInfo *),
+  MagicComponentGenesis(void);
+
+extern MagickExport const MagicInfo
+  *GetMagicInfo(const unsigned char *,const size_t,ExceptionInfo *),
+  **GetMagicInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport void
+  MagicComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/magick-config.h

@@ -0,0 +1,166 @@
+/*
+  Copyright 2012 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickConfig not autogenerated (fixed stuff)
+*/
+#ifndef _MAGICKCORE_MAGICK_CONFIG_H
+#define _MAGICKCORE_MAGICK_CONFIG_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/magick-baseconfig.h"
+
+/* Compatibility block */
+#if !defined(MAGICKCORE_QUANTUM_DEPTH) && defined(MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H)
+# warning "you should set MAGICKCORE_QUANTUM_DEPTH to sensible default set it to configure time default"
+# warning "this is an obsolete behavior please fix your makefile"
+# define MAGICKCORE_QUANTUM_DEPTH MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H
+#endif
+
+/* Number of bits in a pixel Quantum (8/16/32/64) */
+#ifndef MAGICKCORE_QUANTUM_DEPTH
+# error "you should set MAGICKCORE_QUANTUM_DEPTH"
+#endif
+
+/* check values */
+#if MAGICKCORE_QUANTUM_DEPTH != 8
+# if MAGICKCORE_QUANTUM_DEPTH != 16
+#  if MAGICKCORE_QUANTUM_DEPTH != 32
+#   if MAGICKCORE_QUANTUM_DEPTH != 64
+#    error "MAGICKCORE_QUANTUM_DEPTH is not 8/16/32/64 bits"
+#   endif
+#  endif
+# endif
+#endif
+
+
+#if !defined(MAGICKCORE_HDRI_ENABLE) && defined(MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H)
+# warning "you should set MAGICKCORE_HDRI_ENABLE to sensible default set it to configure time default"
+# warning "this is an obsolete behavior please fix yours makefile"
+# define MAGICKCORE_HDRI_ENABLE MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H
+#endif
+
+/* whether HDRI is enable */
+#if !defined(MAGICKCORE_HDRI_ENABLE)
+# error "you should set MAGICKCORE_HDRI_ENABLE"
+#endif
+
+#if MAGICKCORE_HDRI_ENABLE
+# define MAGICKCORE_HDRI_SUPPORT 1
+#endif
+
+#if defined __CYGWIN32__ && !defined __CYGWIN__
+   /* For backwards compatibility with Cygwin b19 and
+      earlier, we define __CYGWIN__ here, so that
+      we can rely on checking just for that macro. */
+#  define __CYGWIN__  __CYGWIN32__
+#endif
+
+/*! stringify */
+#define MAGICKCORE_STRING_QUOTE(str) #str
+#define MAGICKCORE_STRING_XQUOTE(str) MAGICKCORE_STRING_QUOTE(str)
+
+/*  ABI SUFFIX */
+#ifndef MAGICKCORE_HDRI_SUPPORT
+#define MAGICKCORE_ABI_SUFFIX  "Q" MAGICKCORE_STRING_XQUOTE(MAGICKCORE_QUANTUM_DEPTH)
+#else 
+#define MAGICKCORE_ABI_SUFFIX "Q" MAGICKCORE_STRING_XQUOTE(MAGICKCORE_QUANTUM_DEPTH) "HDRI"
+#endif 
+
+/* some path game */
+#if !defined __CYGWIN__
+# if defined (_WIN32) || defined (_WIN64) || defined (__MSDOS__) || defined (__DJGPP__) || defined (__OS2__)
+   /* Use Windows separators on all _WIN32 defining
+      environments, except Cygwin. */
+#  define MAGICKCORE_DIR_SEPARATOR_CHAR		'\\'
+#  define MAGICKCORE_DIR_SEPARATOR		"\\"
+#  define MAGICKCORE_PATH_SEPARATOR_CHAR	';'
+#  define MAGICKCORE_PATH_SEPARATOR		";"
+# endif
+#endif
+ 
+/* posix */
+#ifndef MAGICKCORE_DIR_SEPARATOR_CHAR
+   /* Assume that not having this is an indicator that all
+      are missing. */
+#  define MAGICKCORE_DIR_SEPARATOR_CHAR		'/'
+#  define MAGICKCORE_DIR_SEPARATOR		"/"
+#  define MAGICKCORE_PATH_SEPARATOR_CHAR	':'
+#  define MAGICKCORE_PATH_SEPARATOR		":"
+#endif /* !DIR_SEPARATOR_CHAR */
+
+# if defined(MAGICKCORE_POSIX_SUPPORT)
+ 
+/* module dir */
+#ifndef MAGICKCORE_MODULES_DIRNAME
+# define MAGICKCORE_MODULES_DIRNAME MAGICKCORE_MODULES_BASEDIRNAME "-" MAGICKCORE_ABI_SUFFIX
+#endif
+ 
+#ifndef MAGICKCORE_MODULES_PATH
+#  define MAGICKCORE_MODULES_PATH MAGICKCORE_LIBRARY_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_MODULES_DIRNAME
+#endif
+ 
+#ifndef MAGICKCORE_MODULES_RELATIVE_PATH
+#define MAGICKCORE_MODULES_RELATIVE_PATH MAGICKCORE_LIBRARY_RELATIVE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_MODULES_DIRNAME
+#endif
+ 
+/* Subdirectory under lib to place ImageMagick coder module files */
+#ifndef MAGICKCORE_CODER_PATH
+# if defined(vms)
+#  define MAGICKCORE_CODER_PATH "sys$login:"
+# else
+#  define MAGICKCORE_CODER_PATH MAGICKCORE_MODULES_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_CODER_DIRNAME
+# endif
+#endif
+ 
+#ifndef MAGICKCORE_CODER_RELATIVE_PATH
+# define MAGICKCORE_CODER_RELATIVE_PATH MAGICKCORE_MODULES_RELATIVE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_CODER_DIRNAME
+#endif
+ 
+/* subdirectory under lib to place ImageMagick filter module files */
+#ifndef MAGICKCORE_FILTER_PATH
+# if defined(vms)
+#  define MAGICKCORE_FILTER_PATH  "sys$login:"
+# else
+#  define MAGICKCORE_FILTER_PATH MAGICKCORE_MODULES_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_FILTER_DIRNAME
+# endif
+#endif
+ 
+#ifndef MAGICKCORE_FILTER_RELATIVE_PATH
+# define MAGICKCORE_FILTER_RELATIVE_PATH MAGICKCORE_MODULES_RELATIVE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_FILTER_DIRNAME
+#endif
+
+/* sharearch dir */
+#ifndef MAGICKCORE_SHAREARCH_DIRNAME
+# define MAGICKCORE_SHAREARCH_DIRNAME MAGICKCORE_SHAREARCH_BASEDIRNAME "-" MAGICKCORE_ABI_SUFFIX
+#endif
+ 
+#ifndef MAGICKCORE_SHAREARCH_PATH
+#  define MAGICKCORE_SHAREARCH_PATH MAGICKCORE_LIBRARY_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_SHAREARCH_DIRNAME MAGICKCORE_DIR_SEPARATOR
+#endif
+ 
+#ifndef MAGICKCORE_SHAREARCH_RELATIVE_PATH
+#define MAGICKCORE_SHAREARCH_RELATIVE_PATH MAGICKCORE_LIBRARY_RELATIVE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_SHAREARCH_DIRNAME
+#endif
+
+#endif
+ 
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+ 
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/magick-type.h

@@ -0,0 +1,228 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore types.
+*/
+#ifndef _MAGICKCORE_MAGICK_TYPE_H
+#define _MAGICKCORE_MAGICK_TYPE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/magick-config.h"
+
+#if !defined(MAGICKCORE_QUANTUM_DEPTH)
+#define MAGICKCORE_QUANTUM_DEPTH  16
+#endif
+
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__MINGW32__) && !defined(__MINGW64__)
+#  define MagickLLConstant(c)  (MagickOffsetType) (c ## i64)
+#  define MagickULLConstant(c)  (MagickSizeType) (c ## ui64)
+#else
+#  define MagickLLConstant(c)  (MagickOffsetType) (c ## LL)
+#  define MagickULLConstant(c)  (MagickSizeType) (c ## ULL)
+#endif
+
+#if (MAGICKCORE_QUANTUM_DEPTH == 8)
+#define MaxColormapSize  256UL
+#define MaxMap  255UL
+
+/*
+  Float_t is not an ABI type.
+*/
+#if MAGICKCORE_SIZEOF_FLOAT_T == 0
+typedef float MagickRealType;
+#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_FLOAT)
+typedef float MagickRealType;
+#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_DOUBLE)
+typedef double MagickRealType;
+#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_LONG_DOUBLE)
+typedef long double MagickRealType;
+#else
+# error Your float_t type is neither a float, nor a double, nor a long double
+#endif
+
+typedef ssize_t SignedQuantum;
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+typedef float Quantum;
+#define QuantumRange  255.0
+#define QuantumFormat  "%g"
+#else
+typedef unsigned char Quantum;
+#define QuantumRange  ((Quantum) 255)
+#define QuantumFormat  "%u"
+#endif
+#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
+#define MaxColormapSize  65536UL
+#define MaxMap  65535UL
+
+/*
+  Float_t is not an ABI type.
+*/
+#if MAGICKCORE_SIZEOF_FLOAT_T == 0
+typedef float MagickRealType;
+#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_FLOAT)
+typedef float MagickRealType;
+#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_DOUBLE)
+typedef double MagickRealType;
+#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_LONG_DOUBLE)
+typedef long double MagickRealType;
+#else
+# error Your float_t type is neither a float, nor a double, nor a long double
+#endif
+
+typedef ssize_t SignedQuantum;
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+typedef float Quantum;
+#define QuantumRange  65535.0
+#define QuantumFormat  "%g"
+#else
+typedef unsigned short Quantum;
+#define QuantumRange  ((Quantum) 65535)
+#define QuantumFormat  "%u"
+#endif
+#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
+#define MaxColormapSize  65536UL
+#define MaxMap  65535UL
+
+/*
+  Double_t is not an ABI type.
+*/
+#if MAGICKCORE_SIZEOF_DOUBLE_T == 0
+typedef double MagickRealType;
+#elif (MAGICKCORE_SIZEOF_DOUBLE_T == MAGICKCORE_SIZEOF_DOUBLE)
+typedef double MagickRealType;
+#elif (MAGICKCORE_SIZEOF_DOUBLE_T == MAGICKCORE_SIZEOF_LONG_DOUBLE)
+typedef long double MagickRealType;
+#else
+# error Your double_t type is neither a float, nor a double, nor a long double
+#endif
+
+typedef double SignedQuantum;
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+typedef float Quantum;
+#define QuantumRange  4294967295.0
+#define QuantumFormat  "%g"
+#else
+typedef unsigned int Quantum;
+#define QuantumRange  ((Quantum) 4294967295)
+#define QuantumFormat  "%u"
+#endif
+#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
+#define MAGICKCORE_HDRI_SUPPORT
+#define MaxColormapSize  65536UL
+#define MaxMap  65535UL
+
+typedef long double MagickRealType;
+typedef double SignedQuantum;
+typedef double Quantum;
+#define QuantumRange  18446744073709551615.0
+#define QuantumFormat  "%g"
+#else
+#if !defined(_CH_)
+# error "MAGICKCORE_QUANTUM_DEPTH must be one of 8, 16, 32, or 64"
+#endif
+#endif
+#define MagickEpsilon  ((MagickRealType) 1.0e-15)
+#define MagickHuge  3.4e+38F
+#define QuantumScale  ((double) 1.0/(double) QuantumRange)
+
+/*
+  Typedef declarations.
+*/
+typedef unsigned int MagickStatusType;
+#if !defined(MAGICKCORE_WINDOWS_SUPPORT)
+#if (MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG == 8)
+typedef long long MagickOffsetType;
+typedef unsigned long long MagickSizeType;
+#define MagickOffsetFormat  "lld"
+#define MagickSizeFormat  "llu"
+#else
+typedef ssize_t MagickOffsetType;
+typedef size_t MagickSizeType;
+#define MagickOffsetFormat  "ld"
+#define MagickSizeFormat  "lu"
+#endif
+#else
+typedef __int64 MagickOffsetType;
+typedef unsigned __int64 MagickSizeType;
+#define MagickOffsetFormat  "I64i"
+#define MagickSizeFormat  "I64u"
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER == 1200)
+typedef MagickOffsetType QuantumAny;
+#else
+typedef MagickSizeType QuantumAny;
+#endif
+
+#if defined(macintosh)
+#define ExceptionInfo  MagickExceptionInfo
+#endif
+
+typedef enum
+{
+  UndefinedChannel,
+  RedChannel = 0x0001,
+  GrayChannel = 0x0001,
+  CyanChannel = 0x0001,
+  GreenChannel = 0x0002,
+  MagentaChannel = 0x0002,
+  BlueChannel = 0x0004,
+  YellowChannel = 0x0004,
+  AlphaChannel = 0x0008,
+  OpacityChannel = 0x0008,
+  MatteChannel = 0x0008,     /* deprecated */
+  BlackChannel = 0x0020,
+  IndexChannel = 0x0020,
+  CompositeChannels = 0x002F,
+  AllChannels = 0x7ffffff,
+  /*
+    Special purpose channel types.
+  */
+  TrueAlphaChannel = 0x0040, /* extract actual alpha channel from opacity */
+  RGBChannels = 0x0080,      /* set alpha from  grayscale mask in RGB */
+  GrayChannels = 0x0080,
+  SyncChannels = 0x0100,     /* channels should be modified equally */
+  DefaultChannels = ((AllChannels | SyncChannels) &~ OpacityChannel)
+} ChannelType;
+
+typedef enum
+{
+  UndefinedClass,
+  DirectClass,
+  PseudoClass
+} ClassType;
+
+typedef enum
+{
+  MagickFalse = 0,
+  MagickTrue = 1
+} MagickBooleanType;
+
+typedef struct _BlobInfo BlobInfo;
+
+typedef struct _ExceptionInfo ExceptionInfo;
+
+typedef struct _Image Image;
+
+typedef struct _ImageInfo ImageInfo;
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/magick.h

@@ -0,0 +1,143 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore magick methods.
+*/
+#ifndef _MAGICKCORE_MAGICK_H
+#define _MAGICKCORE_MAGICK_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedFormatType,
+  ImplicitFormatType,
+  ExplicitFormatType
+} MagickFormatType;
+
+typedef enum
+{
+  NoThreadSupport = 0x0000,
+  DecoderThreadSupport = 0x0001,
+  EncoderThreadSupport = 0x0002
+} MagickThreadSupport;
+
+typedef Image
+  *DecodeImageHandler(const ImageInfo *,ExceptionInfo *);
+
+typedef MagickBooleanType
+  EncodeImageHandler(const ImageInfo *,Image *);
+
+typedef MagickBooleanType
+  IsImageFormatHandler(const unsigned char *,const size_t);
+
+typedef struct _MagickInfo
+{
+  char
+    *name,
+    *description,
+    *version,
+    *note,
+    *module;
+
+  ImageInfo
+    *image_info;
+
+  DecodeImageHandler
+    *decoder;
+
+  EncodeImageHandler
+    *encoder;
+
+  IsImageFormatHandler
+    *magick;
+
+  void
+    *client_data;
+
+  MagickBooleanType
+    adjoin,
+    raw,
+    endian_support,
+    blob_support,
+    seekable_stream;
+
+  MagickFormatType
+    format_type;
+
+  MagickStatusType
+    thread_support;
+
+  MagickBooleanType
+    stealth;
+
+  struct _MagickInfo
+    *previous,
+    *next;  /* deprecated, use GetMagickInfoList() */
+
+  size_t
+    signature;
+} MagickInfo;
+
+extern MagickExport char
+  **GetMagickList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const char
+  *GetMagickDescription(const MagickInfo *);
+
+extern MagickExport DecodeImageHandler
+  *GetImageDecoder(const MagickInfo *);
+
+extern MagickExport EncodeImageHandler
+  *GetImageEncoder(const MagickInfo *);
+
+extern MagickExport int
+  GetMagickPrecision(void),
+  SetMagickPrecision(const int);
+
+extern MagickExport MagickBooleanType
+  GetImageMagick(const unsigned char *,const size_t,char *),
+  GetMagickAdjoin(const MagickInfo *),
+  GetMagickBlobSupport(const MagickInfo *),
+  GetMagickEndianSupport(const MagickInfo *),
+  GetMagickRawSupport(const MagickInfo *),
+  GetMagickSeekableStream(const MagickInfo *),
+  IsMagickInstantiated(void),
+  MagickComponentGenesis(void),
+  UnregisterMagickInfo(const char *);
+
+extern const MagickExport MagickInfo
+  *GetMagickInfo(const char *,ExceptionInfo *),
+  **GetMagickInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport MagickInfo
+  *RegisterMagickInfo(MagickInfo *),
+  *SetMagickInfo(const char *);
+
+extern MagickExport MagickStatusType
+  GetMagickThreadSupport(const MagickInfo *);
+
+extern MagickExport void
+  MagickComponentTerminus(void),
+  MagickCoreGenesis(const char *,const MagickBooleanType),
+  MagickCoreTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/matrix.h

@@ -0,0 +1,40 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore graphic resample methods.
+*/
+#ifndef _MAGICKCORE_MATRIX_H
+#define _MAGICKCORE_MATRIX_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport double
+  **AcquireMagickMatrix(const size_t,const size_t),
+  **RelinquishMagickMatrix(double **,const size_t);
+
+extern MagickExport MagickBooleanType
+  GaussJordanElimination(double **,double **,const size_t,const size_t);
+
+extern MagickExport void
+  LeastSquaresAddTerms(double **,double **,const double *,const double *,
+    const size_t, const size_t);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/memory_.h

@@ -0,0 +1,56 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore memory methods.
+*/
+#ifndef _MAGICKCORE_MEMORY_H
+#define _MAGICKCORE_MEMORY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef void
+  *(*AcquireMemoryHandler)(size_t) magick_alloc_size(1),
+  (*DestroyMemoryHandler)(void *),
+  *(*ResizeMemoryHandler)(void *,size_t) magick_alloc_size(2);
+
+extern MagickExport void
+  *AcquireAlignedMemory(const size_t,const size_t)
+    magick_attribute((__malloc__)) magick_alloc_sizes(1,2),
+  *AcquireMagickMemory(const size_t) magick_attribute((__malloc__))
+    magick_alloc_size(1),
+  *AcquireQuantumMemory(const size_t,const size_t)
+    magick_attribute((__malloc__)) magick_alloc_sizes(1,2),
+  *CopyMagickMemory(void *,const void *,const size_t)
+    magick_attribute((__nonnull__)),
+  DestroyMagickMemory(void),
+  GetMagickMemoryMethods(AcquireMemoryHandler *,ResizeMemoryHandler *,
+    DestroyMemoryHandler *),
+  *RelinquishAlignedMemory(void *),
+  *RelinquishMagickMemory(void *),
+  *ResetMagickMemory(void *,int,const size_t),
+  *ResizeMagickMemory(void *,const size_t)
+    magick_attribute((__malloc__)) magick_alloc_size(2),
+  *ResizeQuantumMemory(void *,const size_t,const size_t)
+    magick_attribute((__malloc__)) magick_alloc_sizes(2,3),
+  SetMagickMemoryMethods(AcquireMemoryHandler,ResizeMemoryHandler,
+    DestroyMemoryHandler);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/method-attribute.h

@@ -0,0 +1,141 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore method attributes.
+*/
+#ifndef _MAGICKCORE_METHOD_ATTRIBUTE_H
+#define _MAGICKCORE_METHOD_ATTRIBUTE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if defined(__BORLANDC__) && defined(_DLL)
+#  pragma message("BCBMagick lib DLL export interface")
+#  define _MAGICKDLL_
+#  define _MAGICKLIB_
+#  define MAGICKCORE_MODULES_SUPPORT
+#  undef MAGICKCORE_BUILD_MODULES
+#endif
+
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
+# define MagickPrivate
+# if defined(_MT) && defined(_DLL) && !defined(_MAGICKDLL_) && !defined(_LIB)
+#  define _MAGICKDLL_
+# endif
+# if defined(_MAGICKDLL_)
+#  if defined(_VISUALC_)
+#   pragma warning( disable: 4273 )  /* Disable the dll linkage warnings */
+#  endif
+#  if !defined(_MAGICKLIB_)
+#   if defined(__GNUC__)
+#    define MagickExport __attribute__ ((dllimport))
+#   else
+#    define MagickExport __declspec(dllimport)
+#   endif
+#   if defined(_VISUALC_)
+#    pragma message( "MagickCore lib DLL import interface" )
+#   endif
+#  else
+#   if defined(__GNUC__)
+#    define MagickExport __attribute__ ((dllexport))
+#   else
+#    define MagickExport __declspec(dllexport)
+#   endif
+#   if defined(_VISUALC_)
+#    pragma message( "MagickCore lib DLL export interface" )
+#   endif
+#  endif
+# else
+#  define MagickExport
+#  if defined(_VISUALC_)
+#   pragma message( "MagickCore lib static interface" )
+#  endif
+# endif
+
+# if defined(_DLL) && !defined(_LIB)
+#   if defined(__GNUC__)
+#    define ModuleExport __attribute__ ((dllexport))
+#   else
+#    define ModuleExport __declspec(dllexport)
+#   endif
+#  if defined(_VISUALC_)
+#   pragma message( "MagickCore module DLL export interface" )
+#  endif
+# else
+#  define ModuleExport
+#  if defined(_VISUALC_)
+#   pragma message( "MagickCore module static interface" )
+#  endif
+
+# endif
+# define MagickGlobal __declspec(thread)
+# if defined(_VISUALC_)
+#  pragma warning(disable : 4018)
+#  pragma warning(disable : 4068)
+#  pragma warning(disable : 4244)
+#  pragma warning(disable : 4142)
+#  pragma warning(disable : 4800)
+#  pragma warning(disable : 4786)
+#  pragma warning(disable : 4996)
+# endif
+#else
+# if __GNUC__ >= 4
+#  define MagickExport __attribute__ ((visibility ("default")))
+#  define MagickPrivate  __attribute__ ((visibility ("hidden")))
+# else
+#   define MagickExport
+#   define MagickPrivate
+# endif
+# define ModuleExport  MagickExport
+# define MagickGlobal
+#endif
+
+#define MagickSignature  0xabacadabUL
+#if !defined(MaxTextExtent)
+# define MaxTextExtent  4096  /* always >= 4096 */
+#endif
+
+#if defined(MAGICKCORE_HAVE___ATTRIBUTE__)
+#  define magick_aligned(x)  __attribute__((aligned(x)))
+#  define magick_attribute  __attribute__
+#  define magick_unused(x)  magick_unused_ ## x __attribute__((unused))
+#elif defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
+#  define magick_aligned(x)  __declspec(align(x))
+#  define magick_attribute(x)  /* nothing */
+#  define magick_unused(x) x
+#else
+#  define magick_aligned(x)  /* nothing */
+#  define magick_attribute(x)  /* nothing */
+#  define magick_unused(x) x
+#endif
+
+#if (((__GNUC__) > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)))
+#  define magick_alloc_size(x)  __attribute__((__alloc_size__(x)))
+#  define magick_alloc_sizes(x,y)  __attribute__((__alloc_size__(x,y)))
+#  define magick_cold_spot  __attribute__((__cold__))
+#  define magick_hot_spot  __attribute__((__hot__))
+#else
+#  define magick_alloc_size(x)  /* nothing */
+#  define magick_alloc_sizes(x,y)  /* nothing */
+#  define magick_cold_spot
+#  define magick_hot_spot
+#endif
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/mime.h

@@ -0,0 +1,52 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  The ImageMagick mime methods.
+*/
+#ifndef _MIME_MIME_H
+#define _MIME_MIME_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _MimeInfo
+  MimeInfo;
+
+extern MagickExport char
+  **GetMimeList(const char *,size_t *,ExceptionInfo *),
+  *MagickToMime(const char *);
+
+extern MagickExport const char
+  *GetMimeDescription(const MimeInfo *),
+  *GetMimeType(const MimeInfo *);
+
+extern MagickExport MagickBooleanType
+  ListMimeInfo(FILE *,ExceptionInfo *),
+  LoadMimeLists(const char *,ExceptionInfo *),
+  MimeComponentGenesis(void);
+
+extern MagickExport const MimeInfo
+  *GetMimeInfo(const char *,const unsigned char *,const size_t,ExceptionInfo *),
+  **GetMimeInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport void
+  MimeComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/module.h

@@ -0,0 +1,97 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore module methods.
+*/
+#ifndef _MAGICKCORE_MODULE_H
+#define _MAGICKCORE_MODULE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include <time.h>
+#include "magick/version.h"
+
+#define MagickImageCoderSignature  ((size_t) \
+  (((MagickLibVersion) << 8) | MAGICKCORE_QUANTUM_DEPTH))
+#define MagickImageFilterSignature  ((size_t) \
+  (((MagickLibVersion) << 8) | MAGICKCORE_QUANTUM_DEPTH))
+
+typedef enum
+{
+  MagickImageCoderModule,
+  MagickImageFilterModule
+} MagickModuleType;
+
+typedef struct _ModuleInfo
+{
+  char
+    *path,
+    *tag;
+
+  void
+    *handle,
+    (*unregister_module)(void);
+
+  size_t
+    (*register_module)(void);
+
+  time_t
+    timestamp;
+
+  MagickBooleanType
+    stealth;
+
+  struct _ModuleInfo
+    *previous,
+    *next;  /* deprecated, use GetModuleInfoList() */
+
+  size_t
+    signature;
+} ModuleInfo;
+
+typedef size_t
+  ImageFilterHandler(Image **,const int,const char **,ExceptionInfo *);
+
+extern MagickExport char
+  **GetModuleList(const char *,const MagickModuleType,size_t *,ExceptionInfo *);
+
+extern MagickExport const ModuleInfo
+  **GetModuleInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  InitializeModuleList(ExceptionInfo *),
+  InvokeDynamicImageFilter(const char *,Image **,const int,const char **,
+    ExceptionInfo *),
+  ListModuleInfo(FILE *,ExceptionInfo *),
+  ModuleComponentGenesis(void),
+  OpenModule(const char *,ExceptionInfo *),
+  OpenModules(ExceptionInfo *);
+
+extern MagickExport ModuleInfo
+  *GetModuleInfo(const char *,ExceptionInfo *);
+
+extern MagickExport void
+  DestroyModuleList(void),
+  ModuleComponentTerminus(void),
+  RegisterStaticModules(void),
+  UnregisterStaticModules(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/monitor.h

@@ -0,0 +1,49 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore progress monitor methods.
+*/
+#ifndef _MAGICKCORE_MONITOR_H
+#define _MAGICKCORE_MONITOR_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef MagickBooleanType
+  (*MagickProgressMonitor)(const char *,const MagickOffsetType,
+    const MagickSizeType,void *);
+
+MagickExport MagickProgressMonitor
+  SetImageProgressMonitor(Image *,const MagickProgressMonitor,void *),
+  SetImageInfoProgressMonitor(ImageInfo *,const MagickProgressMonitor,void *);
+
+static inline MagickBooleanType QuantumTick(const MagickOffsetType offset,
+  const MagickSizeType span)
+{
+  if (span <= 100)
+    return(MagickTrue);
+  if (offset == (MagickOffsetType) (span-1))
+    return(MagickTrue);
+  if ((offset % (span/100)) == 0)
+    return(MagickTrue);
+  return(MagickFalse);
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/montage.h

@@ -0,0 +1,88 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore montage methods.
+*/
+#ifndef _MAGICKCORE_MONTAGE_H
+#define _MAGICKCORE_MONTAGE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedMode,
+  FrameMode,
+  UnframeMode,
+  ConcatenateMode
+} MontageMode;
+
+typedef struct _MontageInfo
+{
+  char
+    *geometry,
+    *tile,
+    *title,
+    *frame,
+    *texture,
+    *font;
+
+  double
+    pointsize;
+
+  size_t
+    border_width;
+
+  MagickBooleanType
+    shadow;
+
+  PixelPacket
+    fill,
+    stroke,
+    background_color,
+    border_color,
+    matte_color;
+
+  GravityType
+    gravity;
+
+  char
+    filename[MaxTextExtent];
+
+  MagickBooleanType
+    debug;
+
+  size_t
+    signature;
+} MontageInfo;
+
+extern MagickExport Image
+  *MontageImages(const Image *,const MontageInfo *,ExceptionInfo *),
+  *MontageImageList(const ImageInfo *,const MontageInfo *,const Image *,
+    ExceptionInfo *);
+
+extern MagickExport MontageInfo
+  *CloneMontageInfo(const ImageInfo *,const MontageInfo *),
+  *DestroyMontageInfo(MontageInfo *);
+
+extern MagickExport void
+  GetMontageInfo(const ImageInfo *,MontageInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/morphology.h

@@ -0,0 +1,151 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore morphology methods.
+*/
+#ifndef _MAGICKCORE_MORPHOLOGY_H
+#define _MAGICKCORE_MORPHOLOGY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/geometry.h"
+
+typedef enum
+{
+  UndefinedKernel,    /* equivalent to UnityKernel */
+  UnityKernel,        /* The no-op or 'original image' kernel */
+  GaussianKernel,     /* Convolution Kernels, Gaussian Based */
+  DoGKernel,
+  LoGKernel,
+  BlurKernel,
+  CometKernel,
+  LaplacianKernel,    /* Convolution Kernels, by Name */
+  SobelKernel,
+  FreiChenKernel,
+  RobertsKernel,
+  PrewittKernel,
+  CompassKernel,
+  KirschKernel,
+  DiamondKernel,      /* Shape Kernels */
+  SquareKernel,
+  RectangleKernel,
+  OctagonKernel,
+  DiskKernel,
+  PlusKernel,
+  CrossKernel,
+  RingKernel,
+  PeaksKernel,         /* Hit And Miss Kernels */
+  EdgesKernel,
+  CornersKernel,
+  DiagonalsKernel,
+  LineEndsKernel,
+  LineJunctionsKernel,
+  RidgesKernel,
+  ConvexHullKernel,
+  ThinSEKernel,
+  SkeletonKernel,
+  ChebyshevKernel,    /* Distance Measuring Kernels */
+  ManhattanKernel,
+  OctagonalKernel,
+  EuclideanKernel,
+  UserDefinedKernel,   /* User Specified Kernel Array */
+  BinomialKernel
+} KernelInfoType;
+
+typedef enum
+{
+  UndefinedMorphology,
+/* Convolve / Correlate weighted sums */
+  ConvolveMorphology,           /* Weighted Sum with reflected kernel */
+  CorrelateMorphology,          /* Weighted Sum using a sliding window */
+/* Low-level Morphology methods */
+  ErodeMorphology,              /* Minimum Value in Neighbourhood */
+  DilateMorphology,             /* Maximum Value in Neighbourhood */
+  ErodeIntensityMorphology,     /* Pixel Pick using GreyScale Erode */
+  DilateIntensityMorphology,    /* Pixel Pick using GreyScale Dialate */
+  DistanceMorphology,           /* Add Kernel Value, take Minimum */
+/* Second-level Morphology methods */
+  OpenMorphology,               /* Dilate then Erode */
+  CloseMorphology,              /* Erode then Dilate */
+  OpenIntensityMorphology,      /* Pixel Pick using GreyScale Open */
+  CloseIntensityMorphology,     /* Pixel Pick using GreyScale Close */
+  SmoothMorphology,             /* Open then Close */
+/* Difference Morphology methods */
+  EdgeInMorphology,             /* Dilate difference from Original */
+  EdgeOutMorphology,            /* Erode difference from Original */
+  EdgeMorphology,               /* Dilate difference with Erode */
+  TopHatMorphology,             /* Close difference from Original */
+  BottomHatMorphology,          /* Open difference from Original */
+/* Recursive Morphology methods */
+  HitAndMissMorphology,         /* Foreground/Background pattern matching */
+  ThinningMorphology,           /* Remove matching pixels from image */
+  ThickenMorphology,            /* Add matching pixels from image */
+/* Experimental Morphology methods */
+  VoronoiMorphology,            /* distance matte channel copy nearest color */
+  IterativeDistanceMorphology   /* Add Kernel Value, take Minimum */
+} MorphologyMethod;
+
+typedef struct KernelInfo
+{
+  KernelInfoType
+    type;
+
+  size_t
+    width,
+    height;
+
+  ssize_t
+    x,
+    y;
+
+  double
+    *values,
+    minimum,
+    maximum,
+    negative_range,
+    positive_range,
+    angle;
+
+  struct KernelInfo
+    *next;
+
+  size_t
+    signature;
+} KernelInfo;
+
+
+extern MagickExport KernelInfo
+  *AcquireKernelInfo(const char *),
+  *AcquireKernelBuiltIn(const KernelInfoType,const GeometryInfo *),
+  *CloneKernelInfo(const KernelInfo *),
+  *DestroyKernelInfo(KernelInfo *);
+
+extern MagickExport Image
+  *MorphologyImage(const Image *,const MorphologyMethod,const ssize_t,
+    const KernelInfo *,ExceptionInfo *),
+  *MorphologyImageChannel(const Image *,const ChannelType,
+    const MorphologyMethod,const ssize_t,const KernelInfo *,ExceptionInfo *);
+
+extern MagickExport void
+  ScaleGeometryKernelInfo(KernelInfo *,const char *),
+  ShowKernelInfo(const KernelInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/option.h

@@ -0,0 +1,178 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore option methods.
+*/
+#ifndef _MAGICKCORE_OPTION_H
+#define _MAGICKCORE_OPTION_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  MagickUndefinedOptions = -1,
+  MagickAlignOptions = 0,
+  MagickAlphaOptions,
+  MagickBooleanOptions,
+  MagickCacheOptions,
+  MagickChannelOptions,
+  MagickClassOptions,
+  MagickClipPathOptions,
+  MagickCoderOptions,
+  MagickColorOptions,
+  MagickColorspaceOptions,
+  MagickCommandOptions,
+  MagickComposeOptions,
+  MagickCompressOptions,
+  MagickConfigureOptions,
+  MagickDataTypeOptions,
+  MagickDebugOptions,
+  MagickDecorateOptions,
+  MagickDelegateOptions,
+  MagickDirectionOptions,
+  MagickDisposeOptions,
+  MagickDistortOptions,
+  MagickDitherOptions,
+  MagickEndianOptions,
+  MagickEvaluateOptions,
+  MagickFillRuleOptions,
+  MagickFilterOptions,
+  MagickFontOptions,
+  MagickFontsOptions,
+  MagickFormatOptions,
+  MagickFunctionOptions,
+  MagickGravityOptions,
+  MagickIntentOptions,
+  MagickInterlaceOptions,
+  MagickInterpolateOptions,
+  MagickKernelOptions,
+  MagickLayerOptions,
+  MagickLineCapOptions,
+  MagickLineJoinOptions,
+  MagickListOptions,
+  MagickLocaleOptions,
+  MagickLogEventOptions,
+  MagickLogOptions,
+  MagickMagicOptions,
+  MagickMethodOptions,
+  MagickMetricOptions,
+  MagickMimeOptions,
+  MagickModeOptions,
+  MagickModuleOptions,
+  MagickMorphologyOptions,
+  MagickNoiseOptions,
+  MagickOrientationOptions,
+  MagickPolicyOptions,
+  MagickPolicyDomainOptions,
+  MagickPolicyRightsOptions,
+  MagickPreviewOptions,
+  MagickPrimitiveOptions,
+  MagickQuantumFormatOptions,
+  MagickResolutionOptions,
+  MagickResourceOptions,
+  MagickSparseColorOptions,
+  MagickStatisticOptions,
+  MagickStorageOptions,
+  MagickStretchOptions,
+  MagickStyleOptions,
+  MagickThresholdOptions,
+  MagickTypeOptions,
+  MagickValidateOptions,
+  MagickVirtualPixelOptions
+} CommandOption;
+
+typedef enum
+{
+  UndefinedValidate,
+  NoValidate = 0x00000,
+  CompareValidate = 0x00001,
+  CompositeValidate = 0x00002,
+  ConvertValidate = 0x00004,
+  FormatsInMemoryValidate = 0x00008,
+  FormatsOnDiskValidate = 0x00010,
+  IdentifyValidate = 0x00020,
+  ImportExportValidate = 0x00040,
+  MontageValidate = 0x00080,
+  StreamValidate = 0x00100,
+  AllValidate = 0x7fffffff
+} ValidateType;
+
+typedef struct _OptionInfo
+{
+  const char
+    *mnemonic;
+
+  ssize_t
+    type,
+    flags;
+
+  MagickBooleanType
+    stealth;
+} OptionInfo;
+
+/*
+  Flags to describe classes of image processing options.
+*/
+typedef enum
+{
+  UndefinedOptionFlag       = 0x0000,
+  FireOptionFlag            = 0x0001,  /* Option sequence firing point */
+  ImageInfoOptionFlag       = 0x0002,  /* Sets ImageInfo, no image needed */
+  DrawInfoOptionFlag        = 0x0004,  /* Sets DrawInfo, no image needed */
+  QuantizeInfoOptionFlag    = 0x0008,  /* Sets QuantizeInfo, no image needed */
+  GlobalOptionFlag          = 0x0010,  /* Sets Global Option, no image needed */
+  SimpleOperatorOptionFlag  = 0x0100,  /* Simple Image processing operator */
+  ListOperatorOptionFlag    = 0x0200,  /* Multi-Image List processing operator */
+  SpecialOperatorOptionFlag = 0x0400,  /* Specially handled Operator Option */
+  GenesisOptionFlag         = 0x0400,  /* Genesis Command Wrapper Option  */
+  NonConvertOptionFlag      = 0x4000,  /* Option not used by Convert */
+  DeprecateOptionFlag       = 0x8000   /* Deprecate option, give warning */
+} CommandOptionFlags;
+
+extern MagickExport char
+  **GetCommandOptions(const CommandOption),
+  *GetNextImageOption(const ImageInfo *),
+  *RemoveImageOption(ImageInfo *,const char *);
+
+extern MagickExport const char
+  *CommandOptionToMnemonic(const CommandOption,const ssize_t),
+  *GetImageOption(const ImageInfo *,const char *);
+
+extern MagickExport MagickBooleanType
+  CloneImageOptions(ImageInfo *,const ImageInfo *),
+  DefineImageOption(ImageInfo *,const char *),
+  DeleteImageOption(ImageInfo *,const char *),
+  IsCommandOption(const char *),
+  ListCommandOptions(FILE *,const CommandOption,ExceptionInfo *),
+  SetImageOption(ImageInfo *,const char *,const char *);
+
+extern MagickExport ssize_t
+  GetCommandOptionFlags(const CommandOption,const MagickBooleanType,
+    const char *),
+  ParseChannelOption(const char *),
+  ParseCommandOption(const CommandOption,const MagickBooleanType,const char *);
+
+extern MagickExport void
+  DestroyImageOptions(ImageInfo *),
+  ResetImageOptions(const ImageInfo *),
+  ResetImageOptionIterator(const ImageInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/paint.h

@@ -0,0 +1,50 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image paint methods.
+*/
+#ifndef _MAGICKCORE_PAINT_H
+#define _MAGICKCORE_PAINT_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/color.h"
+#include "magick/draw.h"
+
+extern MagickExport Image
+  *OilPaintImage(const Image *,const double,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  FloodfillPaintImage(Image *,const ChannelType,const DrawInfo *,
+    const MagickPixelPacket *,const ssize_t,const ssize_t,
+    const MagickBooleanType),
+  GradientImage(Image *,const GradientType,const SpreadMethod,
+    const PixelPacket *,const PixelPacket *),
+  OpaquePaintImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *,
+    const MagickBooleanType),
+  OpaquePaintImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
+    const MagickPixelPacket *,const MagickBooleanType),
+  TransparentPaintImage(Image *,const MagickPixelPacket *,
+    const Quantum,const MagickBooleanType),
+  TransparentPaintImageChroma(Image *,const MagickPixelPacket *,
+    const MagickPixelPacket *,const Quantum,const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/pixel-accessor.h

@@ -0,0 +1,181 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore pixel accessor methods.
+*/
+#ifndef _MAGICKCORE_PIXEL_ACCESSOR_H
+#define _MAGICKCORE_PIXEL_ACCESSOR_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include <math.h>
+#include "magick/gem.h"
+#include "magick/pixel.h"
+
+#define ClampPixelRed(pixel) ClampToQuantum((pixel)->red)
+#define ClampPixelGreen(pixel) ClampToQuantum((pixel)->green)
+#define ClampPixelBlue(pixel) ClampToQuantum((pixel)->blue)
+#define ClampPixelIndex(indexes) ClampToQuantum(*(indexes))
+#define ClampPixelOpacity(pixel) ClampToQuantum((pixel)->opacity)
+#define GetPixela(pixel) ((pixel)->green)
+#define GetPixelb(pixel) ((pixel)->blue)
+#define GetPixelAlpha(pixel) (QuantumRange-(pixel)->opacity)
+#define GetPixelBlack(indexes) (*(indexes))
+#define GetPixelBlue(pixel) ((pixel)->blue)
+#define GetPixelCb(pixel) ((pixel)->green)
+#define GetPixelCr(pixel) ((pixel)->blue)
+#define GetPixelCyan(pixel) ((pixel)->red)
+#define GetPixelGray(pixel) ((pixel)->red)
+#define GetPixelGreen(pixel) ((pixel)->green)
+#define GetPixelIndex(indexes) (*(indexes))
+#define GetPixelL(pixel) ((pixel)->red)
+#define GetPixelMagenta(pixel) ((pixel)->green)
+#define GetPixelNext(pixel)  ((pixel)+1)
+#define GetPixelOpacity(pixel) ((pixel)->opacity)
+#define GetPixelRed(pixel) ((pixel)->red)
+#define GetPixelRGB(pixel,packet) \
+{ \
+  (packet)->red=GetPixelRed((pixel)); \
+  (packet)->green=GetPixelGreen((pixel)); \
+  (packet)->blue=GetPixelBlue((pixel)); \
+}
+#define GetPixelRGBO(pixel,packet) \
+{ \
+  (packet)->red=GetPixelRed((pixel)); \
+  (packet)->green=GetPixelGreen((pixel)); \
+  (packet)->blue=GetPixelBlue((pixel)); \
+  (packet)->opacity=GetPixelOpacity((pixel)); \
+}
+#define GetPixelY(pixel) ((pixel)->red)
+#define GetPixelYellow(pixel) ((pixel)->blue)
+#define SetPixela(pixel,value) ((pixel)->green=(Quantum) (value))
+#define SetPixelAlpha(pixel,value) \
+  ((pixel)->opacity=(Quantum) (QuantumRange-(value)))
+#define SetPixelb(pixel,value) ((pixel)->blue=(Quantum) (value))
+#define SetPixelBlack(indexes,value) (*(indexes)=(Quantum) (value))
+#define SetPixelBlue(pixel,value) ((pixel)->blue=(Quantum) (value))
+#define SetPixelCb(pixel,value) ((pixel)->green=(Quantum) (value))
+#define SetPixelCr(pixel,value) ((pixel)->blue=(Quantum) (value))
+#define SetPixelCyan(pixel,value) ((pixel)->red=(Quantum) (value))
+#define SetPixelGray(pixel,value) \
+  ((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
+#define SetPixelGreen(pixel,value) ((pixel)->green=(Quantum) (value))
+#define SetPixelIndex(indexes,value) (*(indexes)=(IndexPacket) (value))
+#define SetPixelL(pixel,value) ((pixel)->red=(Quantum) (value))
+#define SetPixelMagenta(pixel,value) ((pixel)->green=(Quantum) (value))
+#define SetPixelOpacity(pixel,value) \
+  ((pixel)->opacity=(Quantum) (value))
+#define SetPixelRed(pixel,value) ((pixel)->red=(Quantum) (value))
+#define SetPixelRgb(pixel,packet) \
+{ \
+  SetPixelRed(pixel,(packet)->red); \
+  SetPixelGreen(pixel,(packet)->green); \
+  SetPixelBlue(pixel,(packet)->blue); \
+}
+#define SetPixelRGBA(pixel,packet) \
+{ \
+  SetPixelRed(pixel,(packet)->red); \
+  SetPixelGreen(pixel,(packet)->green); \
+  SetPixelBlue(pixel,(packet)->blue); \
+  SetPixelAlpha(pixel,(QuantumRange-(packet)->opacity)); \
+}
+#define SetPixelRGBO(pixel,packet) \
+{ \
+  SetPixelRed(pixel,(packet)->red); \
+  SetPixelGreen(pixel,(packet)->green); \
+  SetPixelBlue(pixel,(packet)->blue); \
+  SetPixelOpacity(pixel,(packet)->opacity); \
+}
+#define SetPixelYellow(pixel,value) ((pixel)->blue=(Quantum) (value))
+#define SetPixelY(pixel,value) ((pixel)->red=(Quantum) (value))
+
+static inline MagickRealType GetPixelIntensity(const Image *image,
+  const PixelPacket *pixel)
+{
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  if (image->colorspace == GRAYColorspace)
+    return((MagickRealType) pixel->red);
+  if (image->colorspace != sRGBColorspace)
+    return(0.298839f*pixel->red+0.586811f*pixel->green+0.114350f*pixel->blue);
+  red=DecodePixelGamma((MagickRealType) pixel->red);
+  green=DecodePixelGamma((MagickRealType) pixel->green);
+  blue=DecodePixelGamma((MagickRealType) pixel->blue);
+  return((MagickRealType) (0.298839f*red+0.586811f*green+0.114350f*blue));
+}
+
+static inline MagickRealType AbsolutePixelValue(const MagickRealType x)
+{
+  return(x < 0.0f ? -x : x);
+}
+
+static inline MagickBooleanType IsPixelGray(const PixelPacket *pixel)
+{
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  red=(MagickRealType) pixel->red;
+  green=(MagickRealType) pixel->green;
+  blue=(MagickRealType) pixel->blue;
+  if ((AbsolutePixelValue(red-green) < MagickEpsilon) &&
+      (AbsolutePixelValue(green-blue) < MagickEpsilon))
+    return(MagickTrue);
+  return(MagickFalse);
+}
+
+static inline Quantum PixelPacketIntensity(const PixelPacket *pixel)
+{
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  red=DecodePixelGamma((MagickRealType) pixel->red);
+  green=DecodePixelGamma((MagickRealType) pixel->green);
+  blue=DecodePixelGamma((MagickRealType) pixel->blue);
+  return(ClampToQuantum(0.298839f*red+0.586811f*green+0.114350f*blue));
+}
+
+static inline Quantum PixelIntensityToQuantum(const Image *restrict image,
+  const PixelPacket *restrict pixel)
+{
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  if (image->colorspace == GRAYColorspace)
+    return(GetPixelGray(pixel));
+  if (image->colorspace != sRGBColorspace)
+    return(ClampToQuantum(0.298839f*pixel->red+0.586811f*pixel->green+0.114350f*
+      pixel->blue));
+  red=DecodePixelGamma((MagickRealType) pixel->red);
+  green=DecodePixelGamma((MagickRealType) pixel->green);
+  blue=DecodePixelGamma((MagickRealType) pixel->blue);
+  return(ClampToQuantum(0.298839f*red+0.586811f*green+0.114350f*blue));
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/pixel.h

@@ -0,0 +1,166 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image constitute methods.
+*/
+#ifndef _MAGICKCORE_PIXEL_H
+#define _MAGICKCORE_PIXEL_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/colorspace.h"
+#include "magick/constitute.h"
+
+typedef enum
+{
+  UndefinedInterpolatePixel,
+  AverageInterpolatePixel,           /* Average 4 nearest neighbours */
+  BicubicInterpolatePixel,           /* Catmull-Rom interpolation */
+  BilinearInterpolatePixel,          /* Triangular filter interpolation */
+  FilterInterpolatePixel,            /* Use resize filter - (very slow) */
+  IntegerInterpolatePixel,           /* Integer (floor) interpolation */
+  MeshInterpolatePixel,              /* Triangular mesh interpolation */
+  NearestNeighborInterpolatePixel,   /* Nearest neighbour only */
+  SplineInterpolatePixel,            /* Cubic Spline (blurred) interpolation */
+  Average9InterpolatePixel,          /* Average 9 nearest neighbours */
+  Average16InterpolatePixel,         /* Average 16 nearest neighbours */
+  BlendInterpolatePixel,             /* blend of nearest 1, 2 or 4 pixels */
+  BackgroundInterpolatePixel,        /* just return background color */
+  CatromInterpolatePixel             /* Catmull-Rom interpolation */
+} InterpolatePixelMethod;
+
+typedef enum
+{
+  PixelRed = 0,
+  PixelCyan = 0,
+  PixelGray = 0,
+  PixelY = 0,
+  PixelGreen = 1,
+  PixelMagenta = 1,
+  PixelCb = 1,
+  PixelBlue = 2,
+  PixelYellow = 2,
+  PixelCr = 2,
+  PixelAlpha = 3,
+  PixelBlack = 4,
+  PixelIndex = 4,
+  MaskPixelComponent = 5
+} PixelComponent;
+
+typedef struct _DoublePixelPacket
+{
+  double
+    red,
+    green,
+    blue,
+    opacity,
+    index;
+} DoublePixelPacket;
+
+typedef struct _LongPixelPacket
+{
+  unsigned int
+    red,
+    green,
+    blue,
+    opacity,
+    index;
+} LongPixelPacket;
+
+typedef struct _MagickPixelPacket
+{
+  ClassType
+    storage_class;
+
+  ColorspaceType
+    colorspace;
+
+  MagickBooleanType
+    matte;
+
+  double
+    fuzz;
+
+  size_t
+    depth;
+
+  MagickRealType
+    red,
+    green,
+    blue,
+    opacity,
+    index;
+} MagickPixelPacket;
+
+typedef Quantum IndexPacket;
+
+typedef struct _PixelPacket
+{
+#if defined(MAGICKCORE_WORDS_BIGENDIAN)
+#define MAGICK_PIXEL_RGBA  1
+  Quantum
+    red,
+    green,
+    blue,
+    opacity;
+#else
+#define MAGICK_PIXEL_BGRA  1
+  Quantum
+    blue,
+    green,
+    red,
+    opacity;
+#endif
+} PixelPacket;
+
+typedef struct _QuantumPixelPacket
+{
+  Quantum
+    red,
+    green,
+    blue,
+    opacity,
+    index;
+} QuantumPixelPacket;
+
+typedef struct _CacheView
+  CacheView_;
+
+extern MagickExport MagickBooleanType
+  ExportImagePixels(const Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,const char *,const StorageType,void *,ExceptionInfo *),
+  ImportImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,const char *,const StorageType,const void *),
+  InterpolateMagickPixelPacket(const Image *,const CacheView_ *,
+    const InterpolatePixelMethod,const double,const double,MagickPixelPacket *,
+    ExceptionInfo *);
+
+extern MagickExport MagickPixelPacket
+  *CloneMagickPixelPacket(const MagickPixelPacket *);
+
+extern MagickExport MagickRealType
+  DecodePixelGamma(const MagickRealType) magick_hot_spot,
+  EncodePixelGamma(const MagickRealType) magick_hot_spot;
+
+extern MagickExport void
+  GetMagickPixelPacket(const Image *,MagickPixelPacket *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/policy.h

@@ -0,0 +1,70 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image color methods.
+*/
+#ifndef _MAGICKCORE_POLICY_H
+#define _MAGICKCORE_POLICY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/pixel.h"
+#include "magick/exception.h"
+
+typedef enum
+{
+  UndefinedPolicyDomain,
+  CoderPolicyDomain,
+  DelegatePolicyDomain,
+  FilterPolicyDomain,
+  PathPolicyDomain,
+  ResourcePolicyDomain,
+  SystemPolicyDomain
+} PolicyDomain;
+
+typedef enum
+{
+  UndefinedPolicyRights = 0x00,
+  NoPolicyRights = 0x00,
+  ReadPolicyRights = 0x01,
+  WritePolicyRights = 0x02,
+  ExecutePolicyRights = 0x04
+} PolicyRights;
+
+typedef struct _PolicyInfo
+  PolicyInfo;
+
+extern MagickExport char
+  *GetPolicyValue(const char *name),
+  **GetPolicyList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const PolicyInfo
+  **GetPolicyInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  IsRightsAuthorized(const PolicyDomain,const PolicyRights,const char *),
+  ListPolicyInfo(FILE *,ExceptionInfo *),
+  PolicyComponentGenesis(void);
+
+extern MagickExport void
+  PolicyComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/prepress.h

@@ -0,0 +1,32 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore prepress methods.
+*/
+#ifndef _MAGICKCORE_PREPRESS_H
+#define _MAGICKCORE_PREPRESS_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport double
+  GetImageTotalInkDensity(Image *image);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/profile.h

@@ -0,0 +1,75 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image profile methods.
+*/
+#ifndef _MAGICKCORE_PROFILE_H
+#define _MAGICKCORE_PROFILE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/string_.h"
+
+typedef struct _ProfileInfo
+{
+  char
+    *name;
+
+  size_t
+    length;
+
+  unsigned char
+    *info;
+
+  size_t
+    signature;
+} ProfileInfo;
+
+typedef enum
+{
+  UndefinedIntent,
+  SaturationIntent,
+  PerceptualIntent,
+  AbsoluteIntent,
+  RelativeIntent
+} RenderingIntent;
+
+extern MagickExport char
+  *GetNextImageProfile(const Image *);
+
+extern MagickExport const StringInfo
+  *GetImageProfile(const Image *,const char *);
+
+extern MagickExport MagickBooleanType
+  CloneImageProfiles(Image *,const Image *),
+  DeleteImageProfile(Image *,const char *),
+  ProfileImage(Image *,const char *,const void *,const size_t,
+    const MagickBooleanType),
+  SetImageProfile(Image *,const char *,const StringInfo *),
+  SyncImageProfiles(Image *);
+
+extern MagickExport StringInfo
+  *RemoveImageProfile(Image *,const char *);
+
+extern MagickExport void
+  DestroyImageProfiles(Image *),
+  ResetImageProfileIterator(const Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif 
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/property.h

@@ -0,0 +1,50 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore property methods.
+*/
+#ifndef _MAGICKCORE_PROPERTY_H
+#define _MAGICKCORE_PROPERTY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport char
+  *GetNextImageProperty(const Image *),
+  *InterpretImageProperties(const ImageInfo *,Image *,const char *),
+  *RemoveImageProperty(Image *,const char *);
+
+extern MagickExport const char
+  *GetImageProperty(const Image *,const char *),
+  *GetMagickProperty(const ImageInfo *,Image *,const char *);
+
+extern MagickExport MagickBooleanType
+  CloneImageProperties(Image *,const Image *),
+  DefineImageProperty(Image *,const char *),
+  DeleteImageProperty(Image *,const char *),
+  FormatImageProperty(Image *,const char *,const char *,...)
+    magick_attribute((__format__ (__printf__,3,4))),
+  SetImageProperty(Image *,const char *,const char *);
+
+extern MagickExport void
+  DestroyImageProperties(Image *),
+  ResetImagePropertyIterator(const Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/quantize.h

@@ -0,0 +1,82 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image quantization methods.
+*/
+#ifndef _MAGICKCORE_QUANTIZE_H
+#define _MAGICKCORE_QUANTIZE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/colorspace.h"
+
+typedef enum
+{
+  UndefinedDitherMethod,
+  NoDitherMethod,
+  RiemersmaDitherMethod,
+  FloydSteinbergDitherMethod
+} DitherMethod;
+
+typedef struct _QuantizeInfo
+{
+  size_t
+    number_colors;
+
+  size_t
+    tree_depth;
+
+  MagickBooleanType
+    dither;
+
+  ColorspaceType
+    colorspace;
+
+  MagickBooleanType
+    measure_error;
+
+  size_t
+    signature;
+
+  DitherMethod
+    dither_method;
+} QuantizeInfo;
+
+extern MagickExport MagickBooleanType
+  CompressImageColormap(Image *),
+  GetImageQuantizeError(Image *),
+  PosterizeImage(Image *,const size_t,const MagickBooleanType),
+  PosterizeImageChannel(Image *,const ChannelType,const size_t,
+    const MagickBooleanType),
+  QuantizeImage(const QuantizeInfo *,Image *),
+  QuantizeImages(const QuantizeInfo *,Image *),
+  RemapImage(const QuantizeInfo *,Image *,const Image *),
+  RemapImages(const QuantizeInfo *,Image *,const Image *);
+
+extern MagickExport QuantizeInfo
+  *AcquireQuantizeInfo(const ImageInfo *),
+  *CloneQuantizeInfo(const QuantizeInfo *),
+  *DestroyQuantizeInfo(QuantizeInfo *);
+
+extern MagickExport void
+  GetQuantizeInfo(QuantizeInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/quantum.h

@@ -0,0 +1,197 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore quantum inline methods.
+*/
+#ifndef _MAGICKCORE_QUANTUM_H
+#define _MAGICKCORE_QUANTUM_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/image.h"
+#include "magick/semaphore.h"
+
+#define RoundToQuantum(quantum)  ClampToQuantum(quantum)
+
+typedef enum
+{
+  UndefinedEndian,
+  LSBEndian,
+  MSBEndian
+} EndianType;
+
+typedef enum
+{
+  UndefinedQuantumAlpha,
+  AssociatedQuantumAlpha,
+  DisassociatedQuantumAlpha
+} QuantumAlphaType;
+
+typedef enum
+{
+  UndefinedQuantumFormat,
+  FloatingPointQuantumFormat,
+  SignedQuantumFormat,
+  UnsignedQuantumFormat
+} QuantumFormatType;
+
+typedef enum
+{
+  UndefinedQuantum,
+  AlphaQuantum,
+  BlackQuantum,
+  BlueQuantum,
+  CMYKAQuantum,
+  CMYKQuantum,
+  CyanQuantum,
+  GrayAlphaQuantum,
+  GrayQuantum,
+  GreenQuantum,
+  IndexAlphaQuantum,
+  IndexQuantum,
+  MagentaQuantum,
+  OpacityQuantum,
+  RedQuantum,
+  RGBAQuantum,
+  BGRAQuantum,
+  RGBOQuantum,
+  RGBQuantum,
+  YellowQuantum,
+  GrayPadQuantum,  /* deprecated */
+  RGBPadQuantum,
+  CbYCrYQuantum,
+  CbYCrQuantum,
+  CbYCrAQuantum,
+  CMYKOQuantum,
+  BGRQuantum,
+  BGROQuantum
+} QuantumType;
+
+typedef struct _QuantumInfo
+  QuantumInfo;
+
+static inline Quantum ClampToQuantum(const MagickRealType value)
+{
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+  return((Quantum) value);
+#else
+  if (value <= 0.0f)
+    return((Quantum) 0);
+  if (value >= (MagickRealType) QuantumRange)
+    return(QuantumRange);
+  return((Quantum) (value+0.5f));
+#endif
+}
+
+#if (MAGICKCORE_QUANTUM_DEPTH == 8)
+static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((unsigned char) quantum);
+#else
+  if (quantum <= 0.0)
+    return(0);
+  if (quantum >= 255.0)
+    return(255);
+  return((unsigned char) (quantum+0.5));
+#endif
+}
+#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
+static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((unsigned char) (((quantum+128UL)-((quantum+128UL) >> 8)) >> 8));
+#else
+  if (quantum <= 0.0)
+    return(0);
+  if ((quantum/257.0) >= 255.0)
+    return(255);
+  return((unsigned char) (quantum/257.0+0.5));
+#endif
+}
+#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
+static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((unsigned char) ((quantum+MagickULLConstant(8421504))/
+    MagickULLConstant(16843009)));
+#else
+  if (quantum <= 0.0)
+    return(0);
+  if ((quantum/16843009.0) >= 255.0)
+    return(255);
+  return((unsigned char) (quantum/16843009.0+0.5));
+#endif
+}
+#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
+static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((unsigned char) (quantum/72340172838076673.0+0.5));
+#else
+  if (quantum <= 0.0)
+    return(0);
+  if ((quantum/72340172838076673.0) >= 255.0)
+    return(255);
+  return((unsigned char) (quantum/72340172838076673.0+0.5));
+#endif
+}
+#endif
+
+extern MagickExport EndianType
+  GetQuantumEndian(const QuantumInfo *);
+
+extern MagickExport MagickBooleanType
+  SetQuantumDepth(const Image *,QuantumInfo *,const size_t),
+  SetQuantumEndian(const Image *,QuantumInfo *,const EndianType),
+  SetQuantumFormat(const Image *,QuantumInfo *,const QuantumFormatType),
+  SetQuantumPad(const Image *,QuantumInfo *,const size_t);
+
+extern MagickExport QuantumFormatType
+  GetQuantumFormat(const QuantumInfo *);
+
+extern MagickExport QuantumInfo
+  *AcquireQuantumInfo(const ImageInfo *,Image *),
+  *DestroyQuantumInfo(QuantumInfo *);
+
+extern MagickExport QuantumType
+  GetQuantumType(Image *,ExceptionInfo *);
+
+extern MagickExport size_t
+  ExportQuantumPixels(const Image *,const CacheView *,const QuantumInfo *,
+    const QuantumType,unsigned char *,ExceptionInfo *),
+  GetQuantumExtent(const Image *,const QuantumInfo *,const QuantumType),
+  ImportQuantumPixels(Image *,CacheView *,const QuantumInfo *,const QuantumType,
+    const unsigned char *,ExceptionInfo *);
+
+extern MagickExport unsigned char
+  *GetQuantumPixels(const QuantumInfo *);
+
+extern MagickExport void
+  GetQuantumInfo(const ImageInfo *,QuantumInfo *),
+  SetQuantumAlphaType(QuantumInfo *,const QuantumAlphaType),
+  SetQuantumImageType(Image *,const QuantumType),
+  SetQuantumMinIsWhite(QuantumInfo *,const MagickBooleanType),
+  SetQuantumPack(QuantumInfo *,const MagickBooleanType),
+  SetQuantumQuantum(QuantumInfo *,const size_t),
+  SetQuantumScale(QuantumInfo *,const double);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/random_.h

@@ -0,0 +1,64 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore random methods.
+*/
+#ifndef _MAGICKCORE_RANDOM__H
+#define _MAGICKCORE_RANDOM__H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/string_.h"
+
+/*
+  Typedef declarations.
+*/
+typedef struct _RandomInfo
+  RandomInfo;
+
+/*
+  Method declarations.
+*/
+extern MagickExport double
+  GetRandomValue(RandomInfo *),
+  GetPseudoRandomValue(RandomInfo *);
+
+extern MagickExport MagickBooleanType
+  RandomComponentGenesis(void);
+
+extern MagickExport RandomInfo
+  *AcquireRandomInfo(void),
+  *DestroyRandomInfo(RandomInfo *);
+
+extern MagickExport StringInfo
+  *GetRandomKey(RandomInfo *,const size_t);
+
+extern MagickExport unsigned long
+  GetRandomSecretKey(const RandomInfo *);
+
+extern MagickExport void
+  RandomComponentTerminus(void),
+  SeedPseudoRandomGenerator(const unsigned long),
+  SetRandomKey(RandomInfo *,const size_t,unsigned char *),
+  SetRandomSecretKey(const unsigned long),
+  SetRandomTrueRandom(const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/registry.h

@@ -0,0 +1,53 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore registry methods.
+*/
+#ifndef _MAGICKCORE_REGISTRY_H
+#define _MAGICKCORE_REGISTRY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedRegistryType,
+  ImageRegistryType,
+  ImageInfoRegistryType,
+  StringRegistryType
+} RegistryType;
+
+extern MagickExport char
+  *GetNextImageRegistry(void);
+
+extern MagickExport MagickBooleanType
+  DefineImageRegistry(const RegistryType,const char *,ExceptionInfo *),
+  DeleteImageRegistry(const char *),
+  RegistryComponentGenesis(void),
+  SetImageRegistry(const RegistryType,const char *,const void *,
+    ExceptionInfo *);
+
+extern MagickExport void
+  *GetImageRegistry(const RegistryType,const char *,ExceptionInfo *),
+  RegistryComponentTerminus(void),
+  *RemoveImageRegistry(const char *),
+  ResetImageRegistryIterator(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/resample.h

@@ -0,0 +1,99 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore graphic resample methods.
+*/
+#ifndef _MAGICKCORE_RESAMPLE_H
+#define _MAGICKCORE_RESAMPLE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/cache-view.h"
+
+/*
+  WARNING:  The order of this table must also match the order of a table
+  located in AcquireResizeFilter() in "resize.c" otherwise the users filter
+  will not match the actual filter that is setup.
+*/
+typedef enum
+{
+  UndefinedFilter,
+  PointFilter,
+  BoxFilter,
+  TriangleFilter,
+  HermiteFilter,
+  HanningFilter,
+  HammingFilter,
+  BlackmanFilter,
+  GaussianFilter,
+  QuadraticFilter,
+  CubicFilter,
+  CatromFilter,
+  MitchellFilter,
+  JincFilter,
+  SincFilter,
+  SincFastFilter,
+  KaiserFilter,
+  WelshFilter,
+  ParzenFilter,
+  BohmanFilter,
+  BartlettFilter,
+  LagrangeFilter,
+  LanczosFilter,
+  LanczosSharpFilter,
+  Lanczos2Filter,
+  Lanczos2SharpFilter,
+  RobidouxFilter,
+  RobidouxSharpFilter,
+  CosineFilter,
+  SplineFilter,
+  LanczosRadiusFilter,
+  SentinelFilter  /* a count of all the filters, not a real filter */
+} FilterTypes;
+
+/*
+  Backward compatibility for the more correctly named Jinc Filter.  Original
+  source of this filter is from "zoom" but it refers to a reference by Pratt,
+  who does not actualy name the filter.
+*/
+#define BesselFilter JincFilter
+
+typedef struct _ResampleFilter
+  ResampleFilter;
+
+extern MagickExport MagickBooleanType
+  ResamplePixelColor(ResampleFilter *,const double,const double,
+    MagickPixelPacket *),
+  SetResampleFilterInterpolateMethod(ResampleFilter *,
+    const InterpolatePixelMethod),
+  SetResampleFilterVirtualPixelMethod(ResampleFilter *,
+    const VirtualPixelMethod);
+
+extern MagickExport ResampleFilter
+  *AcquireResampleFilter(const Image *,ExceptionInfo *),
+  *DestroyResampleFilter(ResampleFilter *);
+
+extern MagickExport void
+  ScaleResampleFilter(ResampleFilter *,const double,const double,const double,
+    const double),
+  SetResampleFilter(ResampleFilter *,const FilterTypes,const double);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/resize.h

@@ -0,0 +1,45 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image resize methods.
+*/
+#ifndef _MAGICKCORE_RESIZE_H
+#define _MAGICKCORE_RESIZE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport Image
+  *AdaptiveResizeImage(const Image *,const size_t,const size_t,ExceptionInfo *),
+  *InterpolativeResizeImage(const Image *,const size_t,const size_t,
+    const InterpolatePixelMethod,ExceptionInfo *),
+  *LiquidRescaleImage(const Image *,const size_t,const size_t,const double,
+    const double,ExceptionInfo *),
+  *MagnifyImage(const Image *,ExceptionInfo *),
+  *MinifyImage(const Image *,ExceptionInfo *),
+  *ResampleImage(const Image *,const double,const double,const FilterTypes,
+    const double,ExceptionInfo *),
+  *ResizeImage(const Image *,const size_t,const size_t,const FilterTypes,
+    const double,ExceptionInfo *),
+  *SampleImage(const Image *,const size_t,const size_t,ExceptionInfo *),
+  *ScaleImage(const Image *,const size_t,const size_t,ExceptionInfo *),
+  *ThumbnailImage(const Image *,const size_t,const size_t,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/resource_.h

@@ -0,0 +1,64 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore resource methods.
+*/
+#ifndef _MAGICKCORE_RESOURCE_H
+#define _MAGICKCORE_RESOURCE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedResource,
+  AreaResource,
+  DiskResource,
+  FileResource,
+  MapResource,
+  MemoryResource,
+  ThreadResource,
+  TimeResource,
+  ThrottleResource
+} ResourceType;
+
+#define MagickResourceInfinity  MagickULLConstant(~0)
+
+extern MagickExport int
+  AcquireUniqueFileResource(char *);
+
+extern MagickExport MagickBooleanType
+  AcquireMagickResource(const ResourceType,const MagickSizeType),
+  GetPathTemplate(char *),
+  ListMagickResourceInfo(FILE *,ExceptionInfo *),
+  RelinquishUniqueFileResource(const char *),
+  ResourceComponentGenesis(void),
+  SetMagickResourceLimit(const ResourceType,const MagickSizeType);
+
+extern MagickExport MagickSizeType
+  GetMagickResource(const ResourceType),
+  GetMagickResourceLimit(const ResourceType);
+
+extern MagickExport void
+  AsynchronousResourceComponentTerminus(void),
+  RelinquishMagickResource(const ResourceType,const MagickSizeType),
+  ResourceComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/segment.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image segment methods.
+*/
+#ifndef _MAGICKCORE_SEGMENT_H
+#define _MAGICKCORE_SEGMENT_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  GetImageDynamicThreshold(const Image *,const double,const double,
+    MagickPixelPacket *,ExceptionInfo *),
+  SegmentImage(Image *,const ColorspaceType,const MagickBooleanType,
+    const double,const double);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/semaphore.h

@@ -0,0 +1,46 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore methods to lock and unlock semaphores.
+*/
+#ifndef _MAGICKCORE_SEMAPHORE_H
+#define _MAGICKCORE_SEMAPHORE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct SemaphoreInfo
+  SemaphoreInfo;
+
+extern MagickExport MagickBooleanType
+  SemaphoreComponentGenesis(void);
+
+extern MagickExport SemaphoreInfo
+  *AllocateSemaphoreInfo(void);
+
+extern MagickExport void
+  AcquireSemaphoreInfo(SemaphoreInfo **),
+  DestroySemaphoreInfo(SemaphoreInfo **),
+  LockSemaphoreInfo(SemaphoreInfo *),
+  RelinquishSemaphoreInfo(SemaphoreInfo *),
+  SemaphoreComponentTerminus(void),
+  UnlockSemaphoreInfo(SemaphoreInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/shear.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image stream methods.
+*/
+#ifndef _MAGICKCORE_SHEAR_H
+#define _MAGICKCORE_SHEAR_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport Image
+  *DeskewImage(const Image *,const double,ExceptionInfo *),
+  *IntegralRotateImage(const Image *,size_t,ExceptionInfo *),
+  *ShearImage(const Image *,const double,const double,ExceptionInfo *),
+  *ShearRotateImage(const Image *,const double,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/signature.h

@@ -0,0 +1,32 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore digital signature methods.
+*/
+#ifndef _MAGICKCORE_SIGNATURE_H
+#define _MAGICKCORE_SIGNATURE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  SignatureImage(Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/splay-tree.h

@@ -0,0 +1,61 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore splay-tree methods.
+*/
+#ifndef _MAGICKCORE_SPLAY_H
+#define _MAGICKCORE_SPLAY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _SplayTreeInfo
+  SplayTreeInfo;
+
+extern MagickExport MagickBooleanType
+  AddValueToSplayTree(SplayTreeInfo *,const void *,const void *),
+  DeleteNodeByValueFromSplayTree(SplayTreeInfo *,const void *),
+  DeleteNodeFromSplayTree(SplayTreeInfo *,const void *);
+
+extern MagickExport const void
+  *GetNextKeyInSplayTree(SplayTreeInfo *),
+  *GetNextValueInSplayTree(SplayTreeInfo *),
+  *GetValueFromSplayTree(SplayTreeInfo *,const void *);
+
+extern MagickExport int
+  CompareSplayTreeString(const void *,const void *),
+  CompareSplayTreeStringInfo(const void *,const void *);
+
+extern MagickExport SplayTreeInfo
+  *CloneSplayTree(SplayTreeInfo *,void *(*)(void *),void *(*)(void *)),
+  *DestroySplayTree(SplayTreeInfo *),
+  *NewSplayTree(int (*)(const void *,const void *),void *(*)(void *),
+    void *(*)(void *));
+
+extern MagickExport size_t
+  GetNumberOfNodesInSplayTree(const SplayTreeInfo *);
+
+extern MagickExport void
+  *RemoveNodeByValueFromSplayTree(SplayTreeInfo *,const void *),
+  *RemoveNodeFromSplayTree(SplayTreeInfo *,const void *),
+  ResetSplayTree(SplayTreeInfo *),
+  ResetSplayTreeIterator(SplayTreeInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/statistic.h

@@ -0,0 +1,141 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore statistical methods.
+*/
+#ifndef _MAGICKCORE_STATISTIC_H
+#define _MAGICKCORE_STATISTIC_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _ChannelStatistics
+{
+  size_t
+    depth;
+
+  double
+    minima,
+    maxima,
+    sum,
+    sum_squared,
+    sum_cubed,
+    sum_fourth_power,
+    mean,
+    variance,
+    standard_deviation,
+    kurtosis,
+    skewness;
+} ChannelStatistics;
+
+typedef enum
+{
+  UndefinedEvaluateOperator,
+  AddEvaluateOperator,
+  AndEvaluateOperator,
+  DivideEvaluateOperator,
+  LeftShiftEvaluateOperator,
+  MaxEvaluateOperator,
+  MinEvaluateOperator,
+  MultiplyEvaluateOperator,
+  OrEvaluateOperator,
+  RightShiftEvaluateOperator,
+  SetEvaluateOperator,
+  SubtractEvaluateOperator,
+  XorEvaluateOperator,
+  PowEvaluateOperator,
+  LogEvaluateOperator,
+  ThresholdEvaluateOperator,
+  ThresholdBlackEvaluateOperator,
+  ThresholdWhiteEvaluateOperator,
+  GaussianNoiseEvaluateOperator,
+  ImpulseNoiseEvaluateOperator,
+  LaplacianNoiseEvaluateOperator,
+  MultiplicativeNoiseEvaluateOperator,
+  PoissonNoiseEvaluateOperator,
+  UniformNoiseEvaluateOperator,
+  CosineEvaluateOperator,
+  SineEvaluateOperator,
+  AddModulusEvaluateOperator,
+  MeanEvaluateOperator,
+  AbsEvaluateOperator,
+  ExponentialEvaluateOperator,
+  MedianEvaluateOperator,
+  SumEvaluateOperator
+} MagickEvaluateOperator;
+
+typedef enum
+{
+  UndefinedFunction,
+  PolynomialFunction,
+  SinusoidFunction,
+  ArcsinFunction,
+  ArctanFunction
+} MagickFunction;
+
+typedef enum
+{
+  UndefinedStatistic,
+  GradientStatistic,
+  MaximumStatistic,
+  MeanStatistic,
+  MedianStatistic,
+  MinimumStatistic,
+  ModeStatistic,
+  NonpeakStatistic,
+  StandardDeviationStatistic
+} StatisticType;
+
+extern MagickExport ChannelStatistics
+  *GetImageChannelStatistics(const Image *,ExceptionInfo *);
+
+extern MagickExport Image
+  *EvaluateImages(const Image *,const MagickEvaluateOperator,ExceptionInfo *),
+  *PolynomialImage(const Image *,const size_t,const double *,ExceptionInfo *),
+  *PolynomialImageChannel(const Image *,const ChannelType,const size_t,
+    const double *,ExceptionInfo *),
+  *StatisticImage(const Image *,const StatisticType,const size_t,const size_t,
+    ExceptionInfo *),
+  *StatisticImageChannel(const Image *,const ChannelType,const StatisticType,
+    const size_t,const size_t,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  EvaluateImage(Image *,const MagickEvaluateOperator,const double,
+    ExceptionInfo *),
+  EvaluateImageChannel(Image *,const ChannelType,const MagickEvaluateOperator,
+    const double,ExceptionInfo *),
+  FunctionImage(Image *,const MagickFunction,const size_t,const double *,
+    ExceptionInfo *),
+  FunctionImageChannel(Image *,const ChannelType,const MagickFunction,
+    const size_t,const double *,ExceptionInfo *),
+  GetImageChannelExtrema(const Image *,const ChannelType,size_t *,size_t *,
+    ExceptionInfo *),
+  GetImageChannelMean(const Image *,const ChannelType,double *,double *,
+    ExceptionInfo *),
+  GetImageChannelKurtosis(const Image *,const ChannelType,double *,double *,
+    ExceptionInfo *),
+  GetImageChannelRange(const Image *,const ChannelType,double *,double *,
+    ExceptionInfo *),
+  GetImageExtrema(const Image *,size_t *,size_t *,ExceptionInfo *),
+  GetImageRange(const Image *,double *,double *,ExceptionInfo *),
+  GetImageMean(const Image *,double *,double *,ExceptionInfo *),
+  GetImageKurtosis(const Image *,double *,double *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/stream.h

@@ -0,0 +1,38 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image stream methods.
+*/
+#ifndef _MAGICKCORE_STREAM_H
+#define _MAGICKCORE_STREAM_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef size_t
+  (*StreamHandler)(const Image *,const void *,const size_t);
+
+extern MagickExport Image
+  *ReadStream(const ImageInfo *,StreamHandler,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  WriteStream(const ImageInfo *,Image *,StreamHandler);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/string_.h

@@ -0,0 +1,116 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore string methods.
+*/
+#ifndef _MAGICKCORE_STRING_H_
+#define _MAGICKCORE_STRING_H_
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include <time.h>
+#include "magick/exception.h"
+
+typedef struct _StringInfo
+{
+  char
+    path[MaxTextExtent];
+
+  unsigned char
+    *datum;
+
+  size_t
+    length,
+    signature;
+} StringInfo;
+
+extern MagickExport char
+  *AcquireString(const char *),
+  *CloneString(char **,const char *),
+  *ConstantString(const char *),
+  *DestroyString(char *),
+  **DestroyStringList(char **),
+  *EscapeString(const char *,const char),
+  *FileToString(const char *,const size_t,ExceptionInfo *),
+  *GetEnvironmentValue(const char *),
+  *StringInfoToHexString(const StringInfo *),
+  *StringInfoToString(const StringInfo *),
+  **StringToArgv(const char *,int *),
+  *StringToken(const char *,char **),
+  **StringToList(const char *);
+
+extern MagickExport const char
+  *GetStringInfoPath(const StringInfo *);
+
+extern MagickExport double
+  InterpretSiPrefixValue(const char *restrict,char **restrict),
+  *StringToArrayOfDoubles(const char *,ssize_t *, ExceptionInfo *);
+
+extern MagickExport int
+  CompareStringInfo(const StringInfo *,const StringInfo *),
+  LocaleCompare(const char *,const char *),
+  LocaleNCompare(const char *,const char *,const size_t);
+
+extern MagickExport MagickBooleanType
+  ConcatenateString(char **,const char *),
+  IsStringTrue(const char *),
+  IsStringNotFalse(const char *),
+  SubstituteString(char **,const char *,const char *);
+
+extern MagickExport size_t
+  ConcatenateMagickString(char *,const char *,const size_t)
+    magick_attribute((__nonnull__)),
+  CopyMagickString(char *,const char *,const size_t)
+    magick_attribute((__nonnull__)),
+  GetStringInfoLength(const StringInfo *);
+
+extern MagickExport ssize_t
+  FormatMagickSize(const MagickSizeType,const MagickBooleanType,char *),
+  FormatMagickTime(const time_t,const size_t,char *);
+
+extern MagickExport StringInfo
+  *AcquireStringInfo(const size_t),
+  *BlobToStringInfo(const void *,const size_t),
+  *CloneStringInfo(const StringInfo *),
+  *ConfigureFileToStringInfo(const char *),
+  *DestroyStringInfo(StringInfo *),
+  *FileToStringInfo(const char *,const size_t,ExceptionInfo *),
+  *SplitStringInfo(StringInfo *,const size_t),
+  *StringToStringInfo(const char *);
+
+extern MagickExport unsigned char
+  *GetStringInfoDatum(const StringInfo *);
+
+extern MagickExport void
+  ConcatenateStringInfo(StringInfo *,const StringInfo *)
+    magick_attribute((__nonnull__)),
+  LocaleLower(char *),
+  LocaleUpper(char *),
+  PrintStringInfo(FILE *file,const char *,const StringInfo *),
+  ResetStringInfo(StringInfo *),
+  SetStringInfo(StringInfo *,const StringInfo *),
+  SetStringInfoDatum(StringInfo *,const unsigned char *),
+  SetStringInfoLength(StringInfo *,const size_t),
+  SetStringInfoPath(StringInfo *,const char *),
+  StripString(char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/threshold.h

@@ -0,0 +1,63 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image threshold methods.
+*/
+#ifndef _MAGICKCORE_THRESHOLD_H
+#define _MAGICKCORE_THRESHOLD_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _ThresholdMap
+  ThresholdMap;
+
+extern MagickExport Image
+  *AdaptiveThresholdImage(const Image *,const size_t,const size_t,const ssize_t,
+    ExceptionInfo *);
+
+extern MagickExport ThresholdMap
+  *DestroyThresholdMap(ThresholdMap *),
+  *GetThresholdMap(const char *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  BilevelImage(Image *,const double),
+  BilevelImageChannel(Image *,const ChannelType,const double),
+  BlackThresholdImage(Image *,const char *),
+  BlackThresholdImageChannel(Image *,const ChannelType,const char *,
+    ExceptionInfo *),
+  ClampImage(Image *),
+  ClampImageChannel(Image *,const ChannelType),
+  ListThresholdMaps(FILE *,ExceptionInfo *),
+  OrderedDitherImage(Image *),  /* deprecated */
+  OrderedDitherImageChannel(Image *,const ChannelType,ExceptionInfo *),
+  OrderedPosterizeImage(Image *,const char *,ExceptionInfo *),
+  OrderedPosterizeImageChannel(Image *,const ChannelType,const char *,
+    ExceptionInfo *),
+  PerceptibleImage(Image *,const double),
+  PerceptibleImageChannel(Image *,const ChannelType,const double),
+  RandomThresholdImage(Image *,const char *,ExceptionInfo *),
+  RandomThresholdImageChannel(Image *,const ChannelType,const char *,
+    ExceptionInfo *),
+  WhiteThresholdImage(Image *,const char *),
+  WhiteThresholdImageChannel(Image *,const ChannelType,const char *,
+    ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/timer.h

@@ -0,0 +1,73 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore timer methods.
+*/
+#ifndef _MAGICKCORE_TIMER_H
+#define _MAGICKCORE_TIMER_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedTimerState,
+  StoppedTimerState,
+  RunningTimerState
+} TimerState;
+
+typedef struct _Timer
+{
+  double
+    start,
+    stop,
+    total;
+} Timer;
+
+typedef struct _TimerInfo
+{ 
+  Timer
+    user,
+    elapsed;
+  
+  TimerState
+    state;
+  
+  size_t
+    signature;
+} TimerInfo;
+
+extern MagickExport double
+  GetElapsedTime(TimerInfo *),
+  GetUserTime(TimerInfo *);
+
+extern MagickExport MagickBooleanType
+  ContinueTimer(TimerInfo *);
+
+extern MagickExport TimerInfo
+  *AcquireTimerInfo(void),
+  *DestroyTimerInfo(TimerInfo *);
+
+extern MagickExport void
+  GetTimerInfo(TimerInfo *),
+  ResetTimer(TimerInfo *),
+  StartTimer(TimerInfo *,const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/token.h

@@ -0,0 +1,51 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore token methods.
+*/
+#ifndef _MAGICKCORE_TOKEN_H
+#define _MAGICKCORE_TOKEN_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/*
+  Typedef declarations.
+*/
+typedef struct _TokenInfo
+  TokenInfo;
+
+extern MagickExport int
+  Tokenizer(TokenInfo *,const unsigned int,char *,const size_t,const char *,
+    const char *,const char *,const char *,const char,char *,int *,char *);
+
+extern MagickExport MagickBooleanType
+  GlobExpression(const char *,const char *,const MagickBooleanType),
+  IsGlob(const char *),
+  IsMagickTrue(const char *);
+
+extern MagickExport TokenInfo
+  *AcquireTokenInfo(void),
+  *DestroyTokenInfo(TokenInfo *);
+
+extern MagickExport void
+  GetMagickToken(const char *,const char **,char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/transform.h

@@ -0,0 +1,50 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image transform methods.
+*/
+#ifndef _MAGICKCORE_TRANSFORM_H
+#define _MAGICKCORE_TRANSFORM_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport Image
+  *AutoOrientImage(const Image *,const OrientationType,ExceptionInfo *),
+  *ChopImage(const Image *,const RectangleInfo *,ExceptionInfo *),
+  *ConsolidateCMYKImages(const Image *,ExceptionInfo *),
+  *CropImage(const Image *,const RectangleInfo *,ExceptionInfo *),
+  *CropImageToTiles(const Image *,const char *, ExceptionInfo *),
+  *ExcerptImage(const Image *,const RectangleInfo *,ExceptionInfo *),
+  *ExtentImage(const Image *,const RectangleInfo *,ExceptionInfo *),
+  *FlipImage(const Image *,ExceptionInfo *),
+  *FlopImage(const Image *,ExceptionInfo *),
+  *RollImage(const Image *,const ssize_t,const ssize_t,ExceptionInfo *),
+  *ShaveImage(const Image *,const RectangleInfo *,ExceptionInfo *),
+  *SpliceImage(const Image *,const RectangleInfo *,ExceptionInfo *),
+  *TransposeImage(const Image *,ExceptionInfo *),
+  *TransverseImage(const Image *,ExceptionInfo *),
+  *TrimImage(const Image *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  TransformImage(Image **,const char *,const char *),
+  TransformImages(Image **,const char *,const char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/type.h

@@ -0,0 +1,107 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore image type methods.
+*/
+#ifndef _MAGICKCORE_TYPE_H
+#define _MAGICKCORE_TYPE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedStretch,
+  NormalStretch,
+  UltraCondensedStretch,
+  ExtraCondensedStretch,
+  CondensedStretch,
+  SemiCondensedStretch,
+  SemiExpandedStretch,
+  ExpandedStretch,
+  ExtraExpandedStretch,
+  UltraExpandedStretch,
+  AnyStretch
+} StretchType;
+
+typedef enum
+{
+  UndefinedStyle,
+  NormalStyle,
+  ItalicStyle,
+  ObliqueStyle,
+  AnyStyle
+} StyleType;
+
+typedef struct _TypeInfo
+{
+  size_t
+    face;
+
+  char
+    *path,
+    *name,
+    *description,
+    *family;
+
+  StyleType
+    style;
+
+  StretchType
+    stretch;
+
+  size_t
+    weight;
+
+  char
+    *encoding,
+    *foundry,
+    *format,
+    *metrics,
+    *glyphs;
+
+  MagickBooleanType
+    stealth;
+
+  struct _TypeInfo
+    *previous,
+    *next;  /* deprecated, use GetTypeInfoList() */
+
+  size_t
+    signature;
+} TypeInfo;
+
+extern MagickExport char
+  **GetTypeList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  ListTypeInfo(FILE *,ExceptionInfo *),
+  TypeComponentGenesis(void);
+
+extern MagickExport const TypeInfo
+  *GetTypeInfo(const char *,ExceptionInfo *),
+  *GetTypeInfoByFamily(const char *,const StyleType,const StretchType,
+    const size_t,ExceptionInfo *),
+  **GetTypeInfoList(const char *,size_t *,ExceptionInfo *);
+
+MagickExport void
+  TypeComponentTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/utility.h

@@ -0,0 +1,75 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore utility methods.
+*/
+#ifndef _MAGICKCORE_UTILITY_H
+#define _MAGICKCORE_UTILITY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedPath,
+  MagickPath,
+  RootPath,
+  HeadPath,
+  TailPath,
+  BasePath,
+  ExtensionPath,
+  SubimagePath,
+  CanonicalPath
+} PathType;
+
+extern MagickExport char
+  *Base64Encode(const unsigned char *,const size_t,size_t *),
+  **GetPathComponents(const char *,size_t *),
+  **ListFiles(const char *,const char *,size_t *);
+
+extern MagickExport int
+  SystemCommand(const MagickBooleanType,const MagickBooleanType,const char *,
+    ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  AcquireUniqueFilename(char *),
+  AcquireUniqueSymbolicLink(const char *,char *),
+  ExpandFilenames(int *,char ***),
+  GetPathAttributes(const char *,void *),
+  GetExecutionPath(char *,const size_t),
+  IsPathAccessible(const char *);
+
+extern MagickExport size_t
+  MultilineCensus(const char *);
+
+extern MagickExport ssize_t
+  GetMagickPageSize(void);
+
+extern MagickExport unsigned char
+  *Base64Decode(const char *, size_t *);
+
+extern MagickExport void
+  AppendImageFormat(const char *,char *),
+  ChopPathComponents(char *,const size_t),
+  ExpandFilename(char *),
+  GetPathComponent(const char *,PathType,char *),
+  MagickDelay(const MagickSizeType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/version.h

@@ -0,0 +1,83 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore version methods.
+*/
+#ifndef _MAGICKCORE_VERSION_H
+#define _MAGICKCORE_VERSION_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/*
+  Define declarations.
+*/
+#define MagickPackageName "ImageMagick"
+#define MagickCopyright  "Copyright (C) 1999-2013 ImageMagick Studio LLC"
+#define MagickSVNRevision  "10070"
+#define MagickLibVersion  0x683
+#define MagickLibVersionText  "6.8.3"
+#define MagickLibVersionNumber  1,0,0
+#define MagickLibAddendum  "-1"
+#define MagickLibInterface  1
+#define MagickLibMinInterface  1
+#define MagickReleaseDate  "2013-02-19"
+#define MagickChangeDate   "20130216"
+#define MagickFeatures "DPC OpenMP"
+#define MagickDelegates "bzlib djvu mpeg fontconfig freetype jng jp2 jpeg lcms lqr openexr pango png ps tiff x xml zlib"
+#define MagickHomeURL  "file:///home/santi/lms/ImageMagick-6.8.3-1/bin/share/doc/ImageMagick-6.8.3/index.html"
+#define MagickAuthoritativeURL  "http://www.imagemagick.org"
+#if (MAGICKCORE_QUANTUM_DEPTH == 8)
+#define MagickQuantumDepth  "Q8"
+#define MagickQuantumRange  "255"
+#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
+#define MagickQuantumDepth  "Q16"
+#define MagickQuantumRange  "65535"
+#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
+#define MagickQuantumDepth  "Q32"
+#define MagickQuantumRange  "4294967295"
+#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
+#define MagickQuantumDepth  "Q64"
+#define MagickQuantumRange  "18446744073709551615.0"
+#else
+#define MagickQuantumDepth  "Q?"
+#define MagickQuantumRange  "?"
+#endif
+#define MagickVersion  \
+  MagickPackageName " " MagickLibVersionText MagickLibAddendum " " \
+  MagickReleaseDate " " MagickQuantumDepth " " MagickAuthoritativeURL
+
+extern MagickExport char
+  *GetMagickHomeURL(void);
+
+extern MagickExport const char
+  *GetMagickCopyright(void),
+  *GetMagickDelegates(void),
+  *GetMagickFeatures(void),
+  *GetMagickPackageName(void),
+  *GetMagickQuantumDepth(size_t *),
+  *GetMagickQuantumRange(size_t *),
+  *GetMagickReleaseDate(void),
+  *GetMagickVersion(size_t *);
+
+extern MagickExport void
+  ListMagickVersion(FILE *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/widget.h

@@ -0,0 +1,58 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore X11 widget methods.
+*/
+#ifndef _MAGICKCORE_WIDGET_H
+#define _MAGICKCORE_WIDGET_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if defined(MAGICKCORE_X11_DELEGATE)
+
+#include "magick/xwindow-private.h"
+
+extern MagickExport int
+  XCommandWidget(Display *,XWindows *,const char **,XEvent *),
+  XConfirmWidget(Display *,XWindows *,const char *,const char *),
+  XDialogWidget(Display *,XWindows *,const char *,const char *,char *),
+  XMenuWidget(Display *,XWindows *,const char *,const char **,char *);
+
+extern MagickExport MagickBooleanType
+  XPreferencesWidget(Display *,XResourceInfo *,XWindows *);
+
+extern MagickExport void
+  DestroyXWidget(void),
+  XColorBrowserWidget(Display *,XWindows *,const char *,char *),
+  XFileBrowserWidget(Display *,XWindows *,const char *,char *),
+  XFontBrowserWidget(Display *,XWindows *,const char *,char *),
+  XInfoWidget(Display *,XWindows *,const char *),
+  XListBrowserWidget(Display *,XWindows *,XWindowInfo *,const char **,
+    const char *,const char *,char *),
+  XNoticeWidget(Display *,XWindows *,const char *,const char *),
+  XProgressMonitorWidget(Display *,XWindows *,const char *,
+    const MagickOffsetType,const MagickSizeType),
+  XTextViewWidget(Display *,const XResourceInfo *,XWindows *,
+    const MagickBooleanType,const char *,const char **);
+
+#endif
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/xml-tree.h

@@ -0,0 +1,65 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+
+    http://www.imagemagick.org/MagicksToolkit/script/license.php
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  Magick's toolkit xml-tree methods.
+*/
+#ifndef _MAGICKCORE_XML_TREE_H
+#define _MAGICKCORE_XML_TREE_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "magick/exception.h"
+#include "magick/splay-tree.h"
+
+typedef struct _XMLTreeInfo
+  XMLTreeInfo;
+
+extern MagickExport char
+  *CanonicalXMLContent(const char *,const MagickBooleanType),
+  *XMLTreeInfoToXML(XMLTreeInfo *);
+
+extern MagickExport const char
+  *GetXMLTreeAttribute(XMLTreeInfo *,const char *),
+  *GetXMLTreeContent(XMLTreeInfo *),
+  **GetXMLTreeProcessingInstructions(XMLTreeInfo *,const char *),
+  *GetXMLTreeTag(XMLTreeInfo *);
+
+extern MagickExport MagickBooleanType
+  GetXMLTreeAttributes(const XMLTreeInfo *,SplayTreeInfo *);
+
+extern MagickExport XMLTreeInfo
+  *AddChildToXMLTree(XMLTreeInfo *,const char *,const size_t),
+  *AddPathToXMLTree(XMLTreeInfo *,const char *,const size_t),
+  *DestroyXMLTree(XMLTreeInfo *),
+  *GetNextXMLTreeTag(XMLTreeInfo *),
+  *GetXMLTreeChild(XMLTreeInfo *,const char *),
+  *GetXMLTreeOrdered(XMLTreeInfo *),
+  *GetXMLTreePath(XMLTreeInfo *,const char *),
+  *GetXMLTreeSibling(XMLTreeInfo *),
+  *InsertTagIntoXMLTree(XMLTreeInfo *,XMLTreeInfo *,const size_t),
+  *NewXMLTree(const char *,ExceptionInfo *),
+  *NewXMLTreeTag(const char *),
+  *ParseTagFromXMLTree(XMLTreeInfo *),
+  *PruneTagFromXMLTree(XMLTreeInfo *),
+  *SetXMLTreeAttribute(XMLTreeInfo *,const char *,const char *),
+  *SetXMLTreeContent(XMLTreeInfo *,const char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

ImageMagick-6.8.3-1/bin/include/ImageMagick/magick/xwindow.h

@@ -0,0 +1,45 @@
+/*
+  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization
+  dedicated to making software imaging solutions freely available.
+  
+  You may not use this file except in compliance with the License.
+  obtain a copy of the License at
+  
+    http://www.imagemagick.org/script/license.php
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  MagickCore X11 window methods.
+*/
+#ifndef _MAGICKCORE_XWINDOW_H
+#define _MAGICKCORE_XWINDOW_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _XImportInfo
+{
+  MagickBooleanType
+    frame,
+    borders,
+    screen,
+    descend,
+    silent;
+} XImportInfo;
+
+extern MagickExport Image
+  *XImportImage(const ImageInfo *,XImportInfo *);
+
+extern MagickExport void
+  XGetImportInfo(XImportInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif