Initial commit

[magickd.git] / source / magickd / core / c / image.d

/*               Copyright (C) kaerou 2021.
** Distributed under the Boost Software License, Version 1.0.
**    (See accompanying file LICENSE_1_0.txt or copy at
**          https://www.boost.org/LICENSE_1_0.txt)
*/
module magickd.core.c.image;

private
{
    import core.stdc.config : c_long, c_ulong;
    import core.stdc.stdio : FILE;

    import magickd.core.c.common;
    import magickd.core.c.colorspace;
    import magickd.core.c.error;
    import magickd.core.c.timer;
}

@nogc @system extern(C):

enum QuantumDepth = 16;

static if (QuantumDepth == 8)
{
    enum MaxColormapSize = 256U;
    enum MaxMap = 255U;
    enum MaxMapDepth = 8;
    enum MaxMapFloat = 255.0f;
    enum MaxMapDouble = 255.0;
    enum MaxRGB = 255U;
    enum MaxRGBFloat = 255.0f;
    enum MaxRGBDouble = 255.0;
    /* TODO: Scale functions */
    alias Quantum = ubyte;
}
else static if (QuantumDepth == 16)
{
    enum MaxColormapSize = 65536U;
    enum MaxMap = 65535U;
    enum MaxMapDepth = 16;
    enum MaxMapFloat = 65535.0f;
    enum MaxMapDouble = 65535.0;
    enum MaxRGB = 65535U;
    enum MaxRGBFloat = 65535.0f;
    enum MaxRGBDouble = 65535.0;
    /* TODO: Scale functions */
    alias Quantum = ushort;
}
else static if (QuenatumDepth == 32)
{
    enum MaxColormapSize = 65536U;
    enum MaxRGB = 4294967295U;
    enum MaxRGBFloat = 4294967295.0f;
    enum MaxRGBDouble = 4294967295.0;
    /* MaxMap defines the maximum index value for algorithms which depend on
     * lookup tables (e.g. colorspace transformations and normalizations).
     * When MaxMap is less than MaxRGB it is necessary to downscale samples to
     * fit the range of MaxMap.  The number of bits which are effectively
     * preserved depend on the size of MaxMap.  MaxMap should be a multiple of
     * 255 and no larger the MaxRGB.  Note that tables can become quite large
     * and as tables grow larger it may take more time to compute the table
     * than to process the image. */
    enum MaxMap = 65535U;
    enum MaxMapDepth = 16;
    enum MaxMapFloat = 65535.0f;
    enum MaxMapDouble = 65535.0;
    
    static if (MaxMap == 65535U)
    {
        /* TODO: Scale functions */
    }
    else
    {
        /* TODO: Scale functions */
    }
    alias Quantum = uint;
}
else
{
    static assert(false, "Specified value of QuantumDepth is not supported");
}


alias AlphaType = int;
enum : int
{
    UnspecifiedAlpha,
    AssociatedAlpha,
    UnassociatedAlpha
}

alias ChannelType = int;
enum : int
{
    UndefinedChannel,
    RedChannel,     /* RGB Red channel */
    CyanChannel,    /* CMYK Cyan channel */
    GreenChannel,   /* RGB Green channel */
    MagentaChannel, /* CMYK Magenta channel */
    BlueChannel,    /* RGB Blue channel */
    YellowChannel,  /* CMYK Yellow channel */
    OpacityChannel, /* Opacity channel */
    BlackChannel,   /* CMYK Black (K) channel */
    MatteChannel,   /* Same as Opacity channel (deprecated) */
    AllChannels,    /* Color channels */
    GrayChannel     /* Color channels represent an intensity. */
}

/// ClassType enumeration specifies the image storage class.
alias ClassType = int;
enum : int
{
    /// Unset values
    UndefinedClass,
    /// Image is composed of pixels which represent literal color values.
    DirectClass,
    /// Image is composed of pixels which specify an index in a color palette.
    PseudoClass
}

