""":mod:`wand.api` --- Low-level interfaces
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. versionchanged:: 0.1.10
   Changed to throw :exc:`~exceptions.ImportError` instead of
   :exc:`~exceptions.AttributeError` when the shared library fails to load.

"""
import ctypes
import ctypes.util
import itertools
import os
import os.path
import platform
import sys
import traceback
if platform.system() == "Windows":
    try:
        import winreg
    except ImportError:
        import _winreg as winreg

__all__ = ('MagickPixelPacket', 'PointInfo', 'AffineMatrix', 'c_magick_char_p',
           'library', 'libc', 'libmagick', 'load_library')


class c_magick_char_p(ctypes.c_char_p):
    """This subclass prevents the automatic conversion behavior of
    :class:`ctypes.c_char_p`, allowing memory to be properly freed in the
    destructor.  It must only be used for non-const character pointers
    returned by ImageMagick functions.

    """

    def __del__(self):
        """Relinquishes memory allocated by ImageMagick.
        We don't need to worry about checking for ``NULL`` because
        :c:func:`MagickRelinquishMemory` does that for us.
        Note alslo that :class:`ctypes.c_char_p` has no
        :meth:`~object.__del__` method, so we don't need to
        (and indeed can't) call the superclass destructor.

        """
        library.MagickRelinquishMemory(self)


def library_paths():
    """Iterates for library paths to try loading.  The result paths are not
    guaranteed that they exist.

    :returns: a pair of libwand and libmagick paths.  they can be the same.
              path can be ``None`` as well
    :rtype: :class:`tuple`

    """
    libwand = None
    libmagick = None
    versions = '', '-6', '-Q16', '-Q8', '-6.Q16'
    options = '', 'HDRI', 'HDRI-2'
    system = platform.system()
    magick_home = os.environ.get('MAGICK_HOME')

    if system == 'Windows':
        # ImageMagick installers normally install coder and filter DLLs in
        # subfolders, we need to add those folders to PATH, otherwise loading
        # the DLL later will fail.
        try:
            with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
                                r"SOFTWARE\ImageMagick\Current") as reg_key:
                libPath = winreg.QueryValueEx(reg_key, "LibPath")
                coderPath = winreg.QueryValueEx(reg_key, "CoderModulesPath")
                filterPath = winreg.QueryValueEx(reg_key, "FilterModulesPath")
                magick_home = libPath[0]
                os.environ['PATH'] += (';' + libPath[0] + ";" +
                                       coderPath[0] + ";" + filterPath[0])
        except OSError:
            # otherwise use MAGICK_HOME, and we assume the coder and
            # filter DLLs are in the same directory
            pass

    def magick_path(path):
        return os.path.join(magick_home, *path)
    combinations = itertools.product(versions, options)
    suffixes = (version + option for version, option in combinations)
    if magick_home:
        # exhaustively search for libraries in magick_home before calling
        # find_library
        for suffix in suffixes:
            # On Windows, the API is split between two libs.
            # On other platforms, it's all contained in one.
            if system == 'Windows':
                libwand = 'CORE_RL_wand_{0}.dll'.format(suffix),
                libmagick = 'CORE_RL_magick_{0}.dll'.format(suffix),
                yield magick_path(libwand), magick_path(libmagick)
                libwand = 'libMagickWand{0}.dll'.format(suffix),
                libmagick = 'libMagickCore{0}.dll'.format(suffix),
                yield magick_path(libwand), magick_path(libmagick)
            elif system == 'Darwin':
                libwand = 'lib', 'libMagickWand{0}.dylib'.format(suffix),
                yield magick_path(libwand), magick_path(libwand)
            else:
                libwand = 'lib', 'libMagickWand{0}.so'.format(suffix),
                yield magick_path(libwand), magick_path(libwand)
    for suffix in suffixes:
        if system == 'Windows':
            libwand = ctypes.util.find_library('CORE_RL_wand_' + suffix)
            libmagick = ctypes.util.find_library('CORE_RL_magick_' + suffix)
            yield libwand, libmagick
            libwand = ctypes.util.find_library('libMagickWand' + suffix)
            libmagick = ctypes.util.find_library('libMagickCore' + suffix)
            yield libwand, libmagick
        else:
            libwand = ctypes.util.find_library('MagickWand' + suffix)
            yield libwand, libwand


def load_library():
    """Loads the MagickWand library.

    :returns: the MagickWand library and the ImageMagick library
    :rtype: :class:`ctypes.CDLL`

    """
    tried_paths = []
    for libwand_path, libmagick_path in library_paths():
        if libwand_path is None or libmagick_path is None:
            continue
        try:
            tried_paths.append(libwand_path)
            libwand = ctypes.CDLL(libwand_path)
            if libwand_path == libmagick_path:
                libmagick = libwand
            else:
                tried_paths.append(libmagick_path)
                libmagick = ctypes.CDLL(libmagick_path)
        except (IOError, OSError):
            continue
        return libwand, libmagick
    raise IOError('cannot find library; tried paths: ' + repr(tried_paths))


if not hasattr(ctypes, 'c_ssize_t'):
    if ctypes.sizeof(ctypes.c_uint) == ctypes.sizeof(ctypes.c_void_p):
        ctypes.c_ssize_t = ctypes.c_int
    elif ctypes.sizeof(ctypes.c_ulong) == ctypes.sizeof(ctypes.c_void_p):
        ctypes.c_ssize_t = ctypes.c_long
    elif ctypes.sizeof(ctypes.c_ulonglong) == ctypes.sizeof(ctypes.c_void_p):
        ctypes.c_ssize_t = ctypes.c_longlong


class MagickPixelPacket(ctypes.Structure):

    _fields_ = [('storage_class', ctypes.c_int),
                ('colorspace', ctypes.c_int),
                ('matte', ctypes.c_int),
                ('fuzz', ctypes.c_double),
                ('depth', ctypes.c_size_t),
                ('red', ctypes.c_double),
                ('green', ctypes.c_double),
                ('blue', ctypes.c_double),
                ('opacity', ctypes.c_double),
                ('index', ctypes.c_double)]


class PointInfo(ctypes.Structure):

    _fields_ = [('x', ctypes.c_double),
                ('y', ctypes.c_double)]


class AffineMatrix(ctypes.Structure):
    _fields_ = [('sx', ctypes.c_double),
                ('rx', ctypes.c_double),
                ('ry', ctypes.c_double),
                ('sy', ctypes.c_double),
                ('tx', ctypes.c_double),
                ('ty', ctypes.c_double)]


# Preserve the module itself even if it fails to import
sys.modules['wand._api'] = sys.modules['wand.api']

try:
    libraries = load_library()
except (OSError, IOError):
    msg = 'http://docs.wand-py.org/en/latest/guide/install.html'
    if sys.platform.startswith(('dragonfly', 'freebsd')):
        msg = 'pkg install'
    elif sys.platform == 'win32':
        msg += '#install-imagemagick-on-windows'
    elif sys.platform == 'darwin':
        mac_pkgmgrs = {'brew': 'brew install freetype imagemagick',
                       'port': 'port install imagemagick'}
        for pkgmgr in mac_pkgmgrs:
            with os.popen('which ' + pkgmgr) as f:
                if f.read().strip():
                    msg = mac_pkgmgrs[pkgmgr]
                    break
        else:
            msg += '#install-imagemagick-on-mac'
    else:
        distname, _, __ = platform.linux_distribution()
        distname = (distname or '').lower()
        if distname in ('debian', 'ubuntu'):
            msg = 'apt-get install libmagickwand-dev'
        elif distname in ('fedora', 'centos', 'redhat'):
            msg = 'yum install ImageMagick-devel'
    raise ImportError('MagickWand shared library not found.\n'
                      'You probably had not installed ImageMagick library.\n'
                      'Try to install:\n  ' + msg)

