(* ImageEn Build 7.0.0.06.2637 @ 7-4-17 14:58:42.679 *)
(*
Copyright (c) 1998-2017 by Carlotta Calandra. All rights reserved.
Copyright (c) 2011-2017 by Xequte Software.

This software comes without express or implied warranty.
In no case shall the author be liable for any damage or unwanted behavior of any
computer hardware and/or software.

Author grants you the right to include the component
in your application, whether COMMERCIAL, SHAREWARE, or FREEWARE.

ImageEn, IEvolution and ImageEn ActiveX may not be included in any
commercial, shareware or freeware libraries or components.

www.ImageEn.com
*)

(*
File version 1001
*)


unit iemiscplugins;

{$R-}
{$Q-}
{$J+}
{$Z4}

{$I ie.inc}


interface

uses
  Windows, Messages, Classes, Graphics, SysUtils, hyiedefs, imageenio, hyieutils, iesettings, iexBitmaps;


{$IFDEF IEINCLUDEMISCPLUGINS}


///////////////////////////////////////////////////////////////////////////////////////////////////////
// TIEMiscPluginsImageMagick

const iomscFITS   = ioMiscDLLPlugIns + 1;
const iomscPCD    = ioMiscDLLPlugIns + 2;
const iomscPCL    = ioMiscDLLPlugIns + 3;
const iomscPDF    = ioMiscDLLPlugIns + 4;
const iomscBIE    = ioMiscDLLPlugIns + 5;
const iomscCIN    = ioMiscDLLPlugIns + 6;
const iomscDDS    = ioMiscDLLPlugIns + 7;
const iomscDFONT  = ioMiscDLLPlugIns + 8;
const iomscDPX    = ioMiscDLLPlugIns + 9;
const iomscJBIG   = ioMiscDLLPlugIns + 10;
const iomscJNG    = ioMiscDLLPlugIns + 11;
const iomscM2V    = ioMiscDLLPlugIns + 12;
const iomscMAT    = ioMiscDLLPlugIns + 13;
const iomscMIFF   = ioMiscDLLPlugIns + 14;
const iomscMNG    = ioMiscDLLPlugIns + 15;
const iomscMP4    = ioMiscDLLPlugIns + 16;
const iomscMSVG   = ioMiscDLLPlugIns + 17;
const iomscPES    = ioMiscDLLPlugIns + 18;
const iomscPS     = ioMiscDLLPlugIns + 19;
const iomscPSB    = ioMiscDLLPlugIns + 20;
const iomscPTIF   = ioMiscDLLPlugIns + 21;
const iomscSVG    = ioMiscDLLPlugIns + 22;
const iomscTIFF64 = ioMiscDLLPlugIns + 23;
const iomscXCF    = ioMiscDLLPlugIns + 24;
const iomscXPS    = ioMiscDLLPlugIns + 25;

const Min_ImageMagick_Type = iomscFITS;
const Max_ImageMagick_Type = iomscXPS;

const IEIMAGEMAGICK_WAND_DLL_FILENAMES: array [0..1] of WideString   = ('CORE_RL_wand_.dll', 'CORE_RL_MagickWand_.dll');
const IEIMAGEMAGICK_MAGICK_DLL_FILENAMES: array [0..1] of WideString = ('CORE_RL_magick_.dll', 'CORE_RL_MagickCore_.dll');

type TIEImageMagick_MagickWand        = pointer;
type TIEImageMagick_MagickBooleanType = longbool;
type TIEImageMagick_size_t            = {$ifdef WIN64} uint64; {$else} dword; {$endif}
type TIEImageMagick_ssize_t           = {$ifdef WIN64} int64; {$else} integer; {$endif}
type TIEImageMagick_MagickOffsetType  = int64;
type TIEImageMagick_MagickSizeType    = uint64;
type TIEImageMagick_MagicInfo         = pointer;
type TIEImageMagick_ExceptionInfo     = pointer;
type TIEImageMagick_ExceptionType     = integer;
type TIEImageMagick_PixelWand         = pointer;

type TIEImageMagick_StorageType = (
                                    imck_UndefinedPixel,
                                    imck_CharPixel,
                                    imck_DoublePixel,
                                    imck_FloatPixel,
                                    imck_IntegerPixel,
                                    imck_LongPixel,
                                    imck_QuantumPixel,
                                    imck_ShortPixel
                                  );

type TIEImageMagick_ChannelType = (
                                    imck_UndefinedChannel    = 0,
                                    imck_RedChannel          = $0001,
                                    imck_GrayChannel         = $0001,
                                    imck_CyanChannel         = $0001,
                                    imck_GreenChannel        = $0002,
                                    imck_MagentaChannel      = $0002,
                                    imck_BlueChannel         = $0004,
                                    imck_YellowChannel       = $0004,
                                    imck_AlphaChannel        = $0008,
                                    imck_OpacityChannel      = $0008,
                                    imck_MatteChannel        = $0008,
                                    imck_BlackChannel        = $0020,
                                    imck_IndexChannel        = $0020,
                                    imck_CompositeChannels   = $002F,
                                    imck_AllChannels         = $7ffffff,
                                    imck_TrueAlphaChannel    = $0040,
                                    imck_RGBChannels         = $0080,
                                    imck_GrayChannels        = $0080,
                                    imck_SyncChannels        = $0100,
                                    imck_DefaultChannels     = $7FFFFF7
                                  );

type TIEImageMagick_ColorspaceType = (
                                    imck_UndefinedColorspace,
                                    imck_RGBColorspace,
                                    imck_GRAYColorspace,
                                    imck_TransparentColorspace,
                                    imck_OHTAColorspace,
                                    imck_LabColorspace,
                                    imck_XYZColorspace,
                                    imck_YCbCrColorspace,
                                    imck_YCCColorspace,
                                    imck_YIQColorspace,
                                    imck_YPbPrColorspace,
                                    imck_YUVColorspace,
                                    imck_CMYKColorspace,
                                    imck_sRGBColorspace,
                                    imck_HSBColorspace,
                                    imck_HSLColorspace,
                                    imck_HWBColorspace,
                                    imck_Rec601LumaColorspace,
                                    imck_Rec601YCbCrColorspace,
                                    imck_Rec709LumaColorspace,
                                    imck_Rec709YCbCrColorspace,
                                    imck_LogColorspace,
                                    imck_CMYColorspace,
                                    imck_LuvColorspace,
                                    imck_HCLColorspace,
                                    imck_LCHColorspace,
                                    imck_LMSColorspace,
                                    imck_LCHabColorspace,
                                    imck_LCHuvColorspace,
                                    imck_scRGBColorspace,
                                    imck_HSIColorspace,
                                    imck_HSVColorspace,
                                    imck_HCLpColorspace,
                                    imck_YDbDrColorspace
                                  );

type TIEImageMagick_ResolutionType = (
                                    imck_UndefinedResolution,
                                    imck_PixelsPerInchResolution,
                                    imck_PixelsPerCentimeterResolution
                                    );