/++
 + CompositeOperator is used to select the image composition algorithm used to
 + compose a "composite image" with an "image".
 +
 + By default, each of the "composite image" pixels are replaced by the
 + corresponding "image" tile pixel.  Specify CompositeOperator to select a
 + different algorithm.
 +
 + The image compositor requires a matte, or alpha channel in the image for
 + some operations.  This extra channel usually defines a mask which
 + represents a sort of a cookie-cutter for the image.  This is the case when
 + matte is 255 (full coverage) for pixels inside the shape, zero outside, and
 + between zero and 255 on the boundary.  For certain operations, if "image"
 + does not have a matte channel, it is initialized with `0` for any pixel
 + matching in color to pixel location `(0, 0)`, otherwise 255 (to work
 + properly borderWidth must be `0`).
 +/
alias CompositeOperator = int;
/// Ditto
enum : int
{
    /++
     + Unset value.
     +/
    UndefinedCompositeOp = 0,
    /++
     + The result is the union of the two image shapes with the "composite
     + image" obscuring the "image" in the region of overlap.
     +/
    OverCompositeOp,
    /++
     + The result is a simply "composite image" cut by the shape of "image".
     + None of the image data of "image" is included in the result.
     +/
    InCompositeOp,
    /++
     + The resulting image is "composite image" with the shape of "image" cut
     + out.
     +/
    OutCompositeOp,
    /++
     + The result is the same shape as "image", with "composite image"
     + obscuring "image" where the image shapes overlap.
     +
     + Note that this differs from `OverCompositeOp` because the portion of
     + "composite image" outside of "image"'s shape does not appear in the
     + result.
     +/
    AtopCompositeOp,
    /++
     + The result is the image data from both "composite image" and "image"
     + that is outside the overlap region.
     +
     + The overlap region will be blank.
     +/
    XorCompositeOp,
    /++
     + The result is just the sum of image data.
     +
     + Output values are cropped to 255 (no overflow).  This operation is
     + independent of the matte channels.
     +/
    PlusCompositeOp,
    /++
     + The result of `"composite image" - "image"`, with overflow cropped to
     + zero.
     +
     + The matte channel is ignored (set to 255, full coverate).
     +/
    MinusCompositeOp,
    /++
     + The result of `"composite image" + "image"`, with overflow wrapping
     + around (mod 256).
     +/
    AddCompositeOp,
    /++
     + The result of `"composite image" - "image"`, with underflow wrapping
     + around (mod 256).
     +
     + The add and subtract operators can be used to perform reversible
     + transformations.
     +/
    SubtractCompositeOp,
    /++
     + The result of `abs("composite image" - "image")`.
     +
     + This is useful for comparing two very similar images.
     +/
    DifferenceCompositeOp,
    /++
     + The result image shaded by "composite image".
     +/
    BumpmapCompositeOp,
    /++
     + The resulting image is "image" replaced with "composite image".
     +
     + Here the matte information is ignored.
     +/
    CopyCompositeOp,
    /++
     + The resulting image is the red layer in "image" replaced with the red
     + layer in the "composite image".
     +
     + The othe layers are copied untouched.
     +/
    CopyRedCompositeOp,
    /++
     + The resulting image is the green layer in "image" replaced with the
     + green layer in the "composite image".
     +
     + The othe layers are copied untouched.
     +/
    CopyGreenCompositeOp,
    /++
     + The resulting image is the blue layer in "image" replaced with the blue
     + layer in the "composite image".
     +
     + The othe layers are copied untouched.
     +/
    CopyBlueCompositeOp,
    /++
     + The resulting image is the matte layer in "image" replaced with the
     + matte layer in the "composite image".
     +
     + The othe layers are copied untouched.
     +/
    CopyOpacityCompositeOp,
    /++
     + Pixels in the region are set to Transparent.
     +/
    ClearCompositeOp,
    DissolveCompositeOp,
    DisplaceCompositeOp,
    /++
     + Modulate brightness in HSL space.
     +/
    ModulateCompositeOp,
    ThresholdCompositeOp,
    /++
     + Do nothing at all.
     +/
    NoCompositeOp,
    DarkenCompositeOp,
    LightenCompositeOp,
    /++
     + Copy Hue channel (from HSL colorspace)
     +/
    HueCompositeOp,
    /++
     + Copy Saturation channel (from HSL colorspace)
     +/
    SaturateCompositeOp,
    /++
     + Copy Hue and Saturation channels (from HSL colorspace)
     +/
    ColorizeCompositeOp,
    /++
     + Copy Brightness channel (from HSL colorspace)
     +/
    LuminizeCompositeOp,
    /// [Not yet implemented]
    ScreenCompositeOp,
    /// [Not yet implemented]
    OverlayCompositeOp,
    /++
     + Copy the Cyan channel.
     +/
    CopyCyanCompositeOp,
    /++
     + Copy the Magenta channel.
     +/
    CopyMagentaCompositeOp,
    /++
     + Copy the Yellow channel.
     +/
    CopyYellowCompositeOp,
    /++
     + Copy the Black channel.
     +/
    CopyBlackCompositeOp,
    DivideCompositeOp,
    HardLightCompositeOp,
    ExclusionCompositeOp,
    ColorDodgeCompositeOp,
    ColorBurnCompositeOp,
    SoftLightCompositeOp,
    LinearBurnCompositeOp,
    LinearDodgeCompositeOp,
    LinearLightCompositeOp,
    VividLightCompositeOp,
    PinLightCompositeOp,
    HardMixCompositeOp
}

/++
 + CompressionType is used to express the desired compression type when
 + encoding an image.
 +
 + Be aware that most image types only support a sub-set of the available
 + compression types.  If the compression type specified is incompatible with
 + the image, Magick will select a compression type compatible with the image
 + type, which might be no compression at all.
 +/
alias CompressionType = int;
/// Ditto
enum : int
{
    /// Unset value
    UndefinedCompression,
    /// No compression
    NoCompression,
    /++
     + BZip (Burrows-Wheeler block-sorting text compression algorithm and
     + Huffman coding) as used by bzip2 utilities.
     +/
    BZipCompression,
    /// CCITT Group 3 FAX compression
    FaxCompression,
    /// CCITT Group 4 FAX compression (used only for TIFF)
    Group4Compression,
    /// JPEG compression
    JPEGCompression,
    /// Lossless JPEG compression
    LosslessJPEGCompression,
    /// Lempel-Ziv-Welch (LZW) compression (caution: patented by Unisys)
    LZWCompression,
    /// Run-Length encoded (RLE) compression
    RLECompression,
    /// Lempel-Ziv compression (LZ77) as used in PKZIP and GNU gzip.
    ZipCompression,
    /// LZMA - Lempel-Ziv-Markov chain algorithm
    LZMACompression,
    /// JPEG 2000 - ISO/IEC std 15444-1
    JPEG2000Compression,
    /// JBIG v1 - ISO/IEC std 11544 / ITU-T rec T.82
    JBIG1Compression,
    /// JBIG v2 - ISO/IEC std 14492 / ITU-T rec T.88
    JBIG2Compression,
    /// Facebook's Zstandard/Zstd
    ZSTDCompression,
    /// Google's WebP
    WebPCompression,
}

alias DisposeType = int;
enum : int
{
    UndefinedDispose,
    NoneDispose,
    BackgroundDispose,
    PreviousDispose
}

alias EndianType = int;
enum : int
{
    UndefinedEndian,
    LSBEndian,    /* "little" endian */
    MSDEndian,    /* "big" endian */
    NativeEndian  /* native endian */
}

alias FilterTypes = int;
enum : int
{
    UndefinedFilter,
    PointFilter,
    BoxFilter,
    TriangleFilter,
    HermiteFilter,
    HanningFilter,
    HammingFilter,
    BlackmanFilter,
    GaussianFilter,
    QuadraticFilter,
    CubicFilter,
    CatromFilter,
    MitchellFilter,
    LanczosFilter,
    BesselFilter,
    SincFilter
}

/++
 + GravityType specifies positioning of an object (e.g. text, image) within a
 + bouding region (e.g. an image).
 +
 + Gravity provides a convenient way to locate objects irrespective of the
 + size of the bounding region, in other words, you don't need to provide
 + absolute coordinates in order to position an object.  A common default for
 + gravity is NorthWestGravity.
 +/
alias GravityType = int;
/// Ditto
enum : int
{
    /// Don't use gravity.
    ForgetGravity,
    /// Position object at top-left of region.
    NorthWestGravity,
    /// Position object at top-center of region.
    NorthGravity,
    /// Position object at top-right of region.
    NorthEastGravity,
    /// Position object at left-center of region.
    WestGravity,
    /// Position object at center of region.
    CenterGravity,
    /// Position object at right-center of region.
    EastGravity,
    /// Position object at left-bottom of region.
    SouthWestGravity,
    /// Position object at bottom-center of region.
    SouthGravity,
    /// Position object at bottom-right of region.
    SouthEastGravity,
    StaticGravity
}

/++
 + ImageType indicates the type classification of the image.
 +/
alias ImageType = int;
/// Ditto
enum : int
{
    /// Unset value
    UndefinedType,
    /// Monochrome image.
    BilevelType,
    /// Grayscale image.
    GrayscaleType,
    /// Grayscale image with opacity
    GrayscaleMatteType,
    /// Indexed color (palette) image.
    PaletteType,
    /// Indexed color (palette) image with opacity.
    PaletteMatteType,
    /// Truecolor image.
    TrueColorType,
    /// Truecolor image with opacity.
    TrueColorMatteType,
    /// Cyan/Yellow/Magenta/Black (CYMK) image
    ColorSeparationType,
    /// Cyan/Yellow/Magenta/Black (CYMK) image with opacity.
    ColorSeparationMatteType,
    OptimizeType
}

/++
 + InterlaceType specifies the ordering of the red, green, and blue pixel
 + information in the image.
 +
 + Interlacing is usually used to make image information available to the user
 + faster by taking advantage of the space vs. time tradeoff.  For example,
 + interlacing allows images on the Web to be recognizable sooner and
 + satellite images to accumulate/render with image resolution increasing over
 + time.
 +
 + Use `LineInterlace` or `PlaneInterlace` to create an interlace GIF or
 + progressive JPEG image.
 +/
alias InterlaceType = int;
/// Ditto
enum : int
{
    /++
     + Unset value.
     +/
    UndefinedInterlace,
    /++
     + Don't interlace image (RGBRGBRGBRGBRGBRGB...)
     +/
    NoInterlace,
    /++
     + Use scanline interlacing (RRR...GGG...BBB...RRR...GGG...BBB)
     +/
    LineInterlace,
    /++
     + Use plane interlacing (RRRRRR...GGGGGG...BBBBBB...)
     +/
    PlaneInterlace,
    /++
     + Similar to plane interlacing except that the different planes are
     + saved to individual files (e.g. image.R, image.G, and image.B)
     +/
    PartitionInterlace
}

/++
 + NoiseType is used as an argument to select the type of noise to be added to
 + the image.
 +/
alias NoiseType = int;
/// Ditto
enum : int
{
    UniformNoise,
    GaussianNoise,
    MultiplicativeGaussianNoise,
    ImpulseNoise,
    LaplacianNoise,
    PoissonNoise,
    RandomNoise,
    UndefinedNoise
}

/++
 + OrientationType specifies the orientation of the image.
 +
 + Useful for when the image is produced via a different ordinate system, the
 + camera was turned on its side, or the page was scanned sideways.
 +/
alias OrientationType = int;
/// Ditto
enum : int
{
    /// Scanline dir: Unknown; Frame dir: Unknown
    UndefinedOrientation,
    /// Scanline dir: Left to Right; Frame dir: Top to Bottom
    TopLeftOrientation,
    /// Scanline dir: Right to Left; Frame dir: Top to Bottom
    TopRightOrientation,
    /// Scanline dir: Right to Left; Frame dir: Bottom to Top
    BottomRightOrientation,
    /// Scanline dir: Left to Right; Frame dir: Bottom to Top
    BottomLeftOrientation,
    /// Scanline dir: Top to Bottom; Frame dir: Left to Right
    LeftTopOrientation,
    /// Scanline dir: Top to Bottom; Frame dir: Right to Left
    RightTopOrientation,
    /// Scanline dir: Bottom to Top; Frame dir: Right to Left
    RightBottomOrientation,
    /// Scanline dir: Bottom to Top; Frame dir: Left to Right
    LeftBottomOrientation
}

/++
 + Rendering intent is a concept defined by ICC Spec ICC.1:1998-09, "File
 + Format for Color Profiles".
 +
 + GraphicsMagick uses RenderingIntent in order to support ICC Color Profiles.
 +
 + From the specification:
 + "Rendering intent specifies the style of reproduction to be used during the
 + evaluation of this profile in a sequence of profiles.  It applies
 + specifically to that profile in the sequence and not to th entire sequence.
 + Typically, the user or application will set the rendering intent
 + dynamically at runtime or embedding time."
 +/
alias RenderingIntent = int;
/// Ditto
enum : int
{
    /++
     + Unset value.
     +/
    UndefinedIntent,
    /++
     + A rendering intent that specifies the saturation of the pixels in the
     + image is preserved perhaps at the expense of accuracy in hue and
     + lightness.
     +/
    SaturationIntent,
    /++
     + A rendering intent that specifies the full gamut of the image is
     + compressed or expanded to fill the gamut of the destination device.
     +
     + Gray balance is preserved but colorimetric accuracy might not be
     + preseved.
     +/
    PerceptualIntent,
    /++
     + Absolute colorimetric.
     +/
    AbsoluteIntent,
    /++
     + Relative colorimetric
     +/
    RelativeIntent
}

/++
 + By default, Magick defines resolution pixels per inch.
 +
 + ResolutionType provides a means to adjust this.
 +/
alias ResolutionType = int;
/// Ditto
enum : int
{
    /// Unset Value.
    UndefinedResolution,
    /++
     + Density specifications are specified in units of pixels per inch
     + (english units).
     +/
    PixelsPerInchResolution,
    /++
     + Density specifications are specified in units of pixels per centimeter
     + (metric units).
     +/
    PixelsPerCentimeterResolution
}


/+
 + --------------------------------------------------------------------------
 +                           Structure  Definitions                          
 + --------------------------------------------------------------------------
+/

struct AffineMatrix
{
    double
        sx,
        rx,
        ry,
        sy,
        tx,
        ty;
}

struct PrimaryInfo
{
    double x,
        y,
        z;
}

/++
 + The ChromaticityInfo structure is used to represent chromaticity
 + (colorspace primary coordinates in xy space) values for images in Magick.
 +/
struct ChromaticityInfo
{
    /// Chromaticity red primary point (e.g. x=0.64, y=0.33)
    PrimaryInfo red_primary;
    /// Chromaticity green primary point (e.g. x=3, y=0.6)
    PrimaryInfo green_primary;
    /// Chromaticity blue primary point (e.g. x=0.15, y=0.06)
    PrimaryInfo blue_primary;
    /// Chromaticity white point (e.g. x=0.3127, y=0.329)
    PrimaryInfo white_point;
}

struct PixelPacket
{
    version(BigEndian) {
        /* RGBA */
//        enum MAGICK_PIXELS_RGBA = 1;
        Quantum red,
            green,
            blue,
            opacity;
    }
    else {
        /* BGRA (as used by Microsoft Windows DIB) */
//        enum MAGICK_PIXELS_BGRA = 1;
        Quantum blue,
            green,
            red,
            opacity;
    }
}

struct DoublePixelPacket
{
    double red,
        green,
        blue,
        opacity;
}

struct FloatPixelPacket
{
    float red,
        green,
        blue,
        opacity;
}

/++
 + ErrorInfo is used to record statistical difference (error) information
 + based on computed Euclidean distance in RGB space.
 +/
struct ErrorInfo
{
    /// Average error per pixel (absolute range).
    double mean_error_per_pixel;
    /// Average error per pixel (normalized to 1.0).
    double normalized_mean_error;
    /// Maximum error encountered (normalized to 1.0).
    double normalized_maximum_error;
}