#: (:class:`ctypes.CDLL`) The MagickWand library.
library = libraries[0]

#: (:class:`ctypes.CDLL`) The ImageMagick library.  It is the same with
#: :data:`library` on platforms other than Windows.
#:
#: .. versionadded:: 0.1.10
libmagick = libraries[1]

try:
    library.MagickWandGenesis.argtypes = []
    library.MagickWandTerminus.argtypes = []

    library.NewMagickWand.argtypes = []
    library.NewMagickWand.restype = ctypes.c_void_p

    library.MagickNewImage.argtypes = [ctypes.c_void_p, ctypes.c_int,
                                       ctypes.c_int, ctypes.c_void_p]

    library.ClearMagickWand.argtypes = [ctypes.c_void_p]

    library.DestroyMagickWand.argtypes = [ctypes.c_void_p]
    library.DestroyMagickWand.restype = ctypes.c_void_p

    library.CloneMagickWand.argtypes = [ctypes.c_void_p]
    library.CloneMagickWand.restype = ctypes.c_void_p

    library.IsMagickWand.argtypes = [ctypes.c_void_p]

    library.MagickGetException.argtypes = [ctypes.c_void_p,
                                           ctypes.POINTER(ctypes.c_int)]
    library.MagickGetException.restype = c_magick_char_p

    library.MagickClearException.argtypes = [ctypes.c_void_p]

    library.MagickSetFilename.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    library.MagickReadImageBlob.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                            ctypes.c_size_t]

    library.MagickReadImage.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    library.MagickReadImageFile.argtypes = [ctypes.c_void_p, ctypes.c_void_p]

    library.MagickGetImageFormat.argtypes = [ctypes.c_void_p]
    library.MagickGetImageFormat.restype = c_magick_char_p

    library.MagickSetImageFormat.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    libmagick.MagickToMime.argtypes = [ctypes.c_char_p]
    libmagick.MagickToMime.restype = c_magick_char_p

    library.MagickGetImageSignature.argtypes = [ctypes.c_void_p]
    library.MagickGetImageSignature.restype = c_magick_char_p

    library.MagickGetImageProperty.argtypes = [ctypes.c_void_p,
                                               ctypes.c_char_p]
    library.MagickGetImageProperty.restype = c_magick_char_p

    library.MagickGetImageProperties.argtypes = [
        ctypes.c_void_p,
        ctypes.c_char_p,
        ctypes.POINTER(ctypes.c_size_t)
    ]
    library.MagickGetImageProperties.restype = ctypes.POINTER(ctypes.c_char_p)

    library.MagickSetImageProperty.argtypes = [ctypes.c_void_p,
                                               ctypes.c_char_p,
                                               ctypes.c_char_p]

    library.MagickDeleteImageProperty.argtypes = [ctypes.c_void_p,
                                                  ctypes.c_char_p]
    library.MagickGetImageBackgroundColor.argtypes = [ctypes.c_void_p,
                                                      ctypes.c_void_p]

    library.MagickSetImageBackgroundColor.argtypes = [ctypes.c_void_p,
                                                      ctypes.c_void_p]

    library.MagickSetImageMatte.argtypes = [ctypes.c_void_p, ctypes.c_int]

    library.MagickGetImageMatteColor.argtypes = [ctypes.c_void_p,
                                                 ctypes.c_void_p]

    library.MagickSetImageMatteColor.argtypes = [ctypes.c_void_p,
                                                 ctypes.c_void_p]

    library.MagickGetImageAlphaChannel.argtypes = [ctypes.c_void_p]
    library.MagickGetImageAlphaChannel.restype = ctypes.c_size_t

    library.MagickSetImageAlphaChannel.argtypes = [ctypes.c_void_p,
                                                   ctypes.c_int]

    library.MagickGetImageBlob.argtypes = [ctypes.c_void_p,
                                           ctypes.POINTER(ctypes.c_size_t)]
    library.MagickGetImageBlob.restype = ctypes.POINTER(ctypes.c_ubyte)

    library.MagickGetImagesBlob.argtypes = [ctypes.c_void_p,
                                            ctypes.POINTER(ctypes.c_size_t)]
    library.MagickGetImagesBlob.restype = ctypes.POINTER(ctypes.c_ubyte)

    library.MagickWriteImage.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    library.MagickWriteImageFile.argtypes = [ctypes.c_void_p, ctypes.c_void_p]

    library.MagickWriteImages.argtypes = [ctypes.c_void_p, ctypes.c_char_p,
                                          ctypes.c_int]

    library.MagickWriteImagesFile.argtypes = [ctypes.c_void_p, ctypes.c_void_p]

    library.MagickGetImageResolution.argtypes = [
        ctypes.c_void_p,
        ctypes.POINTER(ctypes.c_double),
        ctypes.POINTER(ctypes.c_double)
    ]

    library.MagickSetImageResolution.argtypes = [ctypes.c_void_p,
                                                 ctypes.c_double,
                                                 ctypes.c_double]

    library.MagickSetResolution.argtypes = [ctypes.c_void_p, ctypes.c_double,
                                            ctypes.c_double]

    library.MagickGetImageWidth.argtypes = [ctypes.c_void_p]
    library.MagickGetImageWidth.restype = ctypes.c_size_t

    library.MagickGetImageHeight.argtypes = [ctypes.c_void_p]
    library.MagickGetImageHeight.restype = ctypes.c_size_t

    library.MagickGetImageOrientation.argtypes = [ctypes.c_void_p]
    library.MagickGetImageOrientation.restype = ctypes.c_int

    library.MagickSetImageOrientation.argtypes = [ctypes.c_void_p,
                                                  ctypes.c_int]

    library.MagickGetImageUnits.argtypes = [ctypes.c_void_p]

    library.MagickSetImageUnits.argtypes = [ctypes.c_void_p, ctypes.c_int]

    library.MagickGetImageVirtualPixelMethod.argtypes = [ctypes.c_void_p]

    library.MagickSetImageVirtualPixelMethod.argtypes = [ctypes.c_void_p,
                                                         ctypes.c_int]

    library.MagickGetImageColorspace.argtypes = [ctypes.c_void_p]
    library.MagickGetImageColorspace.restype = ctypes.c_int

    library.MagickSetImageColorspace.argtypes = [ctypes.c_void_p, ctypes.c_int]
    library.MagickTransformImageColorspace.argtypes = [ctypes.c_void_p,
                                                       ctypes.c_int]

    library.MagickGetImageCompression.argtypes = [ctypes.c_void_p]
    library.MagickGetImageCompression.restype = ctypes.c_int

    library.MagickSetImageCompression.argtypes = [ctypes.c_void_p,
                                                  ctypes.c_int]

    library.MagickGetImageDepth.argtypes = [ctypes.c_void_p]
    library.MagickGetImageDepth.restype = ctypes.c_size_t

    library.MagickSetImageDepth.argtypes = [ctypes.c_void_p]

    library.MagickGetImageChannelDepth.argtypes = [ctypes.c_void_p,
                                                   ctypes.c_int]
    library.MagickGetImageChannelDepth.restype = ctypes.c_size_t

    library.MagickSeparateImageChannel.argtypes = [ctypes.c_void_p,
                                                   ctypes.c_int]

    library.MagickCropImage.argtypes = [ctypes.c_void_p, ctypes.c_size_t,
                                        ctypes.c_size_t, ctypes.c_ssize_t,
                                        ctypes.c_ssize_t]

    library.MagickFlipImage.argtypes = [ctypes.c_void_p]

    library.MagickFlopImage.argtypes = [ctypes.c_void_p]

    library.MagickFrameImage.argtypes = [ctypes.c_void_p,   # wand
                                         ctypes.c_void_p,   # matte_color
                                         ctypes.c_size_t,   # width
                                         ctypes.c_size_t,   # height
                                         ctypes.c_ssize_t,  # inner_bevel
                                         ctypes.c_ssize_t]  # outer_bevel

    library.MagickFunctionImage.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_int,     # MagickFunction
        ctypes.c_size_t,  # number_arguments
        ctypes.POINTER(ctypes.c_double),  # arguments
    ]

    library.MagickFunctionImageChannel.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_int,     # channel
        ctypes.c_int,     # MagickFunction
        ctypes.c_size_t,  # number_arguments
        ctypes.POINTER(ctypes.c_double),  # arguments
    ]

    library.MagickFxImage.argtypes = [ctypes.c_void_p,  # wand
                                      ctypes.c_char_p]  # expression
    library.MagickFxImage.restype = ctypes.c_void_p

    library.MagickFxImageChannel.argtypes = [ctypes.c_void_p,  # wand
                                             ctypes.c_int,     # channel
                                             ctypes.c_char_p]  # expression
    library.MagickFxImageChannel.restype = ctypes.c_void_p

    library.MagickResetImagePage.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    library.MagickSampleImage.argtypes = [ctypes.c_void_p, ctypes.c_size_t,
                                          ctypes.c_size_t]

    library.MagickResizeImage.argtypes = [ctypes.c_void_p, ctypes.c_size_t,
                                          ctypes.c_size_t, ctypes.c_int,
                                          ctypes.c_double]

    library.MagickResampleImage.argtypes = [ctypes.c_void_p, ctypes.c_double,
                                            ctypes.c_double, ctypes.c_int,
                                            ctypes.c_double]

    library.MagickTransformImage.argtypes = [ctypes.c_void_p, ctypes.c_char_p,
                                             ctypes.c_char_p]
    library.MagickTransformImage.restype = ctypes.c_void_p

    library.MagickTransparentPaintImage.argtypes = [
        ctypes.c_void_p, ctypes.c_void_p, ctypes.c_double, ctypes.c_double,
        ctypes.c_int
    ]

    library.MagickLiquidRescaleImage.argtypes = [
        ctypes.c_void_p, ctypes.c_size_t, ctypes.c_size_t,
        ctypes.c_double, ctypes.c_double
    ]

    library.MagickRotateImage.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                          ctypes.c_double]

    library.MagickBorderImage.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                          ctypes.c_size_t, ctypes.c_size_t]

    library.MagickMergeImageLayers.argtypes = [ctypes.c_void_p,  # wand
                                               ctypes.c_int]  # method
    library.MagickMergeImageLayers.restype = ctypes.c_void_p

    library.MagickResetIterator.argtypes = [ctypes.c_void_p]

    library.MagickSetLastIterator.argtypes = [ctypes.c_void_p]

    library.MagickGetIteratorIndex.argtypes = [ctypes.c_void_p]
    library.MagickGetIteratorIndex.restype = ctypes.c_ssize_t

    library.MagickCoalesceImages.argtypes = [ctypes.c_void_p]
    library.MagickCoalesceImages.restype = ctypes.c_void_p

    library.MagickIdentifyImage.argtypes = [ctypes.c_void_p]
    library.MagickIdentifyImage.restype = ctypes.c_char_p

    library.MagickRelinquishMemory.argtypes = [ctypes.c_void_p]
    library.MagickRelinquishMemory.restype = ctypes.c_void_p

    library.NewPixelIterator.argtypes = [ctypes.c_void_p]
    library.NewPixelIterator.restype = ctypes.c_void_p

    library.DestroyPixelIterator.argtypes = [ctypes.c_void_p]
    library.DestroyPixelIterator.restype = ctypes.c_void_p

    library.ClonePixelIterator.argtypes = [ctypes.c_void_p]
    library.ClonePixelIterator.restype = ctypes.c_void_p

    library.IsPixelIterator.argtypes = [ctypes.c_void_p]

    library.PixelGetIteratorException.argtypes = [ctypes.c_void_p,
                                                  ctypes.POINTER(ctypes.c_int)]
    library.PixelGetIteratorException.restype = c_magick_char_p

    library.PixelClearIteratorException.argtypes = [ctypes.c_void_p]

    library.PixelSetFirstIteratorRow.argtypes = [ctypes.c_void_p]

    library.PixelSetIteratorRow.argtypes = [ctypes.c_void_p, ctypes.c_ssize_t]

    library.PixelGetNextIteratorRow.argtypes = [
        ctypes.c_void_p,
        ctypes.POINTER(ctypes.c_size_t)
    ]
    library.PixelGetNextIteratorRow.restype = ctypes.POINTER(ctypes.c_void_p)

    library.NewPixelWand.argtypes = []
    library.NewPixelWand.restype = ctypes.c_void_p

    library.DestroyPixelWand.argtypes = [ctypes.c_void_p]
    library.DestroyPixelWand.restype = ctypes.c_void_p

    library.IsPixelWand.argtypes = [ctypes.c_void_p]

    library.PixelGetException.argtypes = [ctypes.c_void_p,
                                          ctypes.POINTER(ctypes.c_int)]
    library.PixelGetException.restype = c_magick_char_p

    library.PixelClearException.argtypes = [ctypes.c_void_p]

    library.IsPixelWandSimilar.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                           ctypes.c_double]

    library.PixelGetMagickColor.argtypes = [ctypes.c_void_p, ctypes.c_void_p]

    library.PixelSetMagickColor.argtypes = [ctypes.c_void_p, ctypes.c_void_p]

    library.PixelSetColor.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    library.PixelGetColorAsString.argtypes = [ctypes.c_void_p]
    library.PixelGetColorAsString.restype = c_magick_char_p

    library.PixelGetColorAsNormalizedString.argtypes = [ctypes.c_void_p]
    library.PixelGetColorAsNormalizedString.restype = c_magick_char_p

    library.PixelGetRed.argtypes = [ctypes.c_void_p]
    library.PixelGetRed.restype = ctypes.c_double

    library.PixelGetGreen.argtypes = [ctypes.c_void_p]
    library.PixelGetGreen.restype = ctypes.c_double

    library.PixelGetBlue.argtypes = [ctypes.c_void_p]
    library.PixelGetBlue.restype = ctypes.c_double

    library.PixelGetAlpha.argtypes = [ctypes.c_void_p]
    library.PixelGetAlpha.restype = ctypes.c_double

    library.PixelGetRedQuantum.argtypes = [ctypes.c_void_p]
    library.PixelGetRedQuantum.restype = ctypes.c_size_t

    library.PixelGetGreenQuantum.argtypes = [ctypes.c_void_p]
    library.PixelGetGreenQuantum.restype = ctypes.c_size_t

    library.PixelGetBlueQuantum.argtypes = [ctypes.c_void_p]
    library.PixelGetBlueQuantum.restype = ctypes.c_size_t

    library.PixelGetAlphaQuantum.argtypes = [ctypes.c_void_p]
    library.PixelGetAlphaQuantum.restype = ctypes.c_size_t

    library.PixelGetColorCount.argtypes = [ctypes.c_void_p]
    library.PixelGetColorCount.restype = ctypes.c_size_t

    library.MagickGetQuantumRange.argtypes = [ctypes.POINTER(ctypes.c_size_t)]

    library.MagickSetIteratorIndex.argtypes = [ctypes.c_void_p,
                                               ctypes.c_ssize_t]

    library.MagickGetImageType.argtypes = [ctypes.c_void_p]

    library.MagickSetImageType.argtypes = [ctypes.c_void_p, ctypes.c_int]

    library.MagickEvaluateImage.argtypes = [ctypes.c_void_p,
                                            ctypes.c_int,
                                            ctypes.c_double]

    library.MagickLevelImage.argtypes = [ctypes.c_void_p,
                                         ctypes.c_double,
                                         ctypes.c_double,
                                         ctypes.c_double]

    library.MagickLevelImageChannel.argtypes = [ctypes.c_void_p,
                                                ctypes.c_int,
                                                ctypes.c_double,
                                                ctypes.c_double,
                                                ctypes.c_double]

    library.MagickEvaluateImageChannel.argtypes = [ctypes.c_void_p,
                                                   ctypes.c_int,
                                                   ctypes.c_int,
                                                   ctypes.c_double]

    library.MagickContrastStretchImage.argtypes = [ctypes.c_void_p,  # wand
                                                   ctypes.c_double,  # black
                                                   ctypes.c_double]  # white

    library.MagickContrastStretchImageChannel.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_int,     # channel
        ctypes.c_double,  # black
        ctypes.c_double,  # white
    ]

    library.MagickGammaImage.argtypes = [ctypes.c_void_p,
                                         ctypes.c_double]

    library.MagickGammaImageChannel.argtypes = [ctypes.c_void_p,
                                                ctypes.c_int,
                                                ctypes.c_double]

    library.MagickLinearStretchImage.argtypes = [ctypes.c_void_p,  # wand
                                                 ctypes.c_double,  # black
                                                 ctypes.c_double]  # white

    library.MagickCompareImages.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                            ctypes.c_int,
                                            ctypes.POINTER(ctypes.c_double)]
    library.MagickCompareImages.restype = ctypes.c_void_p

    library.MagickCompositeImage.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                             ctypes.c_int, ctypes.c_ssize_t,
                                             ctypes.c_ssize_t]

    library.MagickCompositeImageChannel.argtypes = [
        ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p,
        ctypes.c_int, ctypes.c_ssize_t, ctypes.c_ssize_t
    ]

    library.MagickGetImageCompressionQuality.argtypes = [ctypes.c_void_p]
    library.MagickGetImageCompressionQuality.restype = ctypes.c_ssize_t

    library.MagickSetImageCompressionQuality.argtypes = [ctypes.c_void_p,
                                                         ctypes.c_ssize_t]

    library.MagickStripImage.argtypes = [ctypes.c_void_p]

    library.MagickTrimImage.argtypes = [ctypes.c_void_p,
                                        ctypes.c_double]

    library.MagickExtentImage.argtypes = [ctypes.c_void_p,
                                          ctypes.c_size_t,
                                          ctypes.c_size_t,
                                          ctypes.c_ssize_t,
                                          ctypes.c_ssize_t]

    library.MagickGaussianBlurImage.argtypes = [ctypes.c_void_p,
                                                ctypes.c_double,
                                                ctypes.c_double]

    library.MagickBlurImage.argtypes = [ctypes.c_void_p,
                                        ctypes.c_double,
                                        ctypes.c_double]

    library.MagickUnsharpMaskImage.argtypes = [ctypes.c_void_p,
                                               ctypes.c_double,
                                               ctypes.c_double,
                                               ctypes.c_double,
                                               ctypes.c_double]

    library.MagickGetNumberImages.argtypes = [ctypes.c_void_p]
    library.MagickGetNumberImages.restype = ctypes.c_size_t

    library.MagickGetIteratorIndex.argtypes = [ctypes.c_void_p]
    library.MagickGetIteratorIndex.restype = ctypes.c_size_t

    library.MagickSetIteratorIndex.argtypes = [ctypes.c_void_p,
                                               ctypes.c_ssize_t]

    library.MagickSetFirstIterator.argtypes = [ctypes.c_void_p]

    library.MagickSetLastIterator.argtypes = [ctypes.c_void_p]

    library.MagickAddImage.argtypes = [ctypes.c_void_p, ctypes.c_void_p]

    library.MagickRemoveImage.argtypes = [ctypes.c_void_p]

    libmagick.GetNextImageInList.argtypes = [ctypes.c_void_p]
    libmagick.GetNextImageInList.restype = ctypes.c_void_p

    library.MagickGetImageDelay.argtypes = [ctypes.c_void_p]
    library.MagickGetImageDelay.restype = ctypes.c_ssize_t

    library.MagickSetImageDelay.argtypes = [ctypes.c_void_p, ctypes.c_ssize_t]

    library.NewMagickWandFromImage.argtypes = [ctypes.c_void_p]
    library.NewMagickWandFromImage.restype = ctypes.c_void_p

    library.GetImageFromMagickWand.argtypes = [ctypes.c_void_p]
    library.GetImageFromMagickWand.restype = ctypes.c_void_p

    libmagick.CloneImages.argtypes = [ctypes.c_void_p, ctypes.c_char_p,
                                      ctypes.c_void_p]
    libmagick.CloneImages.restype = ctypes.c_void_p

    libmagick.AcquireExceptionInfo.argtypes = []
    libmagick.AcquireExceptionInfo.restype = ctypes.c_void_p

    libmagick.DestroyExceptionInfo.argtypes = [ctypes.c_void_p]
    libmagick.DestroyExceptionInfo.restype = ctypes.c_void_p

    libmagick.DestroyImage.argtypes = [ctypes.c_void_p]
    libmagick.DestroyImage.restype = ctypes.c_void_p

    library.MagickGetSize.argtypes = [ctypes.c_void_p,
                                      ctypes.POINTER(ctypes.c_uint),
                                      ctypes.POINTER(ctypes.c_uint)]
    library.MagickGetSize.restype = ctypes.c_int

    library.MagickGetImagePage.argtypes = [ctypes.c_void_p,
                                           ctypes.POINTER(ctypes.c_uint),
                                           ctypes.POINTER(ctypes.c_uint),
                                           ctypes.POINTER(ctypes.c_int),
                                           ctypes.POINTER(ctypes.c_int)]
    library.MagickGetImagePage.restype = ctypes.c_int

    library.MagickSetImagePage.argtypes = [ctypes.c_void_p,
                                           ctypes.c_size_t,
                                           ctypes.c_size_t,
                                           ctypes.c_ssize_t,
                                           ctypes.c_ssize_t]
    library.MagickSetImagePage.restype = ctypes.c_int

    library.MagickSetSize.argtypes = [ctypes.c_void_p,
                                      ctypes.c_uint,
                                      ctypes.c_uint]
    library.MagickSetSize.restype = ctypes.c_int

    library.MagickSetDepth.argtypes = [ctypes.c_void_p,
                                       ctypes.c_uint]
    library.MagickSetDepth.restype = ctypes.c_int

    library.MagickSetFormat.argtypes = [ctypes.c_void_p,
                                        ctypes.c_char_p]
    library.MagickSetFormat.restype = ctypes.c_int

    library.MagickGetFont.argtypes = [ctypes.c_void_p]
    library.MagickGetFont.restype = ctypes.c_char_p

    library.MagickSetFont.argtypes = [ctypes.c_void_p,
                                      ctypes.c_char_p]
    library.MagickSetFont.restype = ctypes.c_int

    library.MagickGetPointsize.argtypes = [ctypes.c_void_p]
    library.MagickGetPointsize.restype = ctypes.c_double

    library.MagickSetPointsize.argtypes = [ctypes.c_void_p,
                                           ctypes.c_double]
    library.MagickSetPointsize.restype = ctypes.c_int

    library.MagickGetGravity.argtypes = [ctypes.c_void_p]
    library.MagickGetGravity.restype = ctypes.c_int

    library.MagickSetGravity.argtypes = [ctypes.c_void_p,
                                         ctypes.c_int]
    library.MagickSetGravity.restype = ctypes.c_int

    library.MagickSetLastIterator.argtypes = [ctypes.c_void_p]

    library.MagickGetBackgroundColor.argtypes = [ctypes.c_void_p]
    library.MagickGetBackgroundColor.restype = ctypes.c_void_p

    library.MagickSetBackgroundColor.argtypes = [ctypes.c_void_p,
                                                 ctypes.c_void_p]
    library.MagickSetBackgroundColor.restype = ctypes.c_int

    library.MagickGetOption.argtypes = [ctypes.c_void_p,
                                        ctypes.c_char_p]
    library.MagickGetOption.restype = ctypes.c_char_p

    library.MagickSetOption.argtypes = [ctypes.c_void_p,
                                        ctypes.c_char_p,
                                        ctypes.c_char_p]
    library.MagickSetOption.restype = ctypes.c_int

    library.MagickDeleteOption.argtypes = [ctypes.c_void_p,
                                           ctypes.c_char_p]
    library.MagickDeleteOption.restype = ctypes.c_int

    library.MagickGetAntialias.argtypes = [ctypes.c_void_p]
    library.MagickGetAntialias.restype = ctypes.c_int

    library.MagickSetAntialias.argtypes = [ctypes.c_void_p,
                                           ctypes.c_int]
    library.MagickSetAntialias.restype = ctypes.c_int

    library.MagickGetImageHistogram.argtypes = [
        ctypes.c_void_p,
        ctypes.POINTER(ctypes.c_size_t)
    ]
    library.MagickGetImageHistogram.restype = ctypes.POINTER(ctypes.c_void_p)

    # These functions are const so it's okay for them to be c_char_p
    libmagick.GetMagickVersion.argtypes = [ctypes.POINTER(ctypes.c_size_t)]
    libmagick.GetMagickVersion.restype = ctypes.c_char_p

    libmagick.GetMagickReleaseDate.argtypes = []
    libmagick.GetMagickReleaseDate.restype = ctypes.c_char_p

    libmagick.GetMagickQuantumDepth.argtypes = [
        ctypes.POINTER(ctypes.c_size_t)
    ]
    libmagick.GetMagickQuantumDepth.restype = ctypes.c_char_p

    library.NewDrawingWand.restype = ctypes.c_void_p

    library.CloneDrawingWand.argtypes = [ctypes.c_void_p]
    library.CloneDrawingWand.restype = ctypes.c_void_p

    library.DestroyDrawingWand.argtypes = [ctypes.c_void_p]
    library.DestroyDrawingWand.restype = ctypes.c_void_p

    library.IsDrawingWand.argtypes = [ctypes.c_void_p]
    library.IsDrawingWand.restype = ctypes.c_int

    library.DrawGetException.argtypes = [ctypes.c_void_p,
                                         ctypes.POINTER(ctypes.c_int)]
    library.DrawGetException.restype = ctypes.c_char_p

    library.DrawClearException.argtypes = [ctypes.c_void_p]
    library.DrawClearException.restype = ctypes.c_int

    library.DrawAffine.argtypes = [
        ctypes.c_void_p,  # Drawing wand
        ctypes.POINTER(AffineMatrix),  # AffineMatrix
    ]

    library.DrawComment.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_char_p,  # comment
    ]

    library.DrawComposite.argtypes = [
        ctypes.c_void_p,  # DrawingWand wand
        ctypes.c_int,     # CompositeOperator
        ctypes.c_double,  # x
        ctypes.c_double,  # y
        ctypes.c_double,  # width
        ctypes.c_double,  # height
        ctypes.c_void_p,  # MagickWand wand
    ]
    library.DrawComposite.restype = ctypes.c_uint

    library.DrawSetBorderColor.argtypes = [ctypes.c_void_p,  # wand
                                           ctypes.c_void_p]  # PixelWand color

    library.DrawSetClipPath.argtypes = [ctypes.c_void_p,  # wand
                                        ctypes.c_char_p]  # clip_mask
    library.DrawSetClipPath.restype = ctypes.c_int

    library.DrawSetClipRule.argtypes = [ctypes.c_void_p,  # wand
                                        ctypes.c_uint]    # FillRule

    library.DrawSetClipUnits.argtypes = [ctypes.c_void_p,  # wand
                                         ctypes.c_uint]    # ClipPathUnits

    library.DrawSetFont.argtypes = [ctypes.c_void_p,
                                    ctypes.c_char_p]

    library.DrawSetFontFamily.argtypes = [ctypes.c_void_p,  # wand
                                          ctypes.c_char_p]  # font_family
    library.DrawSetFontFamily.restype = ctypes.c_uint

    library.DrawSetFontResolution.argtypes = [ctypes.c_void_p,  # wand
                                              ctypes.c_double,  # x
                                              ctypes.c_double]  # y
    library.DrawSetFontResolution.restype = ctypes.c_uint

    library.DrawSetFontSize.argtypes = [ctypes.c_void_p,
                                        ctypes.c_double]

    library.DrawSetFontStretch.argtypes = [ctypes.c_void_p,  # wand
                                           ctypes.c_int]     # font_stretch

    library.DrawSetFontStyle.argtypes = [ctypes.c_void_p,  # wand
                                         ctypes.c_int]     # style

    library.DrawSetFontWeight.argtypes = [ctypes.c_void_p,  # wand
                                          ctypes.c_size_t]  # font_weight

    library.DrawSetFillColor.argtypes = [ctypes.c_void_p,
                                         ctypes.c_void_p]

    library.DrawSetFillOpacity.argtypes = [ctypes.c_void_p,
                                           ctypes.c_double]

    library.DrawSetFillPatternURL.argtypes = [ctypes.c_void_p,  # wand
                                              ctypes.c_char_p]  # fill_url
    library.DrawSetFillPatternURL.restype = ctypes.c_uint

    library.DrawSetFillRule.argtypes = [ctypes.c_void_p,
                                        ctypes.c_uint]

    library.DrawSetOpacity.argtypes = [ctypes.c_void_p, ctypes.c_double]

    library.DrawSetStrokeAntialias.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_int,     # stroke_antialias
    ]

    library.DrawSetStrokeColor.argtypes = [ctypes.c_void_p,
                                           ctypes.c_void_p]

    library.DrawSetStrokeDashArray.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_size_t,  # number_elements
        ctypes.POINTER(ctypes.c_double),
    ]

    library.DrawSetStrokeDashOffset.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # dash_offset
    ]

    library.DrawSetStrokeLineCap.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_int,     # linecap
    ]

    library.DrawSetStrokeLineJoin.argtypes = [ctypes.c_void_p,  # wand
                                              ctypes.c_int]     # linejoin

    library.DrawSetStrokeMiterLimit.argtypes = [ctypes.c_void_p,  # wand
                                                ctypes.c_size_t]  # miterlimit

    library.DrawSetStrokeOpacity.argtypes = [ctypes.c_void_p,  # wand
                                             ctypes.c_double]  # stroke_opacity

    library.DrawSetStrokePatternURL.argtypes = [ctypes.c_void_p,  # wand
                                                ctypes.c_char_p]  # fill_url
    library.DrawSetStrokePatternURL.restype = ctypes.c_uint

    library.DrawSetStrokeWidth.argtypes = [ctypes.c_void_p,
                                           ctypes.c_double]

    library.DrawSetTextAlignment.argtypes = [ctypes.c_void_p,
                                             ctypes.c_int]

    library.DrawSetTextAntialias.argtypes = [ctypes.c_void_p,
                                             ctypes.c_int]

    library.DrawSetTextDecoration.argtypes = [ctypes.c_void_p,
                                              ctypes.c_int]

    try:
        library.DrawSetTextDirection.argtypes = [ctypes.c_void_p,
                                                 ctypes.c_int]
    except AttributeError:
        library.DrawSetTextDirection = None

    library.DrawSetTextEncoding.argtypes = [ctypes.c_void_p,
                                            ctypes.c_char_p]

    try:
        library.DrawSetTextInterlineSpacing.argtypes = [ctypes.c_void_p,
                                                        ctypes.c_double]
    except AttributeError:
        library.DrawSetTextInterlineSpacing = None

    library.DrawSetTextInterwordSpacing.argtypes = [ctypes.c_void_p,
                                                    ctypes.c_double]

    library.DrawSetTextKerning.argtypes = [ctypes.c_void_p,
                                           ctypes.c_double]

    library.DrawSetTextUnderColor.argtypes = [ctypes.c_void_p,
                                              ctypes.c_void_p]

    library.DrawSetVectorGraphics.argtypes = [ctypes.c_void_p,
                                              ctypes.c_char_p]

    library.DrawSetVectorGraphics.restype = ctypes.c_int

    library.DrawResetVectorGraphics.argtypes = [ctypes.c_void_p]

    library.DrawSetViewbox.argtypes = [ctypes.c_void_p,   # wand
                                       ctypes.c_ssize_t,  # x1
                                       ctypes.c_ssize_t,  # y1
                                       ctypes.c_ssize_t,  # x2
                                       ctypes.c_ssize_t]  # y2

    library.DrawGetBorderColor.argtypes = [ctypes.c_void_p,  # wand
                                           ctypes.c_void_p]  # PixelWand color

    library.DrawGetClipPath.argtypes = [ctypes.c_void_p]
    library.DrawGetClipPath.restype = c_magick_char_p

    library.DrawGetClipRule.argtypes = [ctypes.c_void_p]
    library.DrawGetClipRule.restype = ctypes.c_uint

    library.DrawGetClipUnits.argtypes = [ctypes.c_void_p]
    library.DrawGetClipUnits.restype = ctypes.c_uint

    library.DrawGetFillColor.argtypes = [ctypes.c_void_p,
                                         ctypes.c_void_p]

    library.DrawGetFillOpacity.argtypes = [ctypes.c_void_p]
    library.DrawGetFillOpacity.restype = ctypes.c_double

    library.DrawGetFillRule.argtypes = [ctypes.c_void_p]
    library.DrawGetFillRule.restype = ctypes.c_uint

    library.DrawGetOpacity.argtypes = [ctypes.c_void_p]
    library.DrawGetOpacity.restype = ctypes.c_double

    library.DrawGetStrokeAntialias.argtypes = [ctypes.c_void_p]
    library.DrawGetStrokeAntialias.restype = ctypes.c_int

    library.DrawGetStrokeColor.argtypes = [ctypes.c_void_p,
                                           ctypes.c_void_p]

    library.DrawGetStrokeDashArray.argtypes = [
        ctypes.c_void_p,
        ctypes.POINTER(ctypes.c_size_t),
    ]
    library.DrawGetStrokeDashArray.restype = ctypes.POINTER(ctypes.c_double)

    library.DrawGetStrokeDashOffset.argtypes = [ctypes.c_void_p]
    library.DrawGetStrokeDashOffset.restype = ctypes.c_double

    library.DrawGetStrokeLineCap.argtypes = [ctypes.c_void_p]
    library.DrawGetStrokeLineCap.restype = ctypes.c_int

    library.DrawGetStrokeLineJoin.argtypes = [ctypes.c_void_p]
    library.DrawGetStrokeLineJoin.restype = ctypes.c_int

    library.DrawGetStrokeMiterLimit.argtypes = [ctypes.c_void_p]
    library.DrawGetStrokeMiterLimit.restype = ctypes.c_size_t

    library.DrawGetStrokeOpacity.argtypes = [ctypes.c_void_p]
    library.DrawGetStrokeOpacity.restype = ctypes.c_double

    library.DrawGetStrokeWidth.argtypes = [ctypes.c_void_p]
    library.DrawGetStrokeWidth.restype = ctypes.c_double

    library.DrawGetFont.argtypes = [ctypes.c_void_p]
    library.DrawGetFont.restype = c_magick_char_p

    library.DrawGetFontFamily.argtypes = [ctypes.c_void_p]
    library.DrawGetFontFamily.restype = c_magick_char_p

    library.DrawGetFontResolution.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.POINTER(ctypes.c_double),  # x
        ctypes.POINTER(ctypes.c_double),  # y
    ]
    library.DrawGetFontResolution.restype = ctypes.c_uint

    library.DrawGetFontSize.argtypes = [ctypes.c_void_p]
    library.DrawGetFontSize.restype = ctypes.c_double

    library.DrawGetFontStyle.argtypes = [ctypes.c_void_p]
    library.DrawGetFontStyle.restype = ctypes.c_int

    library.DrawGetFontWeight.argtypes = [ctypes.c_void_p]
    library.DrawGetFontWeight.restype = ctypes.c_size_t

    library.DrawGetFontStretch.argtypes = [ctypes.c_void_p]
    library.DrawGetFontStretch.restype = ctypes.c_int

    library.DrawGetTextAlignment.argtypes = [ctypes.c_void_p]
    library.DrawGetTextAlignment.restype = ctypes.c_int

    library.DrawGetTextAntialias.argtypes = [ctypes.c_void_p]
    library.DrawGetTextAntialias.restype = ctypes.c_int

    library.DrawGetTextDecoration.argtypes = [ctypes.c_void_p]
    library.DrawGetTextDecoration.restype = ctypes.c_int

    try:
        library.DrawGetTextDirection.argtypes = [ctypes.c_void_p]
        library.DrawGetTextDirection.restype = ctypes.c_int
    except AttributeError:
        library.DrawGetTextDirection = None

    library.DrawGetTextEncoding.argtypes = [ctypes.c_void_p]
    library.DrawGetTextEncoding.restype = c_magick_char_p

    try:
        library.DrawGetTextInterlineSpacing.argtypes = [ctypes.c_void_p]
        library.DrawGetTextInterlineSpacing.restype = ctypes.c_double
    except AttributeError:
        library.DrawGetTextInterlineSpacing = None

    library.DrawGetTextInterwordSpacing.argtypes = [ctypes.c_void_p]
    library.DrawGetTextInterwordSpacing.restype = ctypes.c_double

    library.DrawGetTextKerning.argtypes = [ctypes.c_void_p]
    library.DrawGetTextKerning.restype = ctypes.c_double

    library.DrawGetTextUnderColor.argtypes = [ctypes.c_void_p,
                                              ctypes.c_void_p]

    library.DrawGetVectorGraphics.argtypes = [ctypes.c_void_p]
    library.DrawGetVectorGraphics.restype = c_magick_char_p

    library.DrawSetGravity.argtypes = [ctypes.c_void_p,
                                       ctypes.c_int]

    library.DrawGetGravity.argtypes = [ctypes.c_void_p]
    library.DrawGetGravity.restype = ctypes.c_int

    library.MagickAnnotateImage.argtypes = [ctypes.c_void_p,
                                            ctypes.c_void_p,
                                            ctypes.c_double,
                                            ctypes.c_double,
                                            ctypes.c_double,
                                            ctypes.c_char_p]
    library.MagickAnnotateImage.restype = ctypes.c_int

    library.MagickDistortImage.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_int,     # method
        ctypes.c_size_t,  # number_arguments
        ctypes.POINTER(ctypes.c_double),  # arguments
        ctypes.c_int,     # bestfit
    ]
    library.MagickDistortImage.restype = ctypes.c_int

    library.ClearDrawingWand.argtypes = [ctypes.c_void_p]

    library.MagickDrawImage.argtypes = [ctypes.c_void_p,
                                        ctypes.c_void_p]
    library.MagickDrawImage.restype = ctypes.c_int

    library.DrawAnnotation.argtypes = [ctypes.c_void_p,
                                       ctypes.c_double,
                                       ctypes.c_double,
                                       ctypes.POINTER(ctypes.c_ubyte)]

    library.DrawArc.argtypes = [ctypes.c_void_p,  # wand
                                ctypes.c_double,  # sx
                                ctypes.c_double,  # sy
                                ctypes.c_double,  # ex
                                ctypes.c_double,  # ey
                                ctypes.c_double,  # sd
                                ctypes.c_double]  # ed

    library.DrawBezier.argtypes = [ctypes.c_void_p,
                                   ctypes.c_ulong,
                                   ctypes.POINTER(PointInfo)]

    library.DrawCircle.argtypes = [ctypes.c_void_p,  # wand
                                   ctypes.c_double,  # ox
                                   ctypes.c_double,  # oy
                                   ctypes.c_double,  # px
                                   ctypes.c_double]  # py

    library.DrawColor.argtypes = [ctypes.c_void_p,  # wand
                                  ctypes.c_double,  # x
                                  ctypes.c_double,  # y
                                  ctypes.c_uint]    # PaintMethod

    library.DrawEllipse.argtypes = [ctypes.c_void_p,  # wand
                                    ctypes.c_double,  # ox
                                    ctypes.c_double,  # oy
                                    ctypes.c_double,  # rx
                                    ctypes.c_double,  # ry
                                    ctypes.c_double,  # start
                                    ctypes.c_double]  # end

    library.DrawLine.argtypes = [ctypes.c_void_p,
                                 ctypes.c_double,
                                 ctypes.c_double,
                                 ctypes.c_double,
                                 ctypes.c_double]

    library.DrawMatte.argtypes = [ctypes.c_void_p,  # wand
                                  ctypes.c_double,  # x
                                  ctypes.c_double,  # y
                                  ctypes.c_uint]    # PaintMethod

    library.DrawPathClose.argtypes = [ctypes.c_void_p]  # wand

    library.DrawPathCurveToAbsolute.argtypes = [ctypes.c_void_p,  # wand
                                                ctypes.c_double,  # x1
                                                ctypes.c_double,  # y1
                                                ctypes.c_double,  # x2
                                                ctypes.c_double,  # y2
                                                ctypes.c_double,  # x
                                                ctypes.c_double]  # y

    library.DrawPathCurveToRelative.argtypes = [ctypes.c_void_p,  # wand
                                                ctypes.c_double,  # x1
                                                ctypes.c_double,  # y1
                                                ctypes.c_double,  # x2
                                                ctypes.c_double,  # y2
                                                ctypes.c_double,  # x
                                                ctypes.c_double]  # y

    library.DrawPathCurveToQuadraticBezierAbsolute.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # x1
        ctypes.c_double,  # y1
        ctypes.c_double,  # x
        ctypes.c_double,  # y
    ]

    library.DrawPathCurveToQuadraticBezierRelative.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # x1
        ctypes.c_double,  # y1
        ctypes.c_double,  # x
        ctypes.c_double,  # y
    ]

    library.DrawPathCurveToQuadraticBezierSmoothAbsolute.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # x
        ctypes.c_double,  # y
    ]

    library.DrawPathCurveToQuadraticBezierSmoothRelative.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # x
        ctypes.c_double,  # y
    ]

    library.DrawPathCurveToSmoothAbsolute.argtypes = [ctypes.c_void_p,  # wand
                                                      ctypes.c_double,  # x2
                                                      ctypes.c_double,  # y2
                                                      ctypes.c_double,  # x
                                                      ctypes.c_double]  # y

    library.DrawPathCurveToSmoothRelative.argtypes = [ctypes.c_void_p,  # wand
                                                      ctypes.c_double,  # x2
                                                      ctypes.c_double,  # y2
                                                      ctypes.c_double,  # x
                                                      ctypes.c_double]  # y

    library.DrawPathEllipticArcAbsolute.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # rx
        ctypes.c_double,  # ry
        ctypes.c_double,  # rotation
        ctypes.c_uint,    # arc_flag
        ctypes.c_uint,    # sweep_flag
        ctypes.c_double,  # x
        ctypes.c_double,  # y
    ]

    library.DrawPathEllipticArcRelative.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # rx
        ctypes.c_double,  # ry
        ctypes.c_double,  # rotation
        ctypes.c_uint,    # arc_flag
        ctypes.c_uint,    # sweep_flag
        ctypes.c_double,  # x
        ctypes.c_double,  # y
    ]

    library.DrawPathFinish.argtypes = [ctypes.c_void_p]  # wand

    library.DrawPathLineToAbsolute.argtypes = [ctypes.c_void_p,  # wand
                                               ctypes.c_double,  # x
                                               ctypes.c_double]  # y

    library.DrawPathLineToRelative.argtypes = [ctypes.c_void_p,  # wand
                                               ctypes.c_double,  # x
                                               ctypes.c_double]  # y

    library.DrawPathLineToHorizontalAbsolute.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # x
    ]

    library.DrawPathLineToHorizontalRelative.argtypes = [
        ctypes.c_void_p,  # wand
        ctypes.c_double,  # x
    ]

    library.DrawPathLineToVerticalAbsolute.argtypes = [ctypes.c_void_p,  # wand
                                                       ctypes.c_double]  # y

    library.DrawPathLineToVerticalRelative.argtypes = [ctypes.c_void_p,  # wand
                                                       ctypes.c_double]  # y

    library.DrawPathMoveToAbsolute.argtypes = [ctypes.c_void_p,  # wand
                                               ctypes.c_double,  # x
                                               ctypes.c_double]  # y

    library.DrawPathMoveToRelative.argtypes = [ctypes.c_void_p,  # wand
                                               ctypes.c_double,  # x
                                               ctypes.c_double]  # y

    library.DrawPathStart.argtypes = [ctypes.c_void_p]  # wand

    library.DrawPoint.argtypes = [ctypes.c_void_p,  # wand
                                  ctypes.c_double,  # x
                                  ctypes.c_double]  # y

    library.DrawPolygon.argtypes = [ctypes.c_void_p,
                                    ctypes.c_ulong,
                                    ctypes.POINTER(PointInfo)]

    library.DrawPolyline.argtypes = [ctypes.c_void_p,
                                     ctypes.c_ulong,
                                     ctypes.POINTER(PointInfo)]

    library.DrawRotate.argtypes = [ctypes.c_void_p,  # wand
                                   ctypes.c_double]  # degree

    library.DrawRectangle.argtypes = [ctypes.c_void_p,
                                      ctypes.c_double,
                                      ctypes.c_double,
                                      ctypes.c_double,
                                      ctypes.c_double]

    library.DrawRoundRectangle.argtypes = [ctypes.c_void_p,  # wand
                                           ctypes.c_double,  # x1
                                           ctypes.c_double,  # y1
                                           ctypes.c_double,  # x2
                                           ctypes.c_double,  # y2
                                           ctypes.c_double,  # rx
                                           ctypes.c_double]  # ry

    library.DrawScale.argtypes = [ctypes.c_void_p,  # wand
                                  ctypes.c_double,  # x
                                  ctypes.c_double]  # y

    library.DrawSkewX.argtypes = [ctypes.c_void_p,  # wand
                                  ctypes.c_double]  # degree

    library.DrawSkewY.argtypes = [ctypes.c_void_p,  # wand
                                  ctypes.c_double]  # degree

    library.DrawTranslate.argtypes = [ctypes.c_void_p,  # wand
                                      ctypes.c_double,  # x
                                      ctypes.c_double]  # y

    # -- Drawing stack management --
    library.PushDrawingWand.argtypes = [ctypes.c_void_p]
    library.PushDrawingWand.restype = ctypes.c_uint
    library.DrawPushClipPath.argtypes = [ctypes.c_void_p,  # wand
                                         ctypes.c_char_p]  # clip_mask_id
    library.DrawPushDefs.argtypes = [ctypes.c_void_p]
    library.DrawPushPattern.argtypes = [ctypes.c_void_p,  # wand
                                        ctypes.c_char_p,  # clip_mask_id
                                        ctypes.c_double,  # x
                                        ctypes.c_double,  # y
                                        ctypes.c_double,  # width
                                        ctypes.c_double]  # height
    library.DrawPushClipPath.restype = ctypes.c_uint
    library.PopDrawingWand.argtypes = [ctypes.c_void_p]
    library.PopDrawingWand.restype = ctypes.c_uint
    library.DrawPopClipPath.argtypes = [ctypes.c_void_p]
    library.DrawPopDefs.argtypes = [ctypes.c_void_p]
    library.DrawPopPattern.argtypes = [ctypes.c_void_p]

    library.MagickNegateImage.argtypes = [ctypes.c_void_p, ctypes.c_int]

    library.MagickNegateImageChannel.argtypes = [ctypes.c_void_p,
                                                 ctypes.c_int,
                                                 ctypes.c_int]

    library.MagickNormalizeImage.argtypes = [ctypes.c_void_p]

    library.MagickNormalizeImageChannel.argtypes = [ctypes.c_void_p,
                                                    ctypes.c_int]

    library.MagickEqualizeImage.argtypes = [ctypes.c_void_p]

    library.MagickQueryConfigureOption.argtypes = [ctypes.c_char_p]
    library.MagickQueryConfigureOption.restype = c_magick_char_p

    library.MagickQueryConfigureOptions.argtypes = [
        ctypes.c_char_p,
        ctypes.POINTER(ctypes.c_size_t),
    ]
    library.MagickQueryConfigureOptions.restype = \
        ctypes.POINTER(c_magick_char_p)

    library.MagickQueryFontMetrics.argtypes = [ctypes.c_void_p,
                                               ctypes.c_void_p,
                                               ctypes.c_char_p]
    library.MagickQueryFontMetrics.restype = ctypes.POINTER(ctypes.c_double)

    library.MagickQueryFonts.argtypes = [ctypes.c_char_p,
                                         ctypes.POINTER(ctypes.c_size_t)]
    library.MagickQueryFonts.restype = ctypes.POINTER(c_magick_char_p)

    library.MagickQueryFormats.argtypes = [ctypes.c_char_p,
                                           ctypes.POINTER(ctypes.c_size_t)]
    library.MagickQueryFormats.restype = ctypes.POINTER(c_magick_char_p)

    library.MagickQueryMultilineFontMetrics.argtypes = [ctypes.c_void_p,
                                                        ctypes.c_void_p,
                                                        ctypes.c_char_p]
    library.MagickQueryMultilineFontMetrics.restype = ctypes.POINTER(
        ctypes.c_double
    )

    library.MagickThresholdImage.argtypes = [ctypes.c_void_p, ctypes.c_double]

    library.MagickThresholdImageChannel.argtypes = [ctypes.c_void_p,
                                                    ctypes.c_int,
                                                    ctypes.c_double]

    library.MagickModulateImage.argtypes = [ctypes.c_void_p,
                                            ctypes.c_double,
                                            ctypes.c_double,
                                            ctypes.c_double]

    library.MagickAppendImages.argtypes = [ctypes.c_void_p,
                                           ctypes.c_int]
    library.MagickAppendImages.restype = ctypes.c_void_p

    library.MagickTransposeImage.argtypes = [ctypes.c_void_p]
    library.MagickTransverseImage.argtypes = [ctypes.c_void_p]

    library.MagickQuantizeImage.argtypes = [ctypes.c_void_p,
                                            ctypes.c_int,
                                            ctypes.c_int,
                                            ctypes.c_int,
                                            ctypes.c_bool,
                                            ctypes.c_bool]

except AttributeError:
    raise ImportError('MagickWand shared library not found or incompatible\n'
                      'Original exception was raised in:\n' +
                      traceback.format_exc())

try:
    library.MagickAutoOrientImage.argtypes = [ctypes.c_void_p]
except AttributeError:
    # MagickAutoOrientImage was added in 6.8.9+, we have a fallback function
    # so we pass silently if we cannot import it
    pass


#: (:class:`ctypes.CDLL`) The C standard library.
libc = None

if platform.system() == 'Windows':
    msvcrt = ctypes.util.find_msvcrt()
    # workaround -- the newest visual studio DLL is named differently:
    if not msvcrt and "1900" in platform.python_compiler():
        msvcrt = "vcruntime140.dll"
    if msvcrt:
        libc = ctypes.CDLL(msvcrt)
else:
    if platform.system() == 'Darwin':
        try:
            libc = ctypes.cdll.LoadLibrary('libc.dylib')
        except OSError:
            # In case of El Capitan SIP
            libc = ctypes.cdll.LoadLibrary('/usr/lib/libc.dylib')
    elif sys.platform.startswith(('dragonfly', 'freebsd')):
        libc = ctypes.cdll.LoadLibrary(ctypes.util.find_library('c'))
    else:
        libc = ctypes.cdll.LoadLibrary('libc.so.6')
    libc.fdopen.argtypes = [ctypes.c_int, ctypes.c_char_p]
    libc.fdopen.restype = ctypes.c_void_p
    libc.fflush.argtypes = [ctypes.c_void_p]