type TIEImageMagick_ImageType = (
                                    imck_UndefinedType,
                                    imck_BilevelType,
                                    imck_GrayscaleType,
                                    imck_GrayscaleMatteType,
                                    imck_PaletteType,
                                    imck_PaletteMatteType,
                                    imck_TrueColorType,
                                    imck_TrueColorMatteType,
                                    imck_ColorSeparationType,
                                    imck_ColorSeparationMatteType,
                                    imck_OptimizeType,
                                    imck_PaletteBilevelMatteType
                                    );

type TIEImageMagick_MagickProgressMonitor = function(text: PAnsiChar; offset: TIEImageMagick_MagickOffsetType; span: TIEImageMagick_MagickSizeType; client_data: pointer): TIEImageMagick_MagickBooleanType; cdecl;


procedure TIEMiscPluginsImageMagick_ReadImageStream(Stream: TStream; Bitmap: TIEBitmap; var IOParams: TIOParams; var Progress: TProgressRec; Preview: boolean);
procedure TIEMiscPluginsImageMagick_WriteImageStream(Stream: TStream; Bitmap: TIEBitmap; var IOParams: TIOParams; var Progress: TProgressRec);
function TIEMiscPluginsImageMagick_TryImageStream(Stream: TStream; TryingFormat: TIOFileType): boolean;
function TIEMiscPluginsImageMagick_PDFFrameCount(Stream: TStream): integer;