/++
 + The RectangleInfo structure is used to represent positioning information
 + in GraphicsMagick.
 +/
struct RectangleInfo
{
    /// Rectangle width
    c_ulong width;
    /// Rectangle height
    c_ulong height;
    /// Rectangle horizontal offset
    c_long x;
    /// Rectangle vertical offset.
    c_long y;
}

/* forward decl. */
struct _ImageExtra;
struct _CacheInfo;
struct _ThreadViewSet;
struct _ImageAttribute;
struct _Ascii85Info;
struct _BlobInfo;
struct _SemaphoreInfo;

/++
 + The image structure represents a Magick image.
 +
 + It is initially allocated by AllocateImage() and deallocated by
 + DestroyImage().  The functions ReadImage(), ReadImages(), BlobToImage,
 + and CreateImage() return a new Image.  Use CloneImage() to copy an image.
 + An image consists of a structure containing image attributes as well as the
 + image pixels.
 +/
struct Image
{
    /++
     + Image storage class.
     +
     + If DirectClass then the image packets contain valid RGB or CMYK colors.
     + If PseudoClass then the image has a colormap referenced by pixel's
     + index member.
     +/
    ClassType storage_class;
    /++
     + Image pixel interpretation.
     +
     + If the colorspace is RGB the pixels are red, green, blue. If matte is
     + true, then red, green, blue, and index.  If it is CMYK, the pixels are
     + cyan, yellow, magenta, black.  Otherwise, the colorspace is ignored.
     +/
    ColorspaceType colorspace;
    /++
     + Image compression type.
     +
     + The default compression type of the specified image file.
     +/
    CompressionType compression;
    /++
     + Should the image be dithered.
     +/
    MagickBool dither;
    /++
     + If non-zero, then the index member of pixels represents the alpha
     + channel.
     +/
    MagickBool matte;
    /++
     + Image width.
     +/
    c_ulong columns;
    /++
     + Image height.
     +/
    c_ulong rows;
    /++
     + The desired number of colors.
     +
     + Used by QuantizeImage().
     +/
    uint colors;
    /++
     + Image depth.
     +
     + Number of encoding bits per sample.  Usually 8 or 16, but sometimes
     + 10 or 12.
     +/
    uint depth;
    /++
     + PseudoColor palette array.
     +/
    PixelPacket* colormap;
    /++
     + Image background color.
     +/
    PixelPacket background_color;
    /++
     + Image border color.
     +/
    PixelPacket border_color;
    /++
     + Image matte (transparent) color.
     +/
    PixelPacket matte_color;
    double gamma;
    ChromaticityInfo chromaticity;
    OrientationType orientation;
    RenderingIntent rendering_intent;
    ResolutionType units;
    char* montage;
    char* directory;
    char* geometry;
    c_long offset;
    double x_resolution;
    double y_resolution;
    RectangleInfo page;
    RectangleInfo tile_info;
    double blur;
    double fuzz;
    FilterTypes filter;
    InterlaceType interlace;
    EndianType endian;
    GravityType gravity;
    CompositeOperator compose;
    DisposeType dispose;
    c_ulong scene;
    c_ulong delay;
    c_ulong iterations;
    c_ulong total_colors;
    c_long start_loop;
    ErrorInfo error;
    TimerInfo timer;
    void* client_data;
    char[MaxTextExtent] filename;
    char[MaxTextExtent] magick_filename;
    char[MaxTextExtent] magick;
    c_ulong magick_columns;
    c_ulong magick_rows;
    ExceptionInfo exception;
    Image* previous;
    Image* next;
    
    /* private */
    void* profiles;
    uint is_monochrome,
        is_grayscale,
        taint;
    
    _ImageExtra* extra;
    
    MagickBool ping;
    
    _CacheInfo* cache;
    _ThreadViewSet* default_views;
    _ImageAttribute* attributes;
    _Ascii85Info* ascii85;
    _BlobInfo* blob;
    
    c_long reference_count;
    
    _SemaphoreInfo* semaphore;
    
    uint logging;
    
    Image* list;
    c_ulong signature;
}

struct ImageInfo
{
    /++
     + Image compresion type.
     +
     + The default is the compression type of the specified image file.
     +/
    CompressionType compression;
    /++
     + Remove file "filename" once it has been read.
     +/
    MagickBool temporary;
    /++
     + Join images into a single multi-image file.
     +/
    MagickBool adjoin;
    /++
     + Control antialiasing of rendered Postscript and Postscript or TrueType
     + fonts.  Enabled by default.
     +/
    MagickBool antialias;
    /++
     + Subimage of an image sequence.
     +/
    c_ulong subimage;
    /++
     + Number of images relative to the base image.
     +/
    c_ulong subrange;
    /++
     + Image depth (8 or 16).
     +/
    c_ulong depth;
    /++
     + Width and height of a raw image (an image which does not support width
     + and height information).
     +
     + Size may also be used to affect the image size read from a
     + multi-resolution format (e.g. Photo CD, JBIG, or JPEG).
     +/
    char* size;
    /++
     + Tile name.
     +/
    char* tile;
    /++
     + Equivalent size of Postscript page.
     +/
    char* page;
    /++
     + The type of interlacing scheme (default NoInterlace).
     +
     + This option is used to specify the type of interlacing scheme for raw
     + image formats such as RGB or YUV.  NoInterlace means to not interlace,
     + LineInterlace uses scanline interlacing, and PlaneInterlace uses plane
     + interlacing.  PartitionInterlace is like PlaneInterlace except the
     + different planes are saved to individual files (e.g. image.R, image.G,
     + and image.B).  Use LineInterlace or PlaneInterlace to create an
     + interlaced GIF or progressive JPEG image.
     +/
    InterlaceType interlace;
    /++
     + Select MSB/LSB endian output for TIFF format.
     +/
    EndianType endian;
    /++
     + Units of image resolution.
     +/
    ResolutionType units;
    /++
     + JPEG/MIFF/PNG compression level (default 75).
     +/
    c_ulong quality;
    /++
     + JPEG, MPEG, and YUV chroma downsample factor.
     +/
    char* sampling_factor;
    /++
     + X11 display to obtain fonts from, or to capture image from.
     +/
    char* sever_name;
    /++
     + Text rendering font.
     +
     + If the font is a fully qualified X server font name, the font is
     + obtained from an X server.  To use a TrueType font, precede the
     + TrueType filename with an `@`.  Otherwise, specify a Postscript font
     + name (e.g. "helvetica").
     +/
    char* font;
    /++
     + Image filename to use as background texture.
     +/
    char* texture;
    /++
     + Vertical and horizontal resolution in pixels of the image.
     +
     + This option specifies an image density when decoding a Postscript or
     + Portable Document page.  Often used with page.
     +/
    char* density;
    /++
     + Text rendering font point size.
     +/
    double pointsize;
    /++
     + Colors within this distance are considered equal.
     +
     + A number of algorithms seach for a target color.  By default the color
     + must be exact.  Use this option to match colors that are close to the
     + target color in RGB space.
     +/
    double fuzz;
    /++
     + Stroke or fill color while drawing.
     +/
    PixelPacket pen;
    /++
     + Image background color
     +/
    PixelPacket background_color;
    /++
     + Image border color.
     +/
    PixelPacket border_color;
    /++
     + Image matte (transparent) color.
     +/
    PixelPacket matte_color;
    /++
     + Apply Floyd/Steinberg error diffusion to the image.
     +
     + The basic strategy of dithering is to trade intensity resolution for
     + spacial resolution by averaging the intesities of several neighboring
     + pixels.  Images which suffer from severe contouring when reducing
     + colors can be improved with this option.  The colors or monochrome
     + option must be set for this option to take effect.
     +/
    MagickBool dither;
    /++
     + Transform the image to black and white.
     +/
    MagickBool monochrome;
    /++
     + Show progress indication.
     +/
    MagickBool progress;
    /++
     + Image pixel interpretation.
     +
     + If the colorspace is RGB the pixels are red, green, blue.  If `matte`
     + is true, then red, green, blue, and index.  If it is CMYK, the pixels
     + are cyan, yellow, magenta, black.  Otherwise the colorspace is ignored.
     +/
    ColorspaceType colorspace;
    /++
     + Desired image type (used while reading or writing).
     +/
    ImageType type;
    /++
     + X11 Window group ID
     +/
    c_long group;
    /++
     + Print detailed information about the image if True.
     +/
    uint verbose;
    /++
     + FlashPix viewing parameters.
     +/
    char* view;
    /++
     + Password used to decrypt file.
     +/
    char* authenticate;
    /++
     + User-specified data to pass to coder.
     +/
    void* client_data;
    /++
     + stdio stream to read image from or write image to.
     +
     + If set, Magick will read from or write to the stream rather than
     + opening a file.  Used by ReadImage() and WriteImage().  The stream is
     + closed when the operation completes.
     +/
    FILE* file;
    /++
     + Image encoding format (e.g. "GIF").
     +/
    char[MaxTextExtent] magick;
    /++
     + Image file name to read or write.
     +/
    char[MaxTextExtent] filename;
    
    /* XXX: haven't done private members yet, wonder if they're needed to
     * complete this */
}


/+
 + --------------------------------------------------------------------------
 +                              Image  Functions
 + --------------------------------------------------------------------------
+/


/++
 + AccessDefinition() searches the definitions for an entry matching the
 + specified magick and key.
 +
 + NULL is returned if no matching entry is found.
 +
 + Params:
 +   image_info = The image info.
 +   magick = Format ID. This is usually the same as the coder name.
 +   key = The key to search for.
 +/
const(char)* AccessDefinition(const ImageInfo* image_info, const char* magick,
                             const char* key);

/++
 + AddDefinition() adds a key/value definition to the current map of
 + definitions in ImageInfo.
 +
 + Definitions may be used by coders/decoders that read and write images.
 +
 + Params:
 +   image_info = The image info.
 +   magick = Format/classification identifier.
 +   key = Subidentifier within format/classification.
 +   value = Definition value
 +   exception = Errors result in updates to this structure.
 +/
MagickPassFail AddDefinition(ImageInfo* image_info, const char* magick,
                             const char* key, const char* value,
                             ExceptionInfo* exception);

/++
 + CloneImageInfo() copies an image and returns the copy as a new image
 + object.
 +
 + If the specified `columns and `rows` is `0`, an exact copy of the image is
 + returned, otherwise, the pixel data is undefined and must be initialzed
 + with the SetImagePixels() and SyncImagePixels() methods.  On failure, a
 + NULL image is returned and `exception` describes the reason for failure.
 +
 + Params:
 +   image = The image
 +   columns = The number of columns in the cloned image.
 +   rows = The numbe of rows in the cloned image.
 +   orphan = With a value other than 0, the cloned image is an orphan.  An
 + orphan is a stand-alone image that is not associated with an image list.
 + In effect, the next and previous members of the cloned image is set to
 + NULL.
 +   exception = Return any errors or warnings to this structure.
 +/
Image* CloneImage(const Image* image, const c_ulong columns,
                  const c_ulong rows, const uint orphan,
                  ExceptionInfo* exception);

/++
 + CloneImageInfo() makes a copy of the given `ImageInfo` structure.
 +
 + If NULL is specified, a new image info structure is created an initialized
 + to default values.
 +
 + Params:
 +  image_info = The image info
 +/
ImageInfo* CloneImageInfo(const ImageInfo* image_info);

/++
 + DestroyImage() dereferences an image, deallocating memory associated with
 + the image if the reference count becomes zero.
 +
 + There is no effect if the image pointer is null.
 +
 + In the interest of avoiding dangling pointers or memory leaks, the image
 + previous and next pointers should be null when this function is called, and
 + no othe image should refer to it.  In the future this may be enforced.
 +
 + Params:
 +   image = The image.
 +/
void DestroyImage(Image* image);

/++
 + DestroyImageInfo() deallocates memory associated with an `ImageInfo`
 + structure.
 +
 + Params:
 +   image_info = The image info.
 +/
void DestroyImageInfo(ImageInfo* image_info);