/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e g i s t e r M a g i c k I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method RegisterMagickInfo adds attributes for a particular image format to
% the list of supported formats. The attributes include the image format tag,
% a method to read and/or write the format, whether the format supports
% the saving of more than one frame to the same file or blob, whether the
% format supports native in-memory I/O, and a brief description of the format.
%
% The format of the RegisterMagickInfo method is:
%
% MagickInfo *RegisterMagickInfo(MagickInfo *entry)
%
% A description of each parameter follows:
%
% o magick_info: Method RegisterMagickInfo returns a pointer MagickInfo
% structure that contains the specified tag info.
%
% o entry:
%
*/
Export MagickInfo *RegisterMagickInfo(MagickInfo *entry)
{
register MagickInfo
*p;
/*
Add tag info to the image format list.
*/
p=(MagickInfo*) NULL;
if (magick_info != (MagickInfo *) NULL)
{
for (p=magick_info; p->next != (MagickInfo *) NULL; p=p->next)
{
if (Latin1Compare(p->tag,entry->tag) >= 0)
{
if (Latin1Compare(p->tag,entry->tag) == 0)
{
p=p->previous;
UnregisterMagickInfo(entry->tag);
}
break;
}
}
}
if (magick_info == (MagickInfo *) NULL)
{
magick_info=entry;
return(entry);
}
entry->previous=p;
entry->next=p->next;
p->next=entry;
return(entry);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% U n r e g i s t e r M a g i c k I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method UnregisterMagickInfo removes a tag from the magick info list. It
% returns False if the tag does not exist in the list otherwise True.
%
% The format of the UnregisterMagickInfo method is:
%
% unsigned int UnregisterMagickInfo(const char *tag)
%
% A description of each parameter follows:
%
% o status: Method UnregisterMagickInfo returns False if the tag does not
% exist in the list otherwise True.
%
% o tag: a character string that represents the image format we are
% looking for.
%
*/
Export unsigned int UnregisterMagickInfo(const char *tag)
{
register MagickInfo
*p;
for (p=GetMagickInfo((char *) NULL); p != (MagickInfo *) NULL; p=p->next)
{
if (Latin1Compare(p->tag,tag) == 0)
{
if (p->tag != (char *) NULL)
FreeMemory(p->tag);
if (p->description != (char *) NULL)
FreeMemory(p->description);
if (p->previous != (MagickInfo *) NULL)
p->previous->next=p->next;
else
{
magick_info=p->next;
if (p->next != (MagickInfo*) NULL)
p->next->previous=(MagickInfo *) NULL;
}
if (p->next != (MagickInfo*) NULL)
p->next->previous=p->previous;
FreeMemory(p);
return(True);
}
}
return(False);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% G e t M a g i c k L i s t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method GetMagickInfo returns a pointer MagickInfo structure that matches
% the specified tag. If tag is NULL, the head of the image format list is
% returned.
%
% The format of the GetMagickInfo method is:
%
% MagickInfo *GetMagickInfo(const char *tag)
%
% A description of each parameter follows:
%
% o magick_info: Method GetMagickInfo returns a pointer MagickInfo
% structure that matches the specified tag.
%
% o tag: a character string that represents the image format we are
% looking for.
%
%
*/
Export MagickInfo *GetMagickInfo(const char *tag)
{
register MagickInfo
*p;
if (magick_info == (MagickInfo *) NULL)
{
MagickInfo
*entry;
/*
entry=SetMagickInfo("8BIM");
entry->decoder=Read8BIMImage;
entry->encoder=Write8BIMImage;
entry->magick=Is8BIM;
entry->adjoin=False;
entry->description=AllocateString("Photoshop resource format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("AVS");
entry->decoder=ReadAVSImage;
entry->encoder=WriteAVSImage;
entry->description=AllocateString("AVS X image");
RegisterMagickInfo(entry);
#if defined(HasJBIG)
entry=SetMagickInfo("BIE");
entry->decoder=ReadJBIGImage;
entry->encoder=WriteJBIGImage;
entry->adjoin=False;
entry->description=
AllocateString("Joint Bi-level Image experts Group interchange format");
RegisterMagickInfo(entry);
#endif
*/
entry=SetMagickInfo("BMP");
entry->decoder=ReadBMPImage;
entry->encoder=WriteBMPImage;
entry->magick=IsBMP;
entry->description=AllocateString("Microsoft Windows bitmap image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("BMP24");
entry->decoder=ReadBMPImage;
entry->encoder=WriteBMPImage;
entry->description=
AllocateString("Microsoft Windows 24-bit bitmap image");
RegisterMagickInfo(entry);
/*
entry=SetMagickInfo("CMYK");
entry->decoder=ReadCMYKImage;
entry->encoder=WriteCMYKImage;
entry->adjoin=False;
entry->raw=True;
entry->description=
AllocateString("Raw cyan, magenta, yellow, and black bytes");
RegisterMagickInfo(entry);
entry=SetMagickInfo("DCM");
entry->decoder=ReadDCMImage;
entry->magick=IsDCM;
entry->adjoin=False;
entry->description=
AllocateString("Digital Imaging and Communications in Medicine image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("DCX");
entry->decoder=ReadPCXImage;
entry->encoder=WritePCXImage;
entry->magick=IsDCX;
entry->description=
AllocateString("ZSoft IBM PC multi-page Paintbrush");
RegisterMagickInfo(entry);
*/
entry=SetMagickInfo("DIB");
entry->decoder=ReadBMPImage;
entry->encoder=WriteBMPImage;
entry->description=
AllocateString("Microsoft Windows bitmap image");
RegisterMagickInfo(entry);
/*
entry=SetMagickInfo("EPDF");
entry->decoder=ReadPDFImage;
entry->encoder=WritePDFImage;
entry->adjoin=False;
entry->description=
AllocateString("Encapsulated Portable Document Format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("EPI");
entry->decoder=ReadPSImage;
entry->adjoin=False;
entry->description=
AllocateString("Adobe Encapsulated PostScript Interchange format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("EPS");
entry->decoder=ReadPSImage;
entry->encoder=WritePSImage;
entry->adjoin=False;
entry->description=AllocateString("Adobe Encapsulated PostScript");
RegisterMagickInfo(entry);
entry=SetMagickInfo("EPS2");
entry->decoder=ReadPSImage;
entry->encoder=WritePS2Image;
entry->adjoin=False;
entry->description=
AllocateString("Adobe Level II Encapsulated PostScript");
RegisterMagickInfo(entry);
entry=SetMagickInfo("EPSF");
entry->decoder=ReadPSImage;
entry->encoder=WritePSImage;
entry->adjoin=False;
entry->description=AllocateString("Adobe Encapsulated PostScript");
RegisterMagickInfo(entry);
entry=SetMagickInfo("EPSI");
entry->decoder=ReadPSImage;
entry->encoder=WritePSImage;
entry->adjoin=False;
entry->description=
AllocateString("Adobe Encapsulated PostScript Interchange format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("EPT");
entry->decoder=ReadPSImage;
entry->encoder=WriteEPTImage;
entry->magick=IsEPT;
entry->adjoin=False;
entry->description=
AllocateString("Adobe Encapsulated PostScript with TIFF preview");
RegisterMagickInfo(entry);
entry=SetMagickInfo("FAX");
entry->decoder=ReadFAXImage;
entry->encoder=WriteFAXImage;
entry->magick=IsFAX;
entry->description=AllocateString("Group 3 FAX");
RegisterMagickInfo(entry);
entry=SetMagickInfo("FITS");
entry->decoder=ReadFITSImage;
entry->encoder=WriteFITSImage;
entry->magick=IsFITS;
entry->adjoin=False;
entry->description=
AllocateString("Flexible Image Transport System");
RegisterMagickInfo(entry);
#if defined(HasFPX)
entry=SetMagickInfo("FPX");
entry->decoder=ReadFPXImage;
entry->encoder=WriteFPXImage;
entry->adjoin=False;
entry->description=AllocateString("FlashPix Format");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("G3");
entry->decoder=ReadFAXImage;
entry->adjoin=False;
entry->description=AllocateString("Group 3 FAX");
RegisterMagickInfo(entry);
*/
entry=SetMagickInfo("GIF");
entry->decoder=ReadGIFImage;
entry->encoder=WriteGIFImage;
entry->magick=IsGIF;
entry->description=
AllocateString("CompuServe graphics interchange format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("GIF87");
entry->decoder=ReadGIFImage;
entry->encoder=WriteGIFImage;
entry->adjoin=False;
entry->description=
AllocateString("CompuServe graphics interchange format (version 87a)");
RegisterMagickInfo(entry);
/*
entry=SetMagickInfo("GRADATION");
entry->decoder=ReadGRADATIONImage;
entry->adjoin=False;
entry->description=
AllocateString("Gradual passing from one shade to another");
RegisterMagickInfo(entry);
entry=SetMagickInfo("GRANITE");
entry->decoder=ReadLOGOImage;
entry->encoder=WriteLOGOImage;
entry->adjoin=False;
entry->description=AllocateString("Granite texture");
RegisterMagickInfo(entry);
entry=SetMagickInfo("GRAY");
entry->decoder=ReadGRAYImage;
entry->encoder=WriteGRAYImage;
entry->raw=True;
entry->description=AllocateString("Raw gray bytes");
RegisterMagickInfo(entry);
entry=SetMagickInfo("H");
entry->decoder=ReadLOGOImage;
entry->encoder=WriteLOGOImage;
entry->adjoin=False;
entry->description=AllocateString("Internal format");
RegisterMagickInfo(entry);
#if defined(HasHDF)
entry=SetMagickInfo("HDF");
entry->decoder=ReadHDFImage;
entry->encoder=WriteHDFImage;
entry->magick=IsHDF;
entry->blob_support=False;
entry->description=AllocateString("Hierarchical Data Format");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("HISTOGRAM");
entry->decoder=ReadHISTOGRAMImage;
entry->encoder=WriteHISTOGRAMImage;
entry->adjoin=False;
entry->description=AllocateString("Histogram of the image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("HTM");
entry->encoder=WriteHTMLImage;
entry->magick=IsHTML;
entry->adjoin=False;
entry->description=
AllocateString("Hypertext Markup Language and a client-side image map");
RegisterMagickInfo(entry);
entry=SetMagickInfo("HTML");
entry->encoder=WriteHTMLImage;
entry->adjoin=False;
entry->description=
AllocateString("Hypertext Markup Language and a client-side image map");
RegisterMagickInfo(entry);
entry=SetMagickInfo("ICB");
entry->decoder=ReadTGAImage;
entry->encoder=WriteTGAImage;
entry->description=AllocateString("Truevision Targa image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("ICC");
entry->decoder=ReadICCImage;
entry->encoder=WriteICCImage;
entry->adjoin=False;
entry->description=AllocateString("ICC Color Profile");
RegisterMagickInfo(entry);
entry=SetMagickInfo("ICO");
entry->decoder=ReadICONImage;
entry->adjoin=False;
entry->description=AllocateString("Microsoft icon");
RegisterMagickInfo(entry);
entry=SetMagickInfo("IMPLICIT");
entry->description=AllocateString("Internal format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("IPTC");
entry->decoder=ReadIPTCImage;
entry->encoder=WriteIPTCImage;
entry->magick=IsIPTC;
entry->adjoin=False;
entry->description=AllocateString("IPTC Newsphoto");
RegisterMagickInfo(entry);
#if defined(HasJBIG)
entry=SetMagickInfo("JBG");
entry->decoder=ReadJBIGImage;
entry->encoder=WriteJBIGImage;
entry->description=
AllocateString("Joint Bi-level Image experts Group interchange format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("JBIG");
entry->decoder=ReadJBIGImage;
entry->encoder=WriteJBIGImage;
entry->description=
AllocateString("Joint Bi-level Image experts Group interchange format");
RegisterMagickInfo(entry);
#endif
#if defined(HasJPEG)
entry=SetMagickInfo("JPG");
entry->decoder=ReadJPEGImage;
entry->encoder=WriteJPEGImage;
entry->adjoin=False;
entry->description=
AllocateString("Joint Photographic Experts Group JFIF format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("JPEG");
entry->decoder=ReadJPEGImage;
entry->encoder=WriteJPEGImage;
entry->magick=IsJPEG;
entry->adjoin=False;
entry->description=
AllocateString("Joint Photographic Experts Group JFIF format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("JPEG24");
entry->decoder=ReadJPEGImage;
entry->encoder=WriteJPEGImage;
entry->adjoin=False;
entry->description=
AllocateString("Joint Photographic Experts Group JFIF format");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("LABEL");
entry->decoder=ReadLABELImage;
entry->adjoin=False;
entry->description=AllocateString("Text image format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("LOGO");
entry->decoder=ReadLOGOImage;
entry->encoder=WriteLOGOImage;
entry->adjoin=False;
entry->description=AllocateString("ImageMagick Logo");
RegisterMagickInfo(entry);
entry=SetMagickInfo("MAP");
entry->decoder=ReadMAPImage;
entry->encoder=WriteMAPImage;
entry->adjoin=False;
entry->raw=True;
entry->description=
AllocateString("Colormap intensities and indices");
RegisterMagickInfo(entry);
entry=SetMagickInfo("MATTE");
entry->decoder=ReadMIFFImage;
entry->encoder=WriteMATTEImage;
entry->raw=True;
entry->description=AllocateString("Matte format");
RegisterMagickInfo(entry);
*/
entry=SetMagickInfo("MIFF");
entry->decoder=ReadMIFFImage;
entry->encoder=WriteMIFFImage;
entry->magick=IsMIFF;
entry->description=AllocateString("Magick image format");
RegisterMagickInfo(entry);
/*
#if defined(HasPNG)
entry=SetMagickInfo("MNG");
entry->decoder=ReadPNGImage;
entry->encoder=WritePNGImage;
entry->magick=IsMNG;
entry->description=AllocateString("Multiple-image Network Graphics");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("MONO");
entry->decoder=ReadMONOImage;
entry->encoder=WriteMONOImage;
entry->adjoin=False;
entry->description=
AllocateString("Bi-level bitmap in least-significant-byte first order");
RegisterMagickInfo(entry);
entry=SetMagickInfo("MTV");
entry->decoder=ReadMTVImage;
entry->encoder=WriteMTVImage;
entry->description=AllocateString("MTV Raytracing image format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("NETSCAPE");
entry->decoder=ReadLOGOImage;
entry->encoder=WriteLOGOImage;
entry->adjoin=False;
entry->description=AllocateString("Netscape 216 color cube");
RegisterMagickInfo(entry);
entry=SetMagickInfo("NULL");
entry->decoder=ReadNULLImage;
entry->adjoin=False;
entry->description=AllocateString("NULL image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("P7");
entry->decoder=ReadPNMImage;
entry->encoder=WritePNMImage;
entry->description=AllocateString("Xv thumbnail format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PBM");
entry->decoder=ReadPNMImage;
entry->encoder=WritePNMImage;
entry->description=
AllocateString("Portable bitmap format (black and white)");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PCD");
entry->decoder=ReadPCDImage;
entry->encoder=WritePCDImage;
entry->magick=IsPCD;
entry->adjoin=False;
entry->description=AllocateString("Photo CD");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PCDS");
entry->decoder=ReadPCDImage;
entry->encoder=WritePCDImage;
entry->adjoin=False;
entry->description=AllocateString("Photo CD");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PCL");
entry->decoder=ReadPCLImage;
entry->encoder=WritePCLImage;
entry->magick=IsPCL;
entry->adjoin=False;
entry->description=AllocateString("Page Control Language");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PCT");
entry->encoder=WritePICTImage;
entry->adjoin=False;
entry->description=AllocateString("Apple Macintosh QuickDraw/PICT");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PCX");
entry->decoder=ReadPCXImage;
entry->encoder=WritePCXImage;
entry->magick=IsPCX;
entry->adjoin=False;
entry->description=AllocateString("ZSoft IBM PC Paintbrush");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PDF");
entry->decoder=ReadPDFImage;
entry->encoder=WritePDFImage;
entry->magick=IsPDF;
entry->description=AllocateString("Portable Document Format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PIC");
entry->decoder=ReadPICTImage;
entry->encoder=WritePICTImage;
entry->adjoin=False;
entry->description=AllocateString("Apple Macintosh QuickDraw/PICT");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PICT");
entry->decoder=ReadPICTImage;
entry->encoder=WritePICTImage;
entry->adjoin=False;
entry->description=AllocateString("Apple Macintosh QuickDraw/PICT");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PICT24");
entry->decoder=ReadPICTImage;
entry->encoder=WritePICTImage;
entry->adjoin=False;
entry->description=
AllocateString("24-bit Apple Macintosh QuickDraw/PICT");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PIX");
entry->decoder=ReadPIXImage;
entry->description=
AllocateString("Alias/Wavefront RLE image format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PLASMA");
entry->decoder=ReadPLASMAImage;
entry->adjoin=False;
entry->description=AllocateString("Plasma fractal image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PGM");
entry->decoder=ReadPNMImage;
entry->encoder=WritePNMImage;
entry->description=
AllocateString("Portable graymap format (gray scale)");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PM");
entry->decoder=ReadXPMImage;
entry->encoder=WriteXPMImage;
entry->adjoin=False;
entry->description=AllocateString("X Windows system pixmap (color)");
RegisterMagickInfo(entry);
#if defined(HasPNG)
entry=SetMagickInfo("PNG");
entry->decoder=ReadPNGImage;
entry->encoder=WritePNGImage;
entry->magick=IsPNG;
entry->adjoin=False;
entry->description=AllocateString("Portable Network Graphics");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("PNM");
entry->decoder=ReadPNMImage;
entry->encoder=WritePNMImage;
entry->magick=IsPNM;
entry->description=AllocateString("Portable anymap");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PPM");
entry->decoder=ReadPNMImage;
entry->encoder=WritePNMImage;
entry->description=AllocateString("Portable pixmap format (color)");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PREVIEW");
entry->encoder=WritePREVIEWImage;
entry->adjoin=False;
entry->description=
AllocateString("Show a preview an image enhancement, effect, or f/x");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PS");
entry->decoder=ReadPSImage;
entry->encoder=WritePSImage;
entry->magick=IsPS;
entry->description=AllocateString("Adobe PostScript");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PS2");
entry->encoder=WritePS2Image;
entry->description=AllocateString("Adobe Level II PostScript");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PS3");
entry->encoder=WritePS3Image;
entry->description=AllocateString("Adobe Level III PostScript");
RegisterMagickInfo(entry);
entry=SetMagickInfo("PSD");
entry->decoder=ReadPSDImage;
entry->encoder=WritePSDImage;
entry->magick=IsPSD;
entry->adjoin=False;
entry->description=AllocateString("Adobe Photoshop bitmap");
RegisterMagickInfo(entry);
#if defined(HasTIFF)
entry=SetMagickInfo("PTIF");
entry->decoder=ReadTIFFImage;
entry->encoder=WriteTIFFImage;
entry->blob_support=False;
entry->description=AllocateString("Pyramid encoded TIFF");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("PWP");
entry->decoder=ReadPWPImage;
entry->magick=IsPWP;
entry->description=AllocateString("Seattle Film Works");
RegisterMagickInfo(entry);
entry=SetMagickInfo("RAS");
entry->decoder=ReadSUNImage;
entry->encoder=WriteSUNImage;
entry->magick=IsSUN;
entry->description=AllocateString("SUN Rasterfile");
RegisterMagickInfo(entry);
*/
entry=SetMagickInfo("RGB");
entry->decoder=ReadRGBImage;
entry->encoder=WriteRGBImage;
entry->raw=True;
entry->description=AllocateString("Raw red, green, and blue bytes");
RegisterMagickInfo(entry);
/*
entry=SetMagickInfo("RGBA");
entry->decoder=ReadRGBImage;
entry->encoder=WriteRGBImage;
entry->raw=True;
entry->description=
AllocateString("Raw red, green, blue, and matte bytes");
RegisterMagickInfo(entry);
entry=SetMagickInfo("RLA");
entry->decoder=ReadRLAImage;
entry->adjoin=False;
entry->description=AllocateString("Alias/Wavefront image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("RLE");
entry->decoder=ReadRLEImage;
entry->magick=IsRLE;
entry->adjoin=False;
entry->description=AllocateString("Utah Run length encoded image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("SCT");
entry->decoder=ReadSCTImage;
entry->magick=IsSCT;
entry->adjoin=False;
entry->description=AllocateString("Scitex HandShake");
RegisterMagickInfo(entry);
entry=SetMagickInfo("SFW");
entry->decoder=ReadSFWImage;
entry->magick=IsSFW;
entry->adjoin=False;
entry->description=AllocateString("Seattle Film Works");
RegisterMagickInfo(entry);
entry=SetMagickInfo("SGI");
entry->decoder=ReadSGIImage;
entry->encoder=WriteSGIImage;
entry->magick=IsSGI;
entry->description=AllocateString("Irix RGB image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("SHTML");
entry->encoder=WriteHTMLImage;
entry->adjoin=False;
entry->description=
AllocateString("Hypertext Markup Language and a client-side image map");
RegisterMagickInfo(entry);
entry=SetMagickInfo("STEGANO");
entry->decoder=ReadSTEGANOImage;
entry->description=AllocateString("Steganographic image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("SUN");
entry->decoder=ReadSUNImage;
entry->encoder=WriteSUNImage;
entry->description=AllocateString("SUN Rasterfile");
RegisterMagickInfo(entry);
entry=SetMagickInfo("TEXT");
entry->decoder=ReadTXTImage;
entry->encoder=WriteTXTImage;
entry->raw=True;
entry->description=AllocateString("Raw text");
RegisterMagickInfo(entry);
entry=SetMagickInfo("TGA");
entry->decoder=ReadTGAImage;
entry->encoder=WriteTGAImage;
entry->description=AllocateString("Truevision Targa image");
RegisterMagickInfo(entry);
#if defined(HasTIFF)
entry=SetMagickInfo("TIF");
entry->decoder=ReadTIFFImage;
entry->encoder=WriteTIFFImage;
entry->blob_support=False;
entry->description=AllocateString("Tagged Image File Format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("TIFF");
entry->decoder=ReadTIFFImage;
entry->encoder=WriteTIFFImage;
entry->magick=IsTIFF;
entry->blob_support=False;
entry->description=AllocateString("Tagged Image File Format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("TIFF24");
entry->decoder=ReadTIFFImage;
entry->encoder=WriteTIFFImage;
entry->blob_support=False;
entry->description=AllocateString("24-bit Tagged Image File Format");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("TILE");
entry->decoder=ReadTILEImage;
entry->raw=True;
entry->description=AllocateString("Tile image with a texture");
RegisterMagickInfo(entry);
entry=SetMagickInfo("TIM");
entry->decoder=ReadTIMImage;
entry->description=AllocateString("PSX TIM");
RegisterMagickInfo(entry);
#if defined(HasTTF)
entry=SetMagickInfo("TTF");
entry->decoder=ReadTTFImage;
entry->adjoin=False;
entry->description=AllocateString("TrueType font");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("TXT");
entry->decoder=ReadTXTImage;
entry->encoder=WriteTXTImage;
entry->description=AllocateString("Raw text");
RegisterMagickInfo(entry);
entry=SetMagickInfo("UIL");
entry->decoder=ReadUILImage;
entry->encoder=WriteUILImage;
entry->adjoin=False;
entry->description=AllocateString("X-Motif UIL table");
RegisterMagickInfo(entry);
entry=SetMagickInfo("UYVY");
entry->decoder=ReadUYVYImage;
entry->encoder=WriteUYVYImage;
entry->adjoin=False;
entry->raw=True;
entry->description=AllocateString("16bit/pixel interleaved YUV");
RegisterMagickInfo(entry);
entry=SetMagickInfo("VDA");
entry->decoder=ReadTGAImage;
entry->encoder=WriteTGAImage;
entry->description=AllocateString("Truevision Targa image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("VICAR");
entry->decoder=ReadVICARImage;
entry->encoder=WriteVICARImage;
entry->magick=IsVICAR;
entry->adjoin=False;
entry->description=AllocateString("VICAR rasterfile format");
RegisterMagickInfo(entry);
entry=SetMagickInfo("VID");
entry->decoder=ReadVIDImage;
entry->encoder=WriteMIFFImage;
entry->description=AllocateString("Visual Image Directory");
RegisterMagickInfo(entry);
entry=SetMagickInfo("VIFF");
entry->decoder=ReadVIFFImage;
entry->encoder=WriteVIFFImage;
entry->magick=IsVIFF;
entry->description=AllocateString("Khoros Visualization image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("VST");
entry->decoder=ReadTGAImage;
entry->encoder=WriteTGAImage;
entry->description=AllocateString("Truevision Targa image");
RegisterMagickInfo(entry);
entry=SetMagickInfo("WBMP");
entry->decoder=ReadWBMPImage;
entry->encoder=WriteWBMPImage;
entry->adjoin=False;
entry->description=AllocateString("Wireless Bitmap (level 0) image");
RegisterMagickInfo(entry);
#if defined(HasX11)
entry=SetMagickInfo("X");
entry->decoder=ReadXImage;
entry->encoder=WriteXImage;
entry->adjoin=False;
entry->description=AllocateString("X Image");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("XBM");
entry->decoder=ReadXBMImage;
entry->encoder=WriteXBMImage;
entry->magick=IsXBM;
entry->adjoin=False;
entry->description=
AllocateString("X Windows system bitmap (black and white)");
RegisterMagickInfo(entry);
entry=SetMagickInfo("XC");
entry->decoder=ReadXCImage;
entry->adjoin=False;
entry->raw=True;
entry->description=
AllocateString("Constant image of X server color");
RegisterMagickInfo(entry);
entry=SetMagickInfo("XPM");
entry->decoder=ReadXPMImage;
entry->encoder=WriteXPMImage;
entry->magick=IsXPM;
entry->adjoin=False;
entry->description=AllocateString("X Windows system pixmap (color)");
RegisterMagickInfo(entry);
entry=SetMagickInfo("XV");
entry->decoder=ReadVIFFImage;
entry->encoder=WriteVIFFImage;
entry->description=AllocateString("Khoros Visualization image");
RegisterMagickInfo(entry);
#if defined(HasX11)
entry=SetMagickInfo("XWD");
entry->decoder=ReadXWDImage;
entry->encoder=WriteXWDImage;
entry->magick=IsXWD;
entry->adjoin=False;
entry->description=
AllocateString("X Windows system window dump (color)");
RegisterMagickInfo(entry);
#endif
entry=SetMagickInfo("YUV");
entry->decoder=ReadYUVImage;
entry->encoder=WriteYUVImage;
entry->adjoin=False;
entry->raw=True;
entry->description=AllocateString("CCIR 601 4:1:1");
RegisterMagickInfo(entry);
*/
}
if (tag == (char *) NULL)
return(magick_info);
for (p=magick_info; p != (MagickInfo *) NULL; p=p->next)
if (Latin1Compare(p->tag,tag) == 0)
return(p);
return((MagickInfo *) NULL);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e H T M L I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteHTMLImage writes an image in the HTML encoded image format.
%
% The format of the WriteHTMLImage method is:
%
% unsigned int WriteHTMLImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteHTMLImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to an ImageInfo structure.
%
% o image: A pointer to a Image structure.
%
%
*/
Export unsigned int WriteHTMLImage(const ImageInfo *image_info,Image *image)
{
char
buffer[MaxTextExtent],
filename[MaxTextExtent],
mapname[MaxTextExtent],
url[MaxTextExtent];
Image
*next;
ImageInfo
*local_info;
int
x,
y;
register char
*p;
register PixelPacket
*q;
unsigned int
height,
status,
width;
/*
Open image.
*/
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
CloseBlob(image);
TransformRGBImage(image,RGBColorspace);
*url='\0';
if ((Latin1Compare(image_info->magick,"FTP") == 0) ||
(Latin1Compare(image_info->magick,"HTTP") == 0))
{
/*
Extract URL base from filename.
*/
p=strrchr(image->filename,'/');
if (p)
{
p++;
(void) strcpy(url,image_info->magick);
(void) strcat(url,":");
url[Extent(url)+p-image->filename]='\0';
(void) strncat(url,image->filename,p-image->filename);
(void) strcpy(image->filename,p);
}
}
/*
Refer to image map file.
*/
(void) strcpy(filename,image->filename);
AppendImageFormat("map",filename);
(void) strcpy(mapname,BaseFilename(filename));
(void) strcpy(image->filename,image_info->filename);
(void) strcpy(filename,image->filename);
local_info=CloneImageInfo(image_info);
if (local_info == (ImageInfo *) NULL)
WriterExit(FileOpenWarning,"Unable to allocate memory",image);
local_info->adjoin=True;
status=True;
if (Latin1Compare(image_info->magick,"SHTML") != 0)
{
/*
Open output image file.
*/
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
/*
Write the HTML image file.
*/
(void) strcpy(buffer,"<html version=\"2.0\">\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"<head>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) sprintf(buffer,"<title>%.1024s</title>\n",
image->label ? image->label : BaseFilename(image->filename));
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"</head>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"<body>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"<center>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) sprintf(buffer,"<h1>%.1024s</h1>\n",image->filename);
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"<br><br>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(filename,image->filename);
AppendImageFormat("gif",filename);
(void) sprintf(buffer,
"<img ismap usemap=#%.1024s src=\"%.1024s\" border=0>\n",
mapname,filename);
(void) WriteBlob(image,strlen(buffer),buffer);
/*
Determine the size and location of each image tile.
*/
width=image->columns;
height=image->rows;
x=0;
y=0;
if (image->montage != (char *) NULL)
(void) ParseGeometry(image->montage,&x,&y,&width,&height);
/*
Write an image map.
*/
(void) sprintf(buffer,"<map name=%.1024s>\n",mapname);
(void) WriteBlob(image,strlen(buffer),buffer);
(void) sprintf(buffer," <area href=""%.1024s""",url);
(void) WriteBlob(image,strlen(buffer),buffer);
if (image->directory == (char *) NULL)
{
(void) sprintf(buffer,"%.1024s shape=rect coords=0,0,%u,%u>\n",
image->filename,width-1,height-1);
(void) WriteBlob(image,strlen(buffer),buffer);
}
else
for (p=image->directory; *p != '\0'; p++)
if (*p != '\n')
(void) WriteByte(image,*p);
else
{
(void) sprintf(buffer," shape=rect coords=%d,%d,%d,%d>\n",
x,y,x+(int) width-1,y+(int) height-1);
(void) WriteBlob(image,strlen(buffer),buffer);
if (*(p+1) != '\0')
{
(void) sprintf(buffer," <area href=""%.1024s""",url);
(void) WriteBlob(image,strlen(buffer),buffer);
}
x+=width;
if (x >= (int) image->columns)
{
x=0;
y+=height;
}
}
(void) strcpy(buffer,"</map>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
if (image->montage != (char *) NULL)
{
char
color[MaxTextExtent] = "#000";
/*
Make montage background transparent.
*/
q=GetPixelCache(image,0,0,1,1);
if (q != (PixelPacket *) NULL)
FormatString(color,HexColorFormat,q->red,q->green,q->blue);
TransparentImage(image,color);
}
(void) strcpy(filename,image->filename);
(void) strcpy(buffer,"</center>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"</body>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"</html>\n");
status=WriteBlob(image,strlen(buffer),buffer);
CloseBlob(image);
/*
Write the image as transparent GIF.
*/
(void) strcpy(image->filename,filename);
AppendImageFormat("gif",image->filename);
next=image->next;
image->next=(Image *) NULL;
status|=WriteGIFImage(local_info,image);
image->next=next;
/*
Determine image map filename.
*/
(void) strcpy(image->filename,filename);
for (p=filename+Extent(filename)-1; p > (filename+1); p--)
if (*p == '.')
{
(void) strncpy(image->filename,filename,p-filename);
image->filename[p-filename]='\0';
break;
}
(void) strcat(image->filename,"_map.shtml");
}
/*
Open image map.
*/
status=OpenBlob(local_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
DestroyImageInfo(local_info);
/*
Determine the size and location of each image tile.
*/
width=image->columns;
height=image->rows;
x=0;
y=0;
if (image->montage != (char *) NULL)
(void) ParseGeometry(image->montage,&x,&y,&width,&height);
/*
Write an image map.
*/
(void) sprintf(buffer,"<map name=%.1024s>\n",mapname);
(void) WriteBlob(image,strlen(buffer),buffer);
(void) sprintf(buffer," <area href=""%.1024s""",url);
(void) WriteBlob(image,strlen(buffer),buffer);
if (image->directory == (char *) NULL)
{
(void) sprintf(buffer,"%.1024s shape=rect coords=0,0,%u,%u>\n",
image->filename,width-1,height-1);
(void) WriteBlob(image,strlen(buffer),buffer);
}
else
for (p=image->directory; *p != '\0'; p++)
if (*p != '\n')
(void) WriteByte(image,*p);
else
{
(void) sprintf(buffer," shape=rect coords=%d,%d,%d,%d>\n",x,y,
x+(int) width-1,y+(int) height-1);
(void) WriteBlob(image,strlen(buffer),buffer);
if (*(p+1) != '\0')
{
(void) sprintf(buffer," <area href=""%.1024s""",url);
(void) WriteBlob(image,strlen(buffer),buffer);
}
x+=width;
if (x >= (int) image->columns)
{
x=0;
y+=height;
}
}
(void) strcpy(buffer,"</map>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
CloseBlob(image);
(void) strcpy(image->filename,filename);
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e E P T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteEPTImage writes an image in the Adobe Encapsulated Postscript
% format with a TIFF preview.
%
% The format of the WriteEPTImage method is:
%
% unsigned int WriteEPTImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteEPTImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to an ImageInfo structure.
%
% o image: A pointer to a Image structure.
%
%
*/
Export unsigned int WriteEPTImage(const ImageInfo *image_info,Image *image)
{
char
filename[MaxTextExtent];
FILE
*ps_file,
*tiff_file;
int
c;
unsigned int
status;
unsigned long
eps_length,
tiff_length;
ps_file=(FILE *) NULL;
if (Latin1Compare(image_info->magick,"PS") == 0)
ps_file=fopen(image->magick_filename,ReadBinaryType);
if (ps_file != (FILE *) NULL)
{
struct stat
attributes;
/*
Read existing Encapsulated Postscript.
*/
eps_length=
fstat(fileno(ps_file),&attributes) < 0 ? 0 : attributes.st_size;
}
else
{
/*
Write image as Encapsulated Postscript to a temporary file.
*/
(void) strcpy(filename,image->filename);
TemporaryFilename(image->filename);
status=WritePSImage(image_info,image);
if (status == False)
return(status);
status=OpenBlob(image_info,image,ReadBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
(void) remove(image->filename);
eps_length=image->filesize;
ps_file=image->file;
image->file=(FILE *) NULL;
}
/*
Write image as TIFF to a temporary file.
*/
TemporaryFilename(image->filename);
status=WriteTIFFImage(image_info,image);
if (status == False)
return(status);
status=OpenBlob(image_info,image,ReadBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
(void) remove(image->filename);
tiff_length=image->filesize;
tiff_file=image->file;
image->file=(FILE *) NULL;
/*
Write EPT image.
*/
(void) strcpy(image->filename,filename);
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
LSBFirstWriteLong(image,0xc6d3d0c5ul);
LSBFirstWriteLong(image,30);
LSBFirstWriteLong(image,eps_length);
LSBFirstWriteLong(image,0);
LSBFirstWriteLong(image,0);
LSBFirstWriteLong(image,eps_length+30);
LSBFirstWriteLong(image,tiff_length);
LSBFirstWriteShort(image,0xffff);
for (c=fgetc(ps_file); c != EOF; c=fgetc(ps_file))
(void) WriteByte(image,(char) c);
for (c=fgetc(tiff_file); c != EOF; c=fgetc(tiff_file))
(void) WriteByte(image,(char) c);
(void) fclose(tiff_file);
CloseBlob(image);
return(True);
}