{!!
<FS>TIEMiscPluginsImageMagick

<FM>Declaration<FC>
TIEMiscPluginsImageMagick = class;

<FM>Description<FN>
TIEMiscPluginsImageMagick is a wrapper around ImageMagick library, allowing ImageEn to load many formats like PDF, PS, PCD and many others.
To setup ImageMagick wrapper just call, one time, the <A TIEMiscPluginsImageMagick.RegisterPlugin> class method.

You can download ImageMagick from:
<L http://www.imagemagick.org/script/binary-releases.php#windows>http://www.imagemagick.org/script/binary-releases.php#windows</L>

In order to load PDF, PS, PCL and  you must install the Ghostscript library:
<L http://www.ghostscript.com/download/>http://www.ghostscript.com/download/</L>

<FM>Methods and Properties<FN>
<TABLE2>
<R> <C_IMG_METHOD> <C><A TIEMiscPluginsImageMagick.IsAvailable></C> </R>
<R> <C_IMG_METHOD> <C><A TIEMiscPluginsImageMagick.RegisterPlugin></C> </R>
</TABLE>

<FM>Demo<FN>
<TABLE2>
<R> <C_IMG_DEMO> <C>Demos\InputOutput\ImageMagick\ImageMagick.dpr </C> </R>
</TABLE>

<FM>Example<FC>
// rasterizes page number 5 of mybook.pdf at 200dpi
TIEMiscPluginsImageMagick.RegisterPlugin(); // call only one time!
ImageEnView1.IO.Params.ImageIndex := 5;
ImageEnView1.IO.Params.Dict.Insert('PDF:Density', 200);
ImageEnView1.IO.LoadFromFile('mybook.pdf');
!!}
type TIEMiscPluginsImageMagick = class

  public

    class function IsAvailable(): boolean;
    class procedure Initialize(reinitialize: boolean = true);
    class procedure Finalize();
    class procedure RegisterPlugin();

  private
  
    class function HandleWand(Handle: THandle = 0; Setup: boolean = false): THandle;
    class function HandleMagick(Handle: THandle = 0; Setup: boolean = false): THandle;
    class procedure CheckCallWand(var exec: pointer; name: AnsiString);
    class procedure CheckCallMagick(var exec: pointer; name: AnsiString);

  public
  
    // MagickWand API wrappers
    class procedure MagickWandGenesis();
    class procedure MagickWandTerminus();
    class function NewMagickWand(): TIEImageMagick_MagickWand;
    class function DestroyMagickWand(wand: TIEImageMagick_MagickWand): TIEImageMagick_MagickWand;
    class function MagickReadImage(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType;
    class function MagickReadImageBlob(wand: TIEImageMagick_MagickWand; blob: pointer; length: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType;
    class function MagickPingImageBlob(wand: TIEImageMagick_MagickWand; blob: pointer; length: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType;
    class function MagickPingImage(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType;
    class procedure MagickResetIterator(wand: TIEImageMagick_MagickWand);
    class function MagickNextImage(wand: TIEImageMagick_MagickWand): TIEImageMagick_MagickBooleanType;
    class function MagickSetIteratorIndex(wand: TIEImageMagick_MagickWand; index: TIEImageMagick_ssize_t): TIEImageMagick_MagickBooleanType;
    class procedure MagickSetLastIterator(wand: TIEImageMagick_MagickWand);
    class function MagickGetIteratorIndex(wand: TIEImageMagick_MagickWand): TIEImageMagick_ssize_t;
    class function MagickExportImagePixels(wand: TIEImageMagick_MagickWand; x: TIEImageMagick_ssize_t; y: TIEImageMagick_ssize_t; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; map: PAnsiChar; storage: TIEImageMagick_StorageType; pixels: pointer): TIEImageMagick_MagickBooleanType;
    class function MagickGetImageWidth(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t;
    class function MagickGetImageHeight(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t;
    class function MagickGetImageChannelDepth(wand: TIEImageMagick_MagickWand; channel: TIEImageMagick_ChannelType): TIEImageMagick_size_t;
    class function MagickGetImageColorspace(wand: TIEImageMagick_MagickWand): TIEImageMagick_ColorspaceType;
    class function MagickSetImageColorspace(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType;
    class function MagickTransformImageColorspace(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType;
    class function MagickGetImageDepth(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t;
    class function MagickGetImageResolution(wand: TIEImageMagick_MagickWand; var x: double; var y: double): TIEImageMagick_MagickBooleanType;
    class function MagickGetImageUnits(wand: TIEImageMagick_MagickWand): TIEImageMagick_ResolutionType;
    class function MagickGetImageFormat(wand: TIEImageMagick_MagickWand): PAnsiChar;
    class function MagickGetType(wand: TIEImageMagick_MagickWand): TIEImageMagick_ImageType;
    class function MagickSetImageType(wand: TIEImageMagick_MagickWand; image_type: TIEImageMagick_ImageType): TIEImageMagick_MagickBooleanType;
    class function MagickIdentifyImageType(wand: TIEImageMagick_MagickWand): TIEImageMagick_ImageType;
    class function MagickSetProgressMonitor(wand: TIEImageMagick_MagickWand; progress_monitor: TIEImageMagick_MagickProgressMonitor; client_data: pointer): TIEImageMagick_MagickProgressMonitor;
    class function MagickSetImageProperty(wand: TIEImageMagick_MagickWand; prop: PAnsiChar; value: PAnsiChar): TIEImageMagick_MagickBooleanType;
    class function MagickSetOption(wand: TIEImageMagick_MagickWand; key: PAnsiChar; value: PAnsiChar): TIEImageMagick_MagickBooleanType;
    class function MagickGetException(wand: TIEImageMagick_MagickWand; var severity: TIEImageMagick_ExceptionType): PAnsiChar;
    class function MagickRelinquishMemory(resource: pointer): pointer;
    class function MagickSetColorspace(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType;
    class function MagickSetDepth(wand: TIEImageMagick_MagickWand; depth: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType;
    class function MagickSetFormat(wand: TIEImageMagick_MagickWand; format: PAnsiChar): TIEImageMagick_MagickBooleanType;
    class function MagickSetResolution(wand: TIEImageMagick_MagickWand; x_resolution: double; y_resolution: double): TIEImageMagick_MagickBooleanType;
    class function MagickSetImageUnits(wand: TIEImageMagick_MagickWand; units: TIEImageMagick_ResolutionType): TIEImageMagick_MagickBooleanType;
    class function MagickGetImageBlob(wand: TIEImageMagick_MagickWand; var length: TIEImageMagick_size_t): pbyte;
    class function MagickWriteImage(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType;
    class function MagickWriteImages(wand: TIEImageMagick_MagickWand; filename: PAnsiChar; adjoin: TIEImageMagick_MagickBooleanType): TIEImageMagick_MagickBooleanType;
    class function MagickImportImagePixels(wand: TIEImageMagick_MagickWand; x: TIEImageMagick_ssize_t; y: TIEImageMagick_ssize_t; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; map: PAnsiChar; storage: TIEImageMagick_StorageType; pixels: pointer): TIEImageMagick_MagickBooleanType;
    class function MagickNewImage(wand: TIEImageMagick_MagickWand; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; background: TIEImageMagick_PixelWand): TIEImageMagick_MagickBooleanType;
    class function NewPixelWand(): TIEImageMagick_PixelWand;
    class function DestroyPixelWand(pixelWand: TIEImageMagick_PixelWand): TIEImageMagick_PixelWand;

    // MagickCore API wrappers
    class function GetMagicInfo(magic: pointer; length: TIEImageMagick_size_t; exception: TIEImageMagick_ExceptionInfo): TIEImageMagick_MagicInfo;
    class function GetMagicName(magic_info: TIEImageMagick_MagicInfo): PAnsiChar;
    class function AcquireExceptionInfo(): TIEImageMagick_ExceptionInfo;
    class function DestroyExceptionInfo(e: TIEImageMagick_ExceptionInfo): TIEImageMagick_ExceptionInfo;
    //class function GetAuthenticPixels(image: TIEImageMagick_Image; x: TIEImageMagick_ssize_t; y: TIEImageMagick_ssize_t; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; exception: TIEImageMagick_ExceptionInfo): TIEImageMagick_PixelPacket;
end;

// TIEMiscPluginsImageMagick
///////////////////////////////////////////////////////////////////////////////////////////////////////


implementation

uses
  imageenproc;


var
  IEMiscPluginsCS: TRTLCriticalSection;


///////////////////////////////////////////////////////////////////////////////////////////////////////
// TIEMiscPluginsImageMagick


type TIEMiscPluginsImageMagick_Format = record
  Typ: TIOFileType;    // Const for this file type
  Des: string;         // Description of file type
  Ext: string;         // Extensions of this file type
  Sue: string;         // Most common extension for the file type
  Wrt: boolean;        // Whether writing is supported for this type
end;

const
  ImageMagickFormats: array [0..24] of TIEMiscPluginsImageMagick_Format = (
    (Typ: iomscFITS;   Des: 'Flexible Image Transport System';                        Ext: 'FITS;FTS';                 Sue: 'fits';   Wrt: true),
    (Typ: iomscPCD;    Des: 'Photo CD';                                               Ext: 'PCD;PCDS';                 Sue: 'pcd';    Wrt: true),
    (Typ: iomscPCL;    Des: 'Printer Control Language';                               Ext: 'PCL';                      Sue: 'pcl';    Wrt: true),
    (Typ: iomscPDF;    Des: 'Portable Document Format';                               Ext: 'PDF;PDFA;EPDF';            Sue: 'pdf';    Wrt: true),
    (Typ: iomscBIE;    Des: 'Joint Bi-level Image experts Group interchange format';  Ext: 'BIE';                      Sue: 'bie';    Wrt: true),
    (Typ: iomscCIN;    Des: 'Cineon Image File';                                      Ext: 'CIN';                      Sue: 'cin';    Wrt: true),
    (Typ: iomscDDS;    Des: 'Microsoft DirectDraw Surface';                           Ext: 'DDS';                      Sue: 'dds';    Wrt: true),
    (Typ: iomscDFONT;  Des: 'Multi-face font package';                                Ext: 'DFONT';                    Sue: 'dfont';  Wrt: false),
    (Typ: iomscDPX;    Des: 'SMPTE 268M-2003 (DPX 2.0)';                              Ext: 'DPX';                      Sue: 'dpx';    Wrt: true),
    (Typ: iomscJBIG;   Des: 'Joint Bi-level Image experts Group interchange format';  Ext: 'JBIG;JBG';                 Sue: 'jbig';   Wrt: true),
    (Typ: iomscJNG;    Des: 'JPEG Network Graphics';                                  Ext: 'JNG';                      Sue: 'jng';    Wrt: true),
    (Typ: iomscM2V;    Des: 'MPEG Video Stream';                                      Ext: 'M2V;MOV;MPEG;MPG';         Sue: 'm2v';    Wrt: true),
    (Typ: iomscMAT;    Des: 'MATLAB level 5 image format';                            Ext: 'MAT';                      Sue: 'mat';    Wrt: true),
    (Typ: iomscMIFF;   Des: 'Magick Image File Format';                               Ext: 'MIFF';                     Sue: 'miff';   Wrt: true),
    (Typ: iomscMNG;    Des: 'Multiple-image Network Graphics';                        Ext: 'MNG';                      Sue: 'mng';    Wrt: true),
    (Typ: iomscMP4;    Des: 'MPEG-4 Video';                                           Ext: 'MP4;M4V';                  Sue: 'mp4';    Wrt: true),
    (Typ: iomscMSVG;   Des: 'ImageMagick''s own SVG internal renderer';               Ext: 'MSVG';                     Sue: 'msvg';   Wrt: true),
    (Typ: iomscPES;    Des: 'Embrid Embroidery Format';                               Ext: 'PES';                      Sue: 'pes';    Wrt: false),
    (Typ: iomscPS;     Des: 'PostScript';                                             Ext: 'PS;EPS;EPSF;EPSI;EPI;EPT'; Sue: 'ps';     Wrt: true),
    (Typ: iomscPSB;    Des: 'Adobe Large Document Format';                            Ext: 'PSB';                      Sue: 'psb';    Wrt: true),
    (Typ: iomscPTIF;   Des: 'Pyramid encoded TIFF';                                   Ext: 'PTIF';                     Sue: 'ptif';   Wrt: true),
    (Typ: iomscSVG;    Des: 'Scalable Vector Graphics';                               Ext: 'SVG;SVGZ';                 Sue: 'svg';    Wrt: true),
    (Typ: iomscTIFF64; Des: 'Tagged Image File Format (64-bit)';                      Ext: 'TIFF64';                   Sue: 'tiff64'; Wrt: true),
    (Typ: iomscXCF;    Des: 'GIMP image';                                             Ext: 'XCF';                      Sue: 'xcf';    Wrt: false),
    (Typ: iomscXPS;    Des: 'Microsoft XML Paper Specification';                      Ext: 'XPS';                      Sue: 'xps';    Wrt: false)
  );


{!!
<FS>TIEMiscPluginsImageMagick.RegisterPlugin

<FM>Declaration<FC>
class procedure RegisterPlugin();

<FM>Description<FN>
Registers ImageMagick file formats into ImageEn (adding support for all its formats).

Applications should call this method once only (generally at the start of the application).

<FM>Demo<FN>
<TABLE2>
<R> <C_IMG_DEMO> <C>Demos\InputOutput\ImageMagick\ImageMagick.dpr </C> </R>
</TABLE>

<FM>Example<FC>
// Rasterizes page number 5 of mybook.pdf at 200dpi
TIEMiscPluginsImageMagick.RegisterPlugin(); // call only once!
ImageEnView1.IO.Params.ImageIndex := 5;
ImageEnView1.IO.Params.Dict.Insert('PDF:Density', 200);
ImageEnView1.IO.LoadFromFile('mybook.pdf');
!!}
class procedure TIEMiscPluginsImageMagick.RegisterPlugin();
var
  i: integer;
begin
  for i := 0 to high(ImageMagickFormats) do
  begin
    if ( ImageMagickFormats[i].typ = iomscPDF ) and ( IEFileFormatGetInfo( iomscWPPDF ) <> nil ) then
      continue; // skip if PDF already supported

    IEFileFormatAdd( TIEFileFormatInfo.Create(ImageMagickFormats[i].typ,
                                              ImageMagickFormats[i].des,
                                              ImageMagickFormats[i].ext,
                                              ImageMagickFormats[i].sue,
                                              false,
                                              [],
                                              @TIEMiscPluginsImageMagick_ReadImageStream,
                                              @TIEMiscPluginsImageMagick_WriteImageStream,
                                              @TIEMiscPluginsImageMagick_TryImageStream) );
  end;

  // remove native ImageEn formats
  IEFileFormatRemove( ioPDF );
  IEFileFormatRemove( ioPS );
end;


// Warning: in future "identify" command may change the SPATTERN!
// At the moment this is the fastest way to know pages count using imagemagick/ghostscript
function TIEMiscPluginsImageMagick_PDFFrameCount(Stream: TStream): integer;
const
  SPATTERN: AnsiString = 'number of pages in the file: ';
var
  filename: AnsiString;
  dosout: AnsiString;
  p: integer;
begin
  result := 0;
  if TIEMiscPluginsImageMagick.IsAvailable() and (Stream is TIEWideFileStream) then
  begin
    filename := AnsiString((Stream as TIEWideFileStream).FileName);
    dosout := IEGetDosOutput('identify ' + filename + '[999999999]');
    p := IEPos(SPATTERN, dosout);
    if p > 0 then
    begin
      dosout := IECopy(dosout, p + length(SPATTERN), length(dosout));
      p := IEPos(#$D#$A, dosout);
      result := IEStrToIntDef(IECopy(dosout, 1, p - 1), 0);
    end;
  end;
end;


// Note: may be executed inside another thread. So Progress method should not update UI (to avoid locks!)
function TIEMiscPluginsImageMagick_MagickProgressMonitor(text: PAnsiChar; offset: TIEImageMagick_MagickOffsetType; span: TIEImageMagick_MagickSizeType; client_data: pointer): TIEImageMagick_MagickBooleanType; cdecl;
var
  pr: ^TProgressRec;
  per: integer;
begin
  pr := client_data;
  if ((span < 100) or (offset = TIEImageMagick_MagickOffsetType(span - 1)) or (offset mod (TIEImageMagick_MagickOffsetType(span) div 100) = 0))
     and assigned(pr)
     and assigned(pr^.fOnProgress) then
  begin
    if GetCurrentThreadId() = System.MainThreadID then
    begin
      per := trunc(100 * integer(offset) / integer(span) / pr^.tot + 100 / pr^.tot * pr^.val);
      pr^.fOnProgress(pr^.Sender, per);
    end;
    result := not pr^.Aborting^;
  end
  else
    result := true;
end;


// to-do:
//  - more reading options (other than PDF:Density)
{
Read image from stream into Bitmap
Stream: Can be either a TMemoryStream or a TIEWideFileStream (file)
Progress: Provide loading progress feedback
Preview: If true, we only want IOParams to be filled.

Read from IOParams:
ImageIndex: The index of the page to load for a multi-page image, such as TIFF or PDF
GetThumbnail: If true, return only a small thumbnail of the image if it can be done efficiently (optional)
Dict: Optional parameters needed for this file type, e.g. 'PDF:Density' could be used to specify a resolution for loading

Written to IOParams:
ImageCount: Number of pages for a multi-page image, such as TIFF or PDF, otherwise 1
DpiX/DpiY: DPI of the image
BitsPerSample/SamplesPerPixel: Image color depth
Width: Bitmap.Width
Height: Bitmap.Height
OriginalWidth: Actual width of the image
OriginalHeight: Actual height of the image
}
procedure TIEMiscPluginsImageMagick_ReadImageStream(Stream: TStream; Bitmap: TIEBitmap; var IOParams: TIOParams; var Progress: TProgressRec; Preview: boolean);
var
  mwand: TIEImageMagick_MagickWand;
  mstream: TMemoryStream;
  filename: AnsiString;
  height, width: integer;
  i, j: integer;
  readOK: TIEImageMagick_MagickBooleanType;
  dpix, dpiy: double;
  imtype: TIEImageMagick_ImageType;
  imdepth: TIEImageMagick_size_t;
  imcolorspc: TIEImageMagick_ColorspaceType;
  pixfrmt: TIEPixelFormat;
  outfrmt: AnsiString;
  outstor: TIEImageMagick_StorageType;
  bytebuf: array of byte;
  px: pointer;
begin
  if TIEMiscPluginsImageMagick.IsAvailable() then
  begin
    Progress.tot := 2;  // number of steps
    mwand := TIEMiscPluginsImageMagick.NewMagickWand();
    mstream := nil;
    try
      if assigned(Progress.fOnProgress) then
        TIEMiscPluginsImageMagick.MagickSetProgressMonitor(mwand, @TIEMiscPluginsImageMagick_MagickProgressMonitor, @Progress);

      if Stream is TIEWideFileStream then
      begin
        filename := AnsiString((Stream as TIEWideFileStream).FileName);
      end
      else
      begin
        mstream := TMemoryStream.Create();
        mstream.LoadFromStream(Stream);
      end;
      Progress.val := 0;  // step one (0) - load

      if IOParams.Dict.HasKey('PDF:Density') then
        TIEMiscPluginsImageMagick.MagickSetOption(mwand, 'density', PAnsiChar(AnsiString(IOParams.Dict.GetString('PDF:Density'))));

      // it is too expensive to calculate page count (consider PDF and PS). For PDF one may use TIEMiscPluginsImageMagick_PDFFrameCount or IEPDFFrameCount instead
      IOParams.ImageCount := 1;

      // PCD files contain multiple resolutions, don't use [1] which is lowest res. Best resolution is usually 5 or 6. If index exceeds count, ImageMagick will load the best resolution
      if ( IOParams.FileType = iomscPCD ) and ( IOParams.ImageIndex = 0 ) then
        filename := filename + '[6]'
      else
        filename := filename + '[' + AnsiString(IntToStr(IOParams.ImageIndex)) + ']';

      readOK := false;
      if Preview then
      begin
        if filename <> '' then
          readOK := TIEMiscPluginsImageMagick.MagickPingImage(mwand, PAnsiChar(filename))
        else
        if mstream <> nil then
          readOK := TIEMiscPluginsImageMagick.MagickPingImageBlob(mwand, mstream.Memory, mstream.Size);
      end
      else
      begin
        if filename <> '' then
          readOK := TIEMiscPluginsImageMagick.MagickReadImage(mwand, PAnsiChar(filename))
        else
        if mstream <> nil then
          readOK := TIEMiscPluginsImageMagick.MagickReadImageBlob(mwand, mstream.Memory, mstream.Size);
      end;

      if readOK then
      begin
        // resolution
        TIEMiscPluginsImageMagick.MagickGetImageResolution(mwand, dpix, dpiy);
        case TIEMiscPluginsImageMagick.MagickGetImageUnits(mwand) of
          imck_UndefinedResolution,
          imck_PixelsPerInchResolution:
            begin
              IOParams.DpiX := trunc(dpix);
              IOParams.DpiY := trunc(dpiy);
            end;
          imck_PixelsPerCentimeterResolution:
            begin
              IOParams.DpiX := trunc(dpix / CM_per_Inch);
              IOParams.DpiY := trunc(dpiy / CM_per_Inch);
            end;
        end;
        if IOParams.DpiX = 0 then
          IOParams.DpiX := IEGlobalSettings().DefaultDPIX;
        if IOParams.DpiY = 0 then
          IOParams.DpiY := IEGlobalSettings().DefaultDPIY;

        // decode image
        Progress.val := 1;  // step two (1) - convert color space

        imtype := TIEMiscPluginsImageMagick.MagickIdentifyImageType(mwand);
        if imtype in [imck_BilevelType, imck_GrayscaleType, imck_GrayscaleMatteType] then
        begin
          TIEMiscPluginsImageMagick.MagickSetImageType(mwand, imck_BilevelType);
          TIEMiscPluginsImageMagick.MagickSetImageColorspace(mwand, imck_GRAYColorspace);
        end
        else if imtype <> imck_UndefinedType then
        begin
          TIEMiscPluginsImageMagick.MagickSetImageType(mwand, imck_TrueColorType);
          TIEMiscPluginsImageMagick.MagickSetImageColorspace(mwand, imck_sRGBColorspace);
        end;

        imdepth := TIEMiscPluginsImageMagick.MagickGetImageDepth(mwand);
        imcolorspc := TIEMiscPluginsImageMagick.MagickGetImageColorspace(mwand);

        case imcolorspc of
          imck_GRAYColorspace:
            begin
              if imdepth = 1 then
              begin
                pixfrmt := ie1g;
                outfrmt := 'I';
                outstor := imck_CharPixel;
                IOParams.BitsPerSample := 1;
                IOParams.SamplesPerPixel := 1;
              end
              else
              if imdepth = 8 then
              begin
                pixfrmt := ie8g;
                outfrmt := 'I';
                outstor := imck_CharPixel;
                IOParams.BitsPerSample := 8;
                IOParams.SamplesPerPixel := 1;
              end
              else
              if (imdepth = 16) and (IOParams.IsNativePixelFormat) then
              begin
                pixfrmt := ie16g;
                outfrmt := 'I';
                outstor := imck_ShortPixel;
                IOParams.BitsPerSample := 16;
                IOParams.SamplesPerPixel := 1;
              end
              else
              begin
                pixfrmt := ie8g;
                outfrmt := 'I';
                outstor := imck_CharPixel;
                IOParams.BitsPerSample := 8;
                IOParams.SamplesPerPixel := 1;
              end;
            end;
          else
            begin
              TIEMiscPluginsImageMagick.MagickTransformImageColorspace(mwand, imck_sRGBColorspace);
              pixfrmt := ie24RGB;
              outfrmt := 'BGR';
              outstor := imck_CharPixel;
              IOParams.BitsPerSample := 8;
              IOParams.SamplesPerPixel := 3;
            end;
        end;

        width  := TIEMiscPluginsImageMagick.MagickGetImageWidth(mwand);
        height := TIEMiscPluginsImageMagick.MagickGetImageHeight(mwand);
        Bitmap.Allocate(width, height, pixfrmt);
        IOParams.Width          := width;
        IOParams.OriginalWidth  := width;
        IOParams.Height         := height;
        IOParams.OriginalHeight := height;

        IOParams.FreeColorMap();

        if not Preview then
        begin
          if pixfrmt = ie1g then
          begin
            // special case, packet 1 bit channels
            SetLength(bytebuf, width);
            for i := 0 to height - 1 do
            begin
              TIEMiscPluginsImageMagick.MagickExportImagePixels(mwand, 0, i, width, 1, PAnsiChar(outfrmt), outstor, bytebuf);
              px := Bitmap.ScanLine[i];
              for j := 0 to width - 1 do
                _SetPixelbw(px, j, bytebuf[j]);
            end;
          end
          else
          begin
            // other cases (non packet channels)
            for i := 0 to height - 1 do
              TIEMiscPluginsImageMagick.MagickExportImagePixels(mwand, 0, i, width, 1, PAnsiChar(outfrmt), outstor, Bitmap.ScanLine[i]);
          end;
        end;
      end
      else
        Progress.Aborting^ := true;
    finally
      mstream.Free();
      TIEMiscPluginsImageMagick.DestroyMagickWand(mwand);
    end;
  end
  else
    Progress.Aborting^ := true;
end;


// to-do:
//  - implement other pixel formats.
//  - multipages
//  - more writing options
// known bugs: resulting PCD has wrong colors
{
Outputs the Bitmap to Stream in format IOParams.FileType (for formats that support writing)

Progress: Provide loading progress feedback

Read from IOParams (Optional):
DpiX/DpiY: DPI of the image
BitsPerSample/SamplesPerPixel: Image color depth
Dict: Optional parameters needed for this file type, e.g. 'PDF:Density' could be used to specify an output resolution

}
procedure TIEMiscPluginsImageMagick_WriteImageStream(Stream: TStream; Bitmap: TIEBitmap; var IOParams: TIOParams; var Progress: TProgressRec);
var
  mwand: TIEImageMagick_MagickWand;
  bkgrnd: TIEImageMagick_PixelWand;
  i: integer;
  frmt: AnsiString;
  imageBlob: pbyte;
  imageBlobLen: TIEImageMagick_size_t;
begin
  if TIEMiscPluginsImageMagick.IsAvailable() then
  begin
    mwand := TIEMiscPluginsImageMagick.NewMagickWand();
    bkgrnd := TIEMiscPluginsImageMagick.NewPixelWand();
    try
      TIEMiscPluginsImageMagick.MagickNewImage(mwand, Bitmap.Width, Bitmap.Height, bkgrnd);

      TIEMiscPluginsImageMagick.MagickSetDepth(mwand, 8);
      frmt := AnsiString(Uppercase(IEFileFormatGetExt(IOParams.FileType, 0)));
      TIEMiscPluginsImageMagick.MagickSetImageUnits(mwand, imck_PixelsPerInchResolution);
      TIEMiscPluginsImageMagick.MagickSetResolution(mwand, IOParams.DpiX, IOParams.DpiY);
      TIEMiscPluginsImageMagick.MagickSetColorspace(mwand, imck_sRGBColorspace);
      TIEMiscPluginsImageMagick.MagickSetFormat(mwand, PAnsiChar(frmt));

      for i := 0 to Bitmap.Height - 1 do
        TIEMiscPluginsImageMagick.MagickImportImagePixels(mwand, 0, i, Bitmap.Width, 1, 'BGR', imck_CharPixel, Bitmap.ScanLine[i]);

      imageBlob := TIEMiscPluginsImageMagick.MagickGetImageBlob(mwand, imageBlobLen);
      Stream.Write(imageBlob^, imageBlobLen);
      TIEMiscPluginsImageMagick.MagickRelinquishMemory(imageBlob);
    finally
      TIEMiscPluginsImageMagick.DestroyPixelWand(bkgrnd);
      TIEMiscPluginsImageMagick.DestroyMagickWand(mwand);
    end;
  end;
end;


// Returns true if the image in Stream matches the format, TryingFormat
function TIEMiscPluginsImageMagick_TryImageStream(Stream: TStream; TryingFormat: TIOFileType): boolean;
const
  BUFSIZE = 8192; // file head to analyse
var
  lpos: int64;
  frmt: string;
  i: integer;
  buf: array of byte;
  ex: TIEImageMagick_ExceptionInfo;
  info: TIEImageMagick_MagicInfo;
begin
  result := false;
  if TIEMiscPluginsImageMagick.IsAvailable() then
  begin
    lpos := Stream.Position;
    try
      SetLength(buf, BUFSIZE);
      Stream.Read(buf[0], BUFSIZE);
      ex := TIEMiscPluginsImageMagick.AcquireExceptionInfo();
      info := TIEMiscPluginsImageMagick.GetMagicInfo(@buf[0], BUFSIZE, ex);
      if info <> nil then
        frmt := string(AnsiString(TIEMiscPluginsImageMagick.GetMagicName(info)))
      else
        frmt := '';
      TIEMiscPluginsImageMagick.DestroyExceptionInfo(ex);
      if frmt <> '' then
        for i := 0 to high(ImageMagickFormats) do
          if (TryingFormat = ImageMagickFormats[i].typ) and (pos(';' + frmt + ';', ';' + ImageMagickFormats[i].ext + ';') > 0) then
          begin
            result := true;
            break;
          end;
    finally
      Stream.Position := lpos;
    end;
  end;
end;


class procedure TIEMiscPluginsImageMagick.CheckCallWand(var exec: pointer; name: AnsiString);
begin
  if exec = nil then
    exec := GetProcAddress(HandleWand(), PAnsiChar(name));
end;


class procedure TIEMiscPluginsImageMagick.CheckCallMagick(var exec: pointer; name: AnsiString);
begin
  if exec = nil then
    exec := GetProcAddress(HandleMagick(), PAnsiChar(name));
end;


class function TIEMiscPluginsImageMagick.HandleWand(Handle: THandle; Setup: boolean): THandle;
const
  LibHandle: THandle = 0;
begin
  if Setup then
    LibHandle := Handle;
  result := LibHandle;
end;


class function TIEMiscPluginsImageMagick.HandleMagick(Handle: THandle; Setup: boolean): THandle;
const
  LibHandle: THandle = 0;
begin
  if Setup then
    LibHandle := Handle;
  result := LibHandle;
end;


{!!
<FS>TIEMiscPluginsImageMagick.IsAvailable

<FM>Declaration<FC>
class function IsAvailable(): boolean;

<FM>Description<FN>
Returns True if the ImageMagick library is present and successfully loaded.
!!}
class function TIEMiscPluginsImageMagick.IsAvailable(): boolean;
begin
  if (HandleWand() = 0) or (HandleMagick() = 0) then
    Initialize(false);
  result := (HandleWand() <> 0) and (HandleMagick() <> 0);
end;


class procedure TIEMiscPluginsImageMagick.Initialize(reinitialize: boolean = true);
  {}
  procedure TryLoad();
  var
    verIndex: integer;
  begin
    verIndex := 0;
    if HandleWand() = 0 then
    begin
      while verIndex < length(IEIMAGEMAGICK_WAND_DLL_FILENAMES) do
      begin
        HandleWand(LoadLibraryW(PWideChar(WideString(IEIMAGEMAGICK_WAND_DLL_FILENAMES[verIndex]))), true);
        if (HandleWand() = 0) and IsLibrary then // if this is a DLL try to load from dll path
          HandleWand(LoadLibraryW(PWideChar( ExtractFilePath(GetModuleName(HInstance)) + WideString(IEIMAGEMAGICK_WAND_DLL_FILENAMES[verIndex]) )), true);
        if HandleWand() <> 0 then
        begin
          MagickWandGenesis();
          break;
        end;
        inc(verIndex);
      end;
    end;
    if HandleMagick() = 0 then
    begin
      // verIndex starts from last loaded library to maintain the same version (in case of multiple installations of magick)
      while verIndex < length(IEIMAGEMAGICK_MAGICK_DLL_FILENAMES) do
      begin
        HandleMagick(LoadLibraryW(PWideChar(WideString(IEIMAGEMAGICK_MAGICK_DLL_FILENAMES[verIndex]))), true);
        if (HandleMagick() = 0) and IsLibrary then // if this is a DLL try to load from dll path
          HandleMagick(LoadLibraryW(PWideChar( ExtractFilePath(GetModuleName(HInstance)) + WideString(IEIMAGEMAGICK_MAGICK_DLL_FILENAMES[verIndex]) )), true);
        if HandleMagick() <> 0 then
          break;
        inc(verIndex);
      end;
    end;
  end;
  {}
begin
  EnterCriticalSection(IEMiscPluginsCS);
  try
    if reinitialize then
      Finalize();
    TryLoad();
  finally
    LeaveCriticalSection(IEMiscPluginsCS);
  end;
end;


class procedure TIEMiscPluginsImageMagick.Finalize();
begin
  if HandleMagick() <> 0 then
  begin
    FreeLibrary(HandleMagick());
    HandleMagick(0, true);
  end;
  if HandleWand() <> 0 then
  begin
    MagickWandTerminus();
    FreeLibrary(HandleWand());
    HandleWand(0, true);
  end;
end;


class procedure TIEMiscPluginsImageMagick.MagickWandGenesis();
const
  exec: procedure(); cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickWandGenesis');
  exec();
end;


class procedure TIEMiscPluginsImageMagick.MagickWandTerminus();
const
  exec: procedure(); cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickWandTerminus');
  exec();
end;


class function TIEMiscPluginsImageMagick.NewMagickWand(): TIEImageMagick_MagickWand;
const
  exec: function(): TIEImageMagick_MagickWand; cdecl = nil;
begin
  CheckCallWand(@exec, 'NewMagickWand');
  result := exec();
end;


class function TIEMiscPluginsImageMagick.DestroyMagickWand(wand: TIEImageMagick_MagickWand): TIEImageMagick_MagickWand;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_MagickWand; cdecl = nil;
begin
  CheckCallWand(@exec, 'DestroyMagickWand');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickReadImage(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickReadImage');
  result := exec(wand, filename);
end;


class function TIEMiscPluginsImageMagick.MagickReadImageBlob(wand: TIEImageMagick_MagickWand; blob: pointer; length: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; blob: pointer; length: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickReadImageBlob');
  result := exec(wand, blob, length);
end;


class function TIEMiscPluginsImageMagick.MagickPingImageBlob(wand: TIEImageMagick_MagickWand; blob: pointer; length: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; blob: pointer; length: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickPingImageBlob');
  result := exec(wand, blob, length);
end;


class function TIEMiscPluginsImageMagick.MagickPingImage(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickPingImage');
  result := exec(wand, filename);
end;


class procedure TIEMiscPluginsImageMagick.MagickResetIterator(wand: TIEImageMagick_MagickWand);
const
  exec: procedure(wand: TIEImageMagick_MagickWand); cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickResetIterator');
  exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickNextImage(wand: TIEImageMagick_MagickWand): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickNextImage');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickSetIteratorIndex(wand: TIEImageMagick_MagickWand; index: TIEImageMagick_ssize_t): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; index: TIEImageMagick_ssize_t): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetIteratorIndex');
  result := exec(wand, index);
end;


class procedure TIEMiscPluginsImageMagick.MagickSetLastIterator(wand: TIEImageMagick_MagickWand);
const
  exec: procedure(wand: TIEImageMagick_MagickWand); cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetLastIterator');
  exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickGetIteratorIndex(wand: TIEImageMagick_MagickWand): TIEImageMagick_ssize_t;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_ssize_t; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetIteratorIndex');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickWriteImages(wand: TIEImageMagick_MagickWand; filename: PAnsiChar; adjoin: TIEImageMagick_MagickBooleanType): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; filename: PAnsiChar; adjoin: TIEImageMagick_MagickBooleanType): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickWriteImages');
  result := exec(wand, filename, adjoin);
end;


class function TIEMiscPluginsImageMagick.MagickExportImagePixels(wand: TIEImageMagick_MagickWand; x: TIEImageMagick_ssize_t; y: TIEImageMagick_ssize_t; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; map: PAnsiChar; storage: TIEImageMagick_StorageType; pixels: pointer): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; x: TIEImageMagick_ssize_t; y: TIEImageMagick_ssize_t; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; map: PAnsiChar; storage: TIEImageMagick_StorageType; pixels: pointer): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickExportImagePixels');
  result := exec(wand, x, y, columns, rows, map, storage, pixels);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageWidth(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageWidth');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageHeight(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageHeight');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageChannelDepth(wand: TIEImageMagick_MagickWand; channel: TIEImageMagick_ChannelType): TIEImageMagick_size_t;
const
  exec: function(wand: TIEImageMagick_MagickWand; channel: TIEImageMagick_ChannelType): TIEImageMagick_size_t; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageChannelDepth');
  result := exec(wand, channel);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageColorspace(wand: TIEImageMagick_MagickWand): TIEImageMagick_ColorspaceType;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_ColorspaceType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageColorspace');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickSetImageColorspace(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetImageColorspace');
  result := exec(wand, colorspace);
end;


class function TIEMiscPluginsImageMagick.MagickTransformImageColorspace(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickTransformImageColorspace');
  result := exec(wand, colorspace);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageDepth(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_size_t; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageDepth');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageResolution(wand: TIEImageMagick_MagickWand; var x: double; var y: double): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; var x: double; var y: double): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageResolution');
  result := exec(wand, x, y);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageUnits(wand: TIEImageMagick_MagickWand): TIEImageMagick_ResolutionType;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_ResolutionType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageUnits');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageFormat(wand: TIEImageMagick_MagickWand): PAnsiChar;
const
  exec: function(wand: TIEImageMagick_MagickWand): PAnsiChar; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageFormat');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickGetType(wand: TIEImageMagick_MagickWand): TIEImageMagick_ImageType;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_ImageType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetType');
  result := exec(wand);
end;


class function TIEMiscPluginsImageMagick.MagickIdentifyImageType(wand: TIEImageMagick_MagickWand): TIEImageMagick_ImageType;
const
  exec: function(wand: TIEImageMagick_MagickWand): TIEImageMagick_ImageType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickIdentifyImageType');
  if assigned(exec) then
    result := exec(wand)
  else
    result := imck_UndefinedType; // not implemented
end;


class function TIEMiscPluginsImageMagick.MagickSetImageType(wand: TIEImageMagick_MagickWand; image_type: TIEImageMagick_ImageType): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; image_type: TIEImageMagick_ImageType): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetImageType');
  result := exec(wand, image_type);
end;


class function TIEMiscPluginsImageMagick.MagickSetProgressMonitor(wand: TIEImageMagick_MagickWand; progress_monitor: TIEImageMagick_MagickProgressMonitor; client_data: pointer): TIEImageMagick_MagickProgressMonitor;
const
  exec: function(wand: TIEImageMagick_MagickWand; progress_monitor: TIEImageMagick_MagickProgressMonitor; client_data: pointer): TIEImageMagick_MagickProgressMonitor; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetProgressMonitor');
  result := exec(wand, progress_monitor, client_data);
end;


class function TIEMiscPluginsImageMagick.GetMagicInfo(magic: pointer; length: TIEImageMagick_size_t; exception: TIEImageMagick_ExceptionInfo): TIEImageMagick_MagicInfo;
const
  exec: function(magic: pointer; length: TIEImageMagick_size_t; exception: TIEImageMagick_ExceptionInfo): TIEImageMagick_MagicInfo; cdecl = nil;
begin
  CheckCallMagick(@exec, 'GetMagicInfo');
  result := exec(magic, length, exception);
end;


class function TIEMiscPluginsImageMagick.GetMagicName(magic_info: TIEImageMagick_MagicInfo): PAnsiChar;
const
  exec: function(magic_info: TIEImageMagick_MagicInfo): PAnsiChar; cdecl = nil;
begin
  CheckCallMagick(@exec, 'GetMagicName');
  result := exec(magic_info);
end;


class function TIEMiscPluginsImageMagick.AcquireExceptionInfo(): TIEImageMagick_ExceptionInfo;
const
  exec: function(): TIEImageMagick_ExceptionInfo; cdecl = nil;
begin
  CheckCallMagick(@exec, 'AcquireExceptionInfo');
  result := exec();
end;


class function TIEMiscPluginsImageMagick.DestroyExceptionInfo(e: TIEImageMagick_ExceptionInfo): TIEImageMagick_ExceptionInfo;
const
  exec: function(e: TIEImageMagick_ExceptionInfo): TIEImageMagick_ExceptionInfo; cdecl = nil;
begin
  CheckCallMagick(@exec, 'DestroyExceptionInfo');
  result := exec(e);
end;


class function TIEMiscPluginsImageMagick.MagickSetImageProperty(wand: TIEImageMagick_MagickWand; prop: PAnsiChar; value: PAnsiChar): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; prop: PAnsiChar; value: PAnsiChar): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetImageProperty');
  result := exec(wand, prop, value);
end;


class function TIEMiscPluginsImageMagick.MagickSetOption(wand: TIEImageMagick_MagickWand; key: PAnsiChar; value: PAnsiChar): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; key: PAnsiChar; value: PAnsiChar): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetOption');
  result := exec(wand, key, value);
end;


class function TIEMiscPluginsImageMagick.MagickGetException(wand: TIEImageMagick_MagickWand; var severity: TIEImageMagick_ExceptionType): PAnsiChar;
const
  exec: function(wand: TIEImageMagick_MagickWand; var severity: TIEImageMagick_ExceptionType): PAnsiChar; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetException');
  result := exec(wand, severity);
end;


class function TIEMiscPluginsImageMagick.MagickRelinquishMemory(resource: pointer): pointer;
const
  exec: function(resource: pointer): pointer; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickRelinquishMemory');
  result := exec(resource);
end;


class function TIEMiscPluginsImageMagick.MagickSetColorspace(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; colorspace: TIEImageMagick_ColorspaceType): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetColorspace');
  result := exec(wand, colorspace);
end;


class function TIEMiscPluginsImageMagick.MagickSetDepth(wand: TIEImageMagick_MagickWand; depth: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; depth: TIEImageMagick_size_t): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetDepth');
  result := exec(wand, depth);
end;


class function TIEMiscPluginsImageMagick.MagickSetFormat(wand: TIEImageMagick_MagickWand; format: PAnsiChar): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; format: PAnsiChar): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetFormat');
  result := exec(wand, format);
end;


class function TIEMiscPluginsImageMagick.MagickSetResolution(wand: TIEImageMagick_MagickWand; x_resolution: double; y_resolution: double): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; x_resolution: double; y_resolution: double): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetResolution');
  result := exec(wand, x_resolution, y_resolution);
end;


class function TIEMiscPluginsImageMagick.MagickSetImageUnits(wand: TIEImageMagick_MagickWand; units: TIEImageMagick_ResolutionType): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; units: TIEImageMagick_ResolutionType): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickSetImageUnits');
  result := exec(wand, units);
end;


class function TIEMiscPluginsImageMagick.MagickGetImageBlob(wand: TIEImageMagick_MagickWand; var length: TIEImageMagick_size_t): pbyte;
const
  exec: function(wand: TIEImageMagick_MagickWand; var length: TIEImageMagick_size_t): pbyte; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickGetImageBlob');
  result := exec(wand, length);
end;


class function TIEMiscPluginsImageMagick.MagickWriteImage(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; filename: PAnsiChar): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickWriteImage');
  result := exec(wand, filename);
end;


class function TIEMiscPluginsImageMagick.MagickImportImagePixels(wand: TIEImageMagick_MagickWand; x: TIEImageMagick_ssize_t; y: TIEImageMagick_ssize_t; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; map: PAnsiChar; storage: TIEImageMagick_StorageType; pixels: pointer): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; x: TIEImageMagick_ssize_t; y: TIEImageMagick_ssize_t; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; map: PAnsiChar; storage: TIEImageMagick_StorageType; pixels: pointer): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickImportImagePixels');
  result := exec(wand, x, y, columns, rows, map, storage, pixels);
end;


class function TIEMiscPluginsImageMagick.MagickNewImage(wand: TIEImageMagick_MagickWand; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; background: TIEImageMagick_PixelWand): TIEImageMagick_MagickBooleanType;
const
  exec: function(wand: TIEImageMagick_MagickWand; columns: TIEImageMagick_size_t; rows: TIEImageMagick_size_t; background: TIEImageMagick_PixelWand): TIEImageMagick_MagickBooleanType; cdecl = nil;
begin
  CheckCallWand(@exec, 'MagickNewImage');
  result := exec(wand, columns, rows, background);
end;


class function TIEMiscPluginsImageMagick.NewPixelWand(): TIEImageMagick_PixelWand;
const
  exec: function(): TIEImageMagick_PixelWand; cdecl = nil;
begin
  CheckCallWand(@exec, 'NewPixelWand');
  result := exec();
end;

class function TIEMiscPluginsImageMagick.DestroyPixelWand(pixelWand: TIEImageMagick_PixelWand): TIEImageMagick_PixelWand;
const
  exec: function(pixelWand: TIEImageMagick_PixelWand): TIEImageMagick_PixelWand; cdecl = nil;
begin
  CheckCallWand(@exec, 'DestroyPixelWand');
  result := exec(pixelWand);
end;



// TIEMiscPluginsImageMagick
///////////////////////////////////////////////////////////////////////////////////////////////////////





initialization
  InitializeCriticalSection(IEMiscPluginsCS);

finalization
  DeleteCriticalSection(IEMiscPluginsCS);


{$ELSE}  // not IEINCLUDEMISCPLUGINS

implementation

{$ENDIF}

end.