Changed RegisterMagickInfo to return a boolean instead of the supplied pointer.
using MagickCore::AcquireVirtualCacheView;
using MagickCore::AcquireImage;
using MagickCore::AcquireKernelInfo;
+ using MagickCore::AcquireMagickInfo;
using MagickCore::AcquireMagickMemory;
using MagickCore::AcquireQuantumInfo;
using MagickCore::AcquireString;
using MagickCore::SetImageRegistry;
using MagickCore::SetImageType;
using MagickCore::SetLogEventMask;
- using MagickCore::SetMagickInfo;
using MagickCore::SetMagickResourceLimit;
using MagickCore::SetImageVirtualPixelMethod;
using MagickCore::SetPixelChannel;
% %
% %
% %
+% A c q u i r e M a g i c k I n f o %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% AcquireMagickInfo() allocates a MagickInfo structure and initializes the
+% members to default values.
+%
+% The format of the AcquireMagickInfo method is:
+%
+% MagickInfo *AcquireMagickInfo(const char *module, const char *name,)
+%
+% A description of each parameter follows:
+%
+% o module: a character string that represents the module associated
+% with the MagickInfo structure.
+%
+% o name: a character string that represents the image format associated
+% with the MagickInfo structure.
+%
+% o description: a character string that represents the image format
+% associated with the MagickInfo structure.
+%
+*/
+MagickExport MagickInfo *AcquireMagickInfo(const char *module,
+ const char *name, const char *description)
+{
+ MagickInfo
+ *magick_info;
+
+ assert(module != (const char *) NULL);
+ assert(name != (const char *) NULL);
+ assert(description != (const char *) NULL);
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
+ magick_info=(MagickInfo *) AcquireMagickMemory(sizeof(*magick_info));
+ if (magick_info == (MagickInfo *) NULL)
+ ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+ (void) ResetMagickMemory(magick_info,0,sizeof(*magick_info));
+ magick_info->module=ConstantString(module);
+ magick_info->name=ConstantString(name);
+ magick_info->description=ConstantString(description);
+ magick_info->flags=CoderAdjoinFlag | CoderBlobSupportFlag |
+ CoderDecoderThreadSupportFlag | CoderEncoderThreadSupportFlag |
+ CoderUseExtensionFlag;
+ magick_info->signature=MagickSignature;
+ return(magick_info);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+ G e t I m a g e D e c o d e r %
% %
% %
if (magick_list == (SplayTreeInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
- magick_info=SetMagickInfo("ephemeral");
- magick_info->flags|=CoderStealthFlag;
- status=AddValueToSplayTree(magick_list,magick_info->name,magick_info);
- if (status == MagickFalse)
- ThrowFatalException(ResourceLimitFatalError,
- "MemoryAllocationFailed");
- magick_info=SetMagickInfo("clipmask");
+ magick_info=AcquireMagickInfo("EPHEMERAL","EPHEMERAL","Internal format");
magick_info->flags|=CoderStealthFlag;
status=AddValueToSplayTree(magick_list,magick_info->name,magick_info);
if (status == MagickFalse)
% o magick_info: the magick info.
%
*/
-MagickExport MagickInfo *RegisterMagickInfo(MagickInfo *magick_info)
+MagickExport MagickBooleanType RegisterMagickInfo(MagickInfo *magick_info)
{
MagickBooleanType
status;
assert(magick_info->signature == MagickSignature);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",magick_info->name);
if (magick_list == (SplayTreeInfo *) NULL)
- return((MagickInfo *) NULL);
+ return(MagickFalse);
if ((GetMagickDecoderThreadSupport(magick_info) == MagickFalse) ||
(GetMagickEncoderThreadSupport(magick_info) == MagickFalse))
magick_info->semaphore=AcquireSemaphoreInfo();
status=AddValueToSplayTree(magick_list,magick_info->name,magick_info);
- if (status == MagickFalse)
- ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
- return(magick_info);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-+ S e t M a g i c k I n f o %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% SetMagickInfo() allocates a MagickInfo structure and initializes the members
-% to default values.
-%
-% The format of the SetMagickInfo method is:
-%
-% MagickInfo *SetMagickInfo(const char *name)
-%
-% A description of each parameter follows:
-%
-% o magick_info: Method SetMagickInfo returns the allocated and initialized
-% MagickInfo structure.
-%
-% o name: a character string that represents the image format associated
-% with the MagickInfo structure.
-%
-*/
-MagickExport MagickInfo *SetMagickInfo(const char *name)
-{
- MagickInfo
- *magick_info;
-
- assert(name != (const char *) NULL);
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
- magick_info=(MagickInfo *) AcquireMagickMemory(sizeof(*magick_info));
- if (magick_info == (MagickInfo *) NULL)
- ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
- (void) ResetMagickMemory(magick_info,0,sizeof(*magick_info));
- magick_info->name=ConstantString(name);
- magick_info->flags=CoderAdjoinFlag | CoderBlobSupportFlag |
- CoderDecoderThreadSupportFlag | CoderEncoderThreadSupportFlag |
- CoderUseExtensionFlag;
- magick_info->signature=MagickSignature;
- return(magick_info);
+ return(status);
}
\f
/*
GetMagickStealth(const MagickInfo *),
GetMagickUseExtension(const MagickInfo *),
IsMagickCoreInstantiated(void),
+ RegisterMagickInfo(MagickInfo *),
UnregisterMagickInfo(const char *);
extern const MagickExport MagickInfo
**GetMagickInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickInfo
- *RegisterMagickInfo(MagickInfo *),
- *SetMagickInfo(const char *);
+ *AcquireMagickInfo(const char *, const char *, const char *);
extern MagickExport void
MagickCoreGenesis(const char *,const MagickBooleanType),
#define SetLogEventMask PrependMagickMethod(SetLogEventMask)
#define SetLogFormat PrependMagickMethod(SetLogFormat)
#define SetLogName PrependMagickMethod(SetLogName)
-#define SetMagickInfo PrependMagickMethod(SetMagickInfo)
+#define AcquireMagickInfo PrependMagickMethod(AcquireMagickInfo)
#define SetMagickMemoryMethods PrependMagickMethod(SetMagickMemoryMethods)
#define SetMagickRegistry PrependMagickMethod(SetMagickRegistry)
#define SetMagickResourceLimit PrependMagickMethod(SetMagickResourceLimit)
MagickInfo
*entry;
- entry=SetMagickInfo("AAI");
+ entry=AcquireMagickInfo("AAI","AAI","AAI Dune image");
entry->decoder=(DecodeImageHandler *) ReadAAIImage;
entry->encoder=(EncodeImageHandler *) WriteAAIImage;
- entry->description=ConstantString("AAI Dune image");
- entry->module=ConstantString("AAI");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("ART");
+ entry=AcquireMagickInfo("ART","ART","PFS: 1st Publisher Clip Art");
entry->decoder=(DecodeImageHandler *) ReadARTImage;
entry->encoder=(EncodeImageHandler *) WriteARTImage;
entry->flags|=CoderRawSupportFlag;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("PFS: 1st Publisher Clip Art");
- entry->module=ConstantString("ART");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("AVS");
+ entry=AcquireMagickInfo("AVS","AVS","AVS X image");
entry->decoder=(DecodeImageHandler *) ReadAVSImage;
entry->encoder=(EncodeImageHandler *) WriteAVSImage;
- entry->description=ConstantString("AVS X image");
- entry->module=ConstantString("AVS");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("BGR");
+ entry=AcquireMagickInfo("BGR","BGR","Raw blue, green, and red samples");
entry->decoder=(DecodeImageHandler *) ReadBGRImage;
entry->encoder=(EncodeImageHandler *) WriteBGRImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw blue, green, and red samples");
- entry->module=ConstantString("BGR");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("BGRA");
+ entry=AcquireMagickInfo("BGR","BGRA",
+ "Raw blue, green, red, and alpha samples");
entry->decoder=(DecodeImageHandler *) ReadBGRImage;
entry->encoder=(EncodeImageHandler *) WriteBGRImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw blue, green, red, and alpha samples");
- entry->module=ConstantString("BGR");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("BGRO");
+ entry=AcquireMagickInfo("BGR","BGRO",
+ "Raw blue, green, red, and opacity samples");
entry->decoder=(DecodeImageHandler *) ReadBGRImage;
entry->encoder=(EncodeImageHandler *) WriteBGRImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw blue, green, red, and opacity samples");
- entry->module=ConstantString("BGR");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("BMP");
+ entry=AcquireMagickInfo("BMP","BMP","Microsoft Windows bitmap image");
entry->decoder=(DecodeImageHandler *) ReadBMPImage;
entry->encoder=(EncodeImageHandler *) WriteBMPImage;
entry->magick=(IsImageFormatHandler *) IsBMP;
- entry->description=ConstantString("Microsoft Windows bitmap image");
- entry->module=ConstantString("BMP");
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("BMP2");
+ entry=AcquireMagickInfo("BMP","BMP2","Microsoft Windows bitmap image (V2)");
entry->encoder=(EncodeImageHandler *) WriteBMPImage;
entry->magick=(IsImageFormatHandler *) IsBMP;
- entry->description=ConstantString("Microsoft Windows bitmap image (V2)");
- entry->module=ConstantString("BMP");
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("BMP3");
+ entry=AcquireMagickInfo("BMP","BMP3","Microsoft Windows bitmap image (V3)");
entry->encoder=(EncodeImageHandler *) WriteBMPImage;
entry->magick=(IsImageFormatHandler *) IsBMP;
- entry->description=ConstantString("Microsoft Windows bitmap image (V3)");
- entry->module=ConstantString("BMP");
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
MagickInfo
*entry;
- entry=SetMagickInfo("BRF");
+ entry=AcquireMagickInfo("BRAILLE","BRF","BRF ASCII Braille format");
entry->encoder=(EncodeImageHandler *) WriteBRAILLEImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=AcquireString("BRF ASCII Braille format");
- entry->module=AcquireString("BRAILLE");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("UBRL");
+ entry=AcquireMagickInfo("BRAILLE","UBRL","Unicode Text format");
entry->encoder=(EncodeImageHandler *) WriteBRAILLEImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=AcquireString("Unicode Text format");
- entry->module=AcquireString("BRAILLE");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ISOBRL");
+ entry=AcquireMagickInfo("BRAILLE","ISOBRL","ISO/TR 11548-1 format");
entry->encoder=(EncodeImageHandler *) WriteBRAILLEImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=AcquireString("ISO/TR 11548-1 format");
- entry->module=AcquireString("BRAILLE");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
*/
ModuleExport size_t RegisterCALSImage(void)
{
+#define CALSDescription "Continuous Acquisition and Life-cycle Support Type 1"
+#define CALSNote "Specified in MIL-R-28002 and MIL-PRF-28002"
+
MagickInfo
*entry;
- static const char
- *CALSDescription=
- {
- "Continuous Acquisition and Life-cycle Support Type 1"
- },
- *CALSNote=
- {
- "Specified in MIL-R-28002 and MIL-PRF-28002"
- };
-
- entry=SetMagickInfo("CAL");
+ entry=AcquireMagickInfo("CALS","CAL",CALSDescription);
entry->decoder=(DecodeImageHandler *) ReadCALSImage;
#if defined(MAGICKCORE_TIFF_DELEGATE)
entry->encoder=(EncodeImageHandler *) WriteCALSImage;
#endif
entry->flags^=CoderAdjoinFlag;
entry->magick=(IsImageFormatHandler *) IsCALS;
- entry->description=ConstantString(CALSDescription);
entry->note=ConstantString(CALSNote);
- entry->module=ConstantString("CALS");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("CALS");
+ entry=AcquireMagickInfo("CALS","CALS",CALSDescription);
entry->decoder=(DecodeImageHandler *) ReadCALSImage;
#if defined(MAGICKCORE_TIFF_DELEGATE)
entry->encoder=(EncodeImageHandler *) WriteCALSImage;
#endif
entry->flags^=CoderAdjoinFlag;
entry->magick=(IsImageFormatHandler *) IsCALS;
- entry->description=ConstantString(CALSDescription);
entry->note=ConstantString(CALSNote);
- entry->module=ConstantString("CALS");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CAPTION");
+ entry=AcquireMagickInfo("CAPTION","CAPTION","Caption");
entry->decoder=(DecodeImageHandler *) ReadCAPTIONImage;
- entry->description=ConstantString("Caption");
entry->flags^=CoderAdjoinFlag;
- entry->module=ConstantString("CAPTION");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CIN");
+ entry=AcquireMagickInfo("CIN","CIN","Cineon Image File");
entry->decoder=(DecodeImageHandler *) ReadCINImage;
entry->encoder=(EncodeImageHandler *) WriteCINImage;
entry->magick=(IsImageFormatHandler *) IsCIN;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Cineon Image File");
- entry->module=ConstantString("CIN");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CIP");
+ entry=AcquireMagickInfo("CIP","CIP","Cisco IP phone image format");
entry->encoder=(EncodeImageHandler *) WriteCIPImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Cisco IP phone image format");
- entry->module=ConstantString("CIP");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CLIP");
+ entry=AcquireMagickInfo("CLIP","CLIP","Image Clip Mask");
entry->decoder=(DecodeImageHandler *) ReadCLIPImage;
entry->encoder=(EncodeImageHandler *) WriteCLIPImage;
- entry->description=ConstantString("Image Clip Mask");
- entry->module=ConstantString("CLIP");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CLIPBOARD");
+ entry=AcquireMagickInfo("CLIPBOARD","CLIPBOARD","The system clipboard");
#if defined(MAGICKCORE_WINGDI32_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadCLIPBOARDImage;
entry->encoder=(EncodeImageHandler *) WriteCLIPBOARDImage;
#endif
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("The system clipboard");
- entry->module=ConstantString("CLIPBOARD");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CMYK");
+ entry=AcquireMagickInfo("CMYK","CMYK",
+ "Raw cyan, magenta, yellow, and black samples");
entry->decoder=(DecodeImageHandler *) ReadCMYKImage;
entry->encoder=(EncodeImageHandler *) WriteCMYKImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw cyan, magenta, yellow, and black "
- "samples");
- entry->module=ConstantString("CMYK");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("CMYKA");
+ entry=AcquireMagickInfo("CMYK","CMYKA",
+ "Raw cyan, magenta, yellow, black, and alpha samples");
entry->decoder=(DecodeImageHandler *) ReadCMYKImage;
entry->encoder=(EncodeImageHandler *) WriteCMYKImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw cyan, magenta, yellow, black, and "
- "alpha samples");
- entry->module=ConstantString("CMYK");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CUT");
+ entry=AcquireMagickInfo("CUT","CUT","DR Halo");
entry->decoder=(DecodeImageHandler *) ReadCUTImage;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("DR Halo");
- entry->module=ConstantString("CUT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
"and supplement 61 which adds JPEG-2000 encoding."
};
- entry=SetMagickInfo("DCM");
+ entry=AcquireMagickInfo("DCM","DCM",
+ "Digital Imaging and Communications in Medicine image");
entry->decoder=(DecodeImageHandler *) ReadDCMImage;
entry->magick=(IsImageFormatHandler *) IsDCM;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString(
- "Digital Imaging and Communications in Medicine image");
entry->note=ConstantString(DCMNote);
- entry->module=ConstantString("DCM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry = SetMagickInfo("DDS");
+ entry = AcquireMagickInfo("DDS","DDS","Microsoft DirectDraw Surface");
entry->decoder = (DecodeImageHandler *) ReadDDSImage;
entry->encoder = (EncodeImageHandler *) WriteDDSImage;
entry->magick = (IsImageFormatHandler *) IsDDS;
entry->flags|=CoderSeekableStreamFlag;
- entry->description = ConstantString("Microsoft DirectDraw Surface");
- entry->module = ConstantString("DDS");
(void) RegisterMagickInfo(entry);
- entry = SetMagickInfo("DXT1");
+ entry = AcquireMagickInfo("DDS","DXT1","Microsoft DirectDraw Surface");
entry->decoder = (DecodeImageHandler *) ReadDDSImage;
entry->encoder = (EncodeImageHandler *) WriteDDSImage;
entry->magick = (IsImageFormatHandler *) IsDDS;
entry->flags|=CoderSeekableStreamFlag;
- entry->description = ConstantString("Microsoft DirectDraw Surface");
- entry->module = ConstantString("DDS");
(void) RegisterMagickInfo(entry);
- entry = SetMagickInfo("DXT5");
+ entry = AcquireMagickInfo("DDS","DXT5","Microsoft DirectDraw Surface");
entry->decoder = (DecodeImageHandler *) ReadDDSImage;
entry->encoder = (EncodeImageHandler *) WriteDDSImage;
entry->magick = (IsImageFormatHandler *) IsDDS;
entry->flags|=CoderSeekableStreamFlag;
- entry->description = ConstantString("Microsoft DirectDraw Surface");
- entry->module = ConstantString("DDS");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("DEBUG");
+ entry=AcquireMagickInfo("DEBUG","DEBUG","Image pixel values for debugging");
entry->encoder=(EncodeImageHandler *) WriteDEBUGImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("Image pixel values for debugging");
- entry->module=ConstantString("DEBUG");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("DIB");
+ entry=AcquireMagickInfo("DIB","DIB",
+ "Microsoft Windows 3.X Packed Device-Independent Bitmap");
entry->decoder=(DecodeImageHandler *) ReadDIBImage;
entry->encoder=(EncodeImageHandler *) WriteDIBImage;
entry->magick=(IsImageFormatHandler *) IsDIB;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString(
- "Microsoft Windows 3.X Packed Device-Independent Bitmap");
- entry->module=ConstantString("DIB");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
(void) ConcatenateMagickString(version,"libdjvu ",MaxTextExtent);
(void) ConcatenateMagickString(version,DJVU_LIBDJVU_VER_STRING,MaxTextExtent);
#endif
- entry=SetMagickInfo("DJVU");
+ entry=AcquireMagickInfo("DJVU","DJVU","Déjà vu");
#if defined(MAGICKCORE_DJVU_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadDJVUImage;
#endif
entry->magick=(IsImageFormatHandler *) IsDJVU;
entry->flags|=CoderRawSupportFlag;
entry->flags^=CoderAdjoinFlag;
- entry->description=AcquireString("Déjà vu");
- entry->module=AcquireString("DJVU");
if (*version != '\0')
entry->version=AcquireString(version);
entry->note=AcquireString(DJVUNote);
MagickInfo
*entry;
- entry=SetMagickInfo("3FR");
+ entry=AcquireMagickInfo("DNG","3FR","Hasselblad CFV/H3D39II");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Hasselblad CFV/H3D39II");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ARW");
+ entry=AcquireMagickInfo("DNG","ARW","Sony Alpha Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Sony Alpha Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("DNG");
+ entry=AcquireMagickInfo("DNG","DNG","Digital Negative");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Digital Negative");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("CR2");
+ entry=AcquireMagickInfo("DNG","CR2","Canon Digital Camera Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Canon Digital Camera Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("CRW");
+ entry=AcquireMagickInfo("DNG","CRW","Canon Digital Camera Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Canon Digital Camera Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("DCR");
+ entry=AcquireMagickInfo("DNG","DCR","Kodak Digital Camera Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Kodak Digital Camera Raw Image File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ERF");
+ entry=AcquireMagickInfo("DNG","ERF","Epson RAW Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Epson RAW Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("IIQ");
+ entry=AcquireMagickInfo("DNG","IIQ","Phase One Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Phase One Raw Image Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("KDC");
+ entry=AcquireMagickInfo("DNG","KDC","Kodak Digital Camera Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Kodak Digital Camera Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("K25");
+ entry=AcquireMagickInfo("DNG","K25","Kodak Digital Camera Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Kodak Digital Camera Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MEF");
+ entry=AcquireMagickInfo("DNG","MEF","Mamiya Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Mamiya Raw Image File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MRW");
+ entry=AcquireMagickInfo("DNG","MRW","Sony (Minolta) Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Sony (Minolta) Raw Image File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("NEF");
+ entry=AcquireMagickInfo("DNG","NEF","Nikon Digital SLR Camera Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Nikon Digital SLR Camera Raw Image File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("NRW");
+ entry=AcquireMagickInfo("DNG","NRW","Nikon Digital SLR Camera Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Nikon Digital SLR Camera Raw Image File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ORF");
+ entry=AcquireMagickInfo("DNG","ORF","Olympus Digital Camera Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Olympus Digital Camera Raw Image File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PEF");
+ entry=AcquireMagickInfo("DNG","PEF","Pentax Electronic File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Pentax Electronic File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("RAF");
+ entry=AcquireMagickInfo("DNG","RAF","Fuji CCD-RAW Graphic File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Fuji CCD-RAW Graphic File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("RAW");
+ entry=AcquireMagickInfo("DNG","RAW","Raw");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Raw");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("RMF");
+ entry=AcquireMagickInfo("DNG","RMF","Raw Media Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Raw Media Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("RW2");
+ entry=AcquireMagickInfo("DNG","RW2","Panasonic Lumix Raw Image");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Panasonic Lumix Raw Image");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("SRF");
+ entry=AcquireMagickInfo("DNG","SRF","Sony Raw Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Sony Raw Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("SR2");
+ entry=AcquireMagickInfo("DNG","SR2","Sony Raw Format 2");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Sony Raw Format 2");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("X3F");
+ entry=AcquireMagickInfo("DNG","X3F","Sigma Camera RAW Picture File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("Sigma Camera RAW Picture File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("DOT");
+ entry=AcquireMagickInfo("DOT","DOT","Graphviz");
#if defined(MAGICKCORE_GVC_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadDOTImage;
#endif
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Graphviz");
- entry->module=ConstantString("DOT");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("GV");
+ entry=AcquireMagickInfo("DOT","GV","Graphviz");
#if defined(MAGICKCORE_GVC_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadDOTImage;
#endif
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Graphviz");
- entry->module=ConstantString("DOT");
(void) RegisterMagickInfo(entry);
#if defined(MAGICKCORE_GVC_DELEGATE)
graphic_context=gvContext();
MagickInfo
*entry;
- entry=SetMagickInfo("DPS");
+ entry=AcquireMagickInfo("DPS","DPS","Display Postscript Interpreter");
#if defined(MAGICKCORE_DPS_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadDPSImage;
#endif
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Display Postscript Interpreter");
- entry->module=ConstantString("DPS");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
"See SMPTE 268M-2003 specification at http://www.smtpe.org\n"
};
- entry=SetMagickInfo("DPX");
+ entry=AcquireMagickInfo("DPX","DPX","SMPTE 268M-2003 (DPX 2.0)");
entry->decoder=(DecodeImageHandler *) ReadDPXImage;
entry->encoder=(EncodeImageHandler *) WriteDPXImage;
entry->magick=(IsImageFormatHandler *) IsDPX;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("SMPTE 268M-2003 (DPX 2.0)");
entry->note=ConstantString(DPXNote);
- entry->module=ConstantString("DPX");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("EMF");
+ entry=AcquireMagickInfo("EMF","EMF","Windows Enhanced Meta File");
#if defined(MAGICKCORE_WINGDI32_DELEGATE)
entry->decoder=ReadEMFImage;
#endif
- entry->description=ConstantString(
- "Windows Enhanced Meta File");
entry->magick=(IsImageFormatHandler *) IsEMF;
entry->flags^=CoderBlobSupportFlag;
- entry->module=ConstantString("WMF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("WMF");
+ entry=AcquireMagickInfo("EMF","WMF","Windows Meta File");
#if defined(MAGICKCORE_WINGDI32_DELEGATE)
entry->decoder=ReadEMFImage;
#endif
- entry->description=ConstantString("Windows Meta File");
entry->magick=(IsImageFormatHandler *) IsWMF;
entry->flags^=CoderBlobSupportFlag;
- entry->module=ConstantString("WMF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("EPT");
+ entry=AcquireMagickInfo("EPT","EPT",
+ "Encapsulated PostScript with TIFF preview");
entry->decoder=(DecodeImageHandler *) ReadEPTImage;
entry->encoder=(EncodeImageHandler *) WriteEPTImage;
entry->magick=(IsImageFormatHandler *) IsEPT;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString(
- "Encapsulated PostScript with TIFF preview");
- entry->module=ConstantString("EPT");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("EPT2");
+ entry=AcquireMagickInfo("EPT","EPT2",
+ "Encapsulated PostScript Level II with TIFF preview");
entry->decoder=(DecodeImageHandler *) ReadEPTImage;
entry->encoder=(EncodeImageHandler *) WriteEPTImage;
entry->magick=(IsImageFormatHandler *) IsEPT;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString(
- "Encapsulated PostScript Level II with TIFF preview");
- entry->module=ConstantString("EPT");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("EPT3");
+ entry=AcquireMagickInfo("EPT","EPT3",
+ "Encapsulated PostScript Level III with TIFF preview");
entry->decoder=(DecodeImageHandler *) ReadEPTImage;
entry->encoder=(EncodeImageHandler *) WriteEPTImage;
entry->magick=(IsImageFormatHandler *) IsEPT;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString(
- "Encapsulated PostScript Level III with TIFF preview");
- entry->module=ConstantString("EPT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("EXR");
+ entry=AcquireMagickInfo("EXR","EXR","High Dynamic-range (HDR)");
#if defined(MAGICKCORE_OPENEXR_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadEXRImage;
entry->encoder=(EncodeImageHandler *) WriteEXRImage;
#endif
entry->magick=(IsImageFormatHandler *) IsEXR;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("High Dynamic-range (HDR)");
entry->flags^=CoderBlobSupportFlag;
- entry->module=ConstantString("EXR");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
"resized using a geometry of \"150x100%\".\n"
};
- entry=SetMagickInfo("FAX");
+ entry=AcquireMagickInfo("FAX","FAX","Group 3 FAX");
entry->decoder=(DecodeImageHandler *) ReadFAXImage;
entry->encoder=(EncodeImageHandler *) WriteFAXImage;
entry->magick=(IsImageFormatHandler *) IsFAX;
- entry->description=ConstantString("Group 3 FAX");
entry->note=ConstantString(Note);
- entry->module=ConstantString("FAX");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("G3");
+ entry=AcquireMagickInfo("FAX","G3","Group 3 FAX");
entry->decoder=(DecodeImageHandler *) ReadFAXImage;
entry->encoder=(EncodeImageHandler *) WriteFAXImage;
entry->magick=(IsImageFormatHandler *) IsFAX;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Group 3 FAX");
- entry->module=ConstantString("FAX");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("FD");
+ entry=AcquireMagickInfo("FD","FD","Read image from a file descriptor");
entry->decoder=(DecodeImageHandler *) ReadFDImage;
- entry->description=ConstantString("Read image from a file descriptor");
- entry->module=ConstantString("FD");
entry->flags|=CoderStealthFlag;
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
MagickInfo
*entry;
- entry=SetMagickInfo("FITS");
+ entry=AcquireMagickInfo("FITS","FITS","Flexible Image Transport System");
entry->decoder=(DecodeImageHandler *) ReadFITSImage;
entry->encoder=(EncodeImageHandler *) WriteFITSImage;
entry->magick=(IsImageFormatHandler *) IsFITS;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Flexible Image Transport System");
- entry->module=ConstantString("FITS");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("FTS");
+ entry=AcquireMagickInfo("FTS","FITS","Flexible Image Transport System");
entry->decoder=(DecodeImageHandler *) ReadFITSImage;
entry->encoder=(EncodeImageHandler *) WriteFITSImage;
entry->magick=(IsImageFormatHandler *) IsFITS;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Flexible Image Transport System");
- entry->module=ConstantString("FTS");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("FPX");
+ entry=AcquireMagickInfo("FPX","FPX","FlashPix Format");
#if defined(MAGICKCORE_FPX_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadFPXImage;
entry->encoder=(EncodeImageHandler *) WriteFPXImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("FlashPix Format");
- entry->module=ConstantString("FPX");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("GIF");
+ entry=AcquireMagickInfo("GIF","GIF",
+ "CompuServe graphics interchange format");
entry->decoder=(DecodeImageHandler *) ReadGIFImage;
entry->encoder=(EncodeImageHandler *) WriteGIFImage;
entry->magick=(IsImageFormatHandler *) IsGIF;
- entry->description=ConstantString("CompuServe graphics interchange format");
entry->mime_type=ConstantString("image/gif");
- entry->module=ConstantString("GIF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("GIF87");
+ entry=AcquireMagickInfo("GIF","GIF87",
+ "CompuServe graphics interchange format");
entry->decoder=(DecodeImageHandler *) ReadGIFImage;
entry->encoder=(EncodeImageHandler *) WriteGIFImage;
entry->magick=(IsImageFormatHandler *) IsGIF;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("CompuServe graphics interchange format");
entry->version=ConstantString("version 87a");
entry->mime_type=ConstantString("image/gif");
- entry->module=ConstantString("GIF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("GRADIENT");
+ entry=AcquireMagickInfo("GRADIENT","GRADIENT",
+ "Gradual linear passing from one shade to another");
entry->decoder=(DecodeImageHandler *) ReadGRADIENTImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderRawSupportFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Gradual linear passing from one shade to "
- "another");
- entry->module=ConstantString("GRADIENT");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("RADIAL-GRADIENT");
+ entry=AcquireMagickInfo("GRADIENT","RADIAL-GRADIENT",
+ "Gradual radial passing from one shade to another");
entry->decoder=(DecodeImageHandler *) ReadGRADIENTImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderRawSupportFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Gradual radial passing from one shade to "
- "another");
- entry->module=ConstantString("GRADIENT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("GRAY");
+ entry=AcquireMagickInfo("GRAY","GRAY","Raw gray samples");
entry->decoder=(DecodeImageHandler *) ReadGRAYImage;
entry->encoder=(EncodeImageHandler *) WriteGRAYImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw gray samples");
- entry->module=ConstantString("GRAY");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("HALD");
+ entry=AcquireMagickInfo("HALD","HALD",
+ "Identity Hald color lookup table image");
entry->decoder=(DecodeImageHandler *) ReadHALDImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Identity Hald color lookup table image");
- entry->module=ConstantString("HALD");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("HDR");
+ entry=AcquireMagickInfo("HDR","HDR","Radiance RGBE image format");
entry->decoder=(DecodeImageHandler *) ReadHDRImage;
entry->encoder=(EncodeImageHandler *) WriteHDRImage;
- entry->description=ConstantString("Radiance RGBE image format");
- entry->module=ConstantString("HDR");
entry->magick=(IsImageFormatHandler *) IsHDR;
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
MagickInfo
*entry;
- entry=SetMagickInfo("HISTOGRAM");
+ entry=AcquireMagickInfo("HISTOGRAM","HISTOGRAM","Histogram of the image");
entry->encoder=(EncodeImageHandler *) WriteHISTOGRAMImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Histogram of the image");
- entry->module=ConstantString("HISTOGRAM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("HRZ");
+ entry=AcquireMagickInfo("HRZ","HRZ","Slow Scan TeleVision");
entry->decoder=(DecodeImageHandler *) ReadHRZImage;
entry->encoder=(EncodeImageHandler *) WriteHRZImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Slow Scan TeleVision");
- entry->module=ConstantString("HRZ");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("HTM");
+ entry=AcquireMagickInfo("HTML","HTM",
+ "Hypertext Markup Language and a client-side image map");
entry->encoder=(EncodeImageHandler *) WriteHTMLImage;
entry->magick=(IsImageFormatHandler *) IsHTML;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(
- "Hypertext Markup Language and a client-side image map");
- entry->module=ConstantString("HTML");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("HTML");
+ entry=AcquireMagickInfo("HTML","HTML",
+ "Hypertext Markup Language and a client-side image map");
entry->encoder=(EncodeImageHandler *) WriteHTMLImage;
entry->magick=(IsImageFormatHandler *) IsHTML;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(
- "Hypertext Markup Language and a client-side image map");
- entry->module=ConstantString("HTML");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("SHTML");
+ entry=AcquireMagickInfo("HTML","SHTML",
+ "Hypertext Markup Language and a client-side image map");
entry->encoder=(EncodeImageHandler *) WriteHTMLImage;
entry->magick=(IsImageFormatHandler *) IsHTML;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(
- "Hypertext Markup Language and a client-side image map");
- entry->module=ConstantString("HTML");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CUR");
+ entry=AcquireMagickInfo("ICON","CUR","Microsoft icon");
entry->decoder=(DecodeImageHandler *) ReadICONImage;
entry->encoder=(EncodeImageHandler *) WriteICONImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Microsoft icon");
- entry->module=ConstantString("CUR");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ICO");
+ entry=AcquireMagickInfo("ICON","ICO","Microsoft icon");
entry->decoder=(DecodeImageHandler *) ReadICONImage;
entry->encoder=(EncodeImageHandler *) WriteICONImage;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Microsoft icon");
- entry->module=ConstantString("ICON");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ICON");
+ entry=AcquireMagickInfo("ICON","ICON","Microsoft icon");
entry->decoder=(DecodeImageHandler *) ReadICONImage;
entry->encoder=(EncodeImageHandler *) WriteICONImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Microsoft icon");
- entry->module=ConstantString("ICON");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("INFO");
+ entry=AcquireMagickInfo("INFO","INFO",
+ "The image format and characteristics");
entry->encoder=(EncodeImageHandler *) WriteINFOImage;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("The image format and characteristics");
- entry->module=ConstantString("INFO");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("INLINE");
+ entry=AcquireMagickInfo("INLINE","INLINE","Base64-encoded inline images");
entry->decoder=(DecodeImageHandler *) ReadINLINEImage;
entry->encoder=(EncodeImageHandler *) WriteINLINEImage;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Base64-encoded inline images");
- entry->module=ConstantString("INLINE");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("IPL");
+ entry=AcquireMagickInfo("IPL","IPL","IPL Image Sequence");
entry->decoder=(DecodeImageHandler *) ReadIPLImage;
entry->encoder=(EncodeImageHandler *) WriteIPLImage;
entry->magick=(IsImageFormatHandler *) IsIPL;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("IPL Image Sequence");
- entry->module=ConstantString("IPL");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
#if defined(JBG_VERSION)
(void) CopyMagickString(version,JBG_VERSION,MaxTextExtent);
#endif
- entry=SetMagickInfo("BIE");
+ entry=AcquireMagickInfo("JBIG","BIE",JBIGDescription);
#if defined(MAGICKCORE_JBIG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadJBIGImage;
entry->encoder=(EncodeImageHandler *) WriteJBIGImage;
#endif
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(JBIGDescription);
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("JBIG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JBG");
+ entry=AcquireMagickInfo("JBIG","JBG",JBIGDescription);
#if defined(MAGICKCORE_JBIG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadJBIGImage;
entry->encoder=(EncodeImageHandler *) WriteJBIGImage;
#endif
- entry->description=ConstantString(JBIGDescription);
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("JBIG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JBIG");
+ entry=AcquireMagickInfo("JBIG","JBIG",JBIGDescription);
#if defined(MAGICKCORE_JBIG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadJBIGImage;
entry->encoder=(EncodeImageHandler *) WriteJBIGImage;
#endif
- entry->description=ConstantString(JBIGDescription);
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("JBIG");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("JNX");
+ entry=AcquireMagickInfo("JNX","JNX","Garmin tile format");
entry->decoder=(DecodeImageHandler *) ReadJNXImage;
- entry->description=ConstantString("Garmin tile format");
entry->flags|=CoderSeekableStreamFlag;
- entry->module=ConstantString("JNX");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
(void) FormatLocaleString(version,MaxTextExtent,"%s",opj_version());
#endif
- entry=SetMagickInfo("JP2");
- entry->description=ConstantString("JPEG-2000 File Format Syntax");
+ entry=AcquireMagickInfo("JP2","JP2","JPEG-2000 File Format Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJP2;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
#endif
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("J2C");
- entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
+ entry=AcquireMagickInfo("JP2","J2C","JPEG-2000 Code Stream Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJ2K;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
#endif
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("J2K");
- entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
+ entry=AcquireMagickInfo("JP2","J2K","JPEG-2000 Code Stream Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJ2K;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
#endif
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JPM");
- entry->description=ConstantString("JPEG-2000 File Format Syntax");
+ entry=AcquireMagickInfo("JP2","JPM","JPEG-2000 File Format Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJP2;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
#endif
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JPT");
- entry->description=ConstantString("JPEG-2000 File Format Syntax");
+ entry=AcquireMagickInfo("JP2","JPT","JPEG-2000 File Format Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJP2;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
#endif
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JPC");
- entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
+ entry=AcquireMagickInfo("JP2","JPC","JPEG-2000 Code Stream Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJP2;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
*/
ModuleExport size_t RegisterJPEGImage(void)
{
+#define JPEGDescription "Joint Photographic Experts Group JFIF format"
+
char
version[MaxTextExtent];
MagickInfo
*entry;
- static const char
- description[] = "Joint Photographic Experts Group JFIF format";
-
*version='\0';
#if defined(JPEG_LIB_VERSION)
(void) FormatLocaleString(version,MaxTextExtent,"%d",JPEG_LIB_VERSION);
#endif
- entry=SetMagickInfo("JPE");
+ entry=AcquireMagickInfo("JPEG","JPE",JPEGDescription);
#if (JPEG_LIB_VERSION < 80) && !defined(LIBJPEG_TURBO_VERSION)
entry->thread_support=NoThreadSupport;
#endif
entry->magick=(IsImageFormatHandler *) IsJPEG;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderUseExtensionFlag;
- entry->description=ConstantString(description);
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jpeg");
- entry->module=ConstantString("JPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JPEG");
+ entry=AcquireMagickInfo("JPEG","JPEG",JPEGDescription);
#if (JPEG_LIB_VERSION < 80) && !defined(LIBJPEG_TURBO_VERSION)
entry->thread_support=NoThreadSupport;
#endif
#endif
entry->magick=(IsImageFormatHandler *) IsJPEG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(description);
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jpeg");
- entry->module=ConstantString("JPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JPG");
+ entry=AcquireMagickInfo("JPEG","JPG",JPEGDescription);
#if (JPEG_LIB_VERSION < 80) && !defined(LIBJPEG_TURBO_VERSION)
entry->thread_support=NoThreadSupport;
#endif
#endif
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderUseExtensionFlag;
- entry->description=ConstantString(description);
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jpeg");
- entry->module=ConstantString("JPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JPS");
+ entry=AcquireMagickInfo("JPEG","JPS",JPEGDescription);
#if (JPEG_LIB_VERSION < 80) && !defined(LIBJPEG_TURBO_VERSION)
entry->thread_support=NoThreadSupport;
#endif
#endif
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderUseExtensionFlag;
- entry->description=ConstantString(description);
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jpeg");
- entry->module=ConstantString("JPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PJPEG");
+ entry=AcquireMagickInfo("JPEG","PJPEG",JPEGDescription);
#if (JPEG_LIB_VERSION < 80) && !defined(LIBJPEG_TURBO_VERSION)
entry->thread_support=NoThreadSupport;
#endif
#endif
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderUseExtensionFlag;
- entry->description=ConstantString(description);
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jpeg");
- entry->module=ConstantString("JPEG");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("JSON");
+ entry=AcquireMagickInfo("JSON","JSON",
+ "The image format and characteristics");
entry->encoder=(EncodeImageHandler *) WriteJSONImage;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("The image format and characteristics");
- entry->module=ConstantString("JSON");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("LABEL");
+ entry=AcquireMagickInfo("LABEL","LABEL","Image label");
entry->decoder=(DecodeImageHandler *) ReadLABELImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Image label");
- entry->module=ConstantString("LABEL");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MAC");
+ entry=AcquireMagickInfo("MAC","MAC","MAC Paint");
entry->decoder=(DecodeImageHandler *) ReadMACImage;
- entry->description=ConstantString("MAC Paint");
- entry->module=ConstantString("MAC");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("GRANITE");
+ entry=AcquireMagickInfo("MAGICK","GRANITE","Granite texture");
entry->decoder=(DecodeImageHandler *) ReadMAGICKImage;
entry->encoder=(EncodeImageHandler *) WriteMAGICKImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("Granite texture");
- entry->module=ConstantString("MAGICK");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("H");
+ entry=AcquireMagickInfo("MAGICK","H","Internal format");
entry->decoder=(DecodeImageHandler *) ReadMAGICKImage;
entry->encoder=(EncodeImageHandler *) WriteMAGICKImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("Internal format");
- entry->module=ConstantString("MAGICK");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("LOGO");
+ entry=AcquireMagickInfo("MAGICK","LOGO","ImageMagick Logo");
entry->decoder=(DecodeImageHandler *) ReadMAGICKImage;
entry->encoder=(EncodeImageHandler *) WriteMAGICKImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("ImageMagick Logo");
- entry->module=ConstantString("MAGICK");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MAGICK");
+ entry=AcquireMagickInfo("MAGICK","MAGICK","Predefined Magick Image");
entry->decoder=(DecodeImageHandler *) ReadMAGICKImage;
entry->encoder=(EncodeImageHandler *) WriteMAGICKImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("Predefined Magick Image");
- entry->module=ConstantString("MAGICK");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("NETSCAPE");
+ entry=AcquireMagickInfo("MAGICK","NETSCAPE","Netscape 216 color cube");
entry->decoder=(DecodeImageHandler *) ReadMAGICKImage;
entry->encoder=(EncodeImageHandler *) WriteMAGICKImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("Netscape 216 color cube");
- entry->module=ConstantString("MAGICK");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ROSE");
+ entry=AcquireMagickInfo("MAGICK","ROSE","70x46 Truecolor rose");
entry->decoder=(DecodeImageHandler *) ReadMAGICKImage;
entry->encoder=(EncodeImageHandler *) WriteMAGICKImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("70x46 Truecolor rose");
- entry->module=ConstantString("MAGICK");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("WIZARD");
+ entry=AcquireMagickInfo("MAGICK","WIZARD","ImageMagick Wizard");
entry->decoder=(DecodeImageHandler *) ReadMAGICKImage;
entry->encoder=(EncodeImageHandler *) WriteMAGICKImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("ImageMagick Wizard");
- entry->module=ConstantString("MAGICK");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MAP");
+ entry=AcquireMagickInfo("MAP","MAP","Colormap intensities and indices");
entry->decoder=(DecodeImageHandler *) ReadMAPImage;
entry->encoder=(EncodeImageHandler *) WriteMAPImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ExplicitFormatType;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Colormap intensities and indices");
- entry->module=ConstantString("MAP");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MASK");
+ entry=AcquireMagickInfo("MASK","MASK","Image Clip Mask");
entry->decoder=(DecodeImageHandler *) ReadMASKImage;
entry->encoder=(EncodeImageHandler *) WriteMASKImage;
- entry->description=ConstantString("Image Clip Mask");
- entry->module=ConstantString("MASK");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MAT");
+ entry=AcquireMagickInfo("MAT","MAT","MATLAB level 5 image format");
entry->decoder=(DecodeImageHandler *) ReadMATImage;
entry->encoder=(EncodeImageHandler *) WriteMATImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=AcquireString("MATLAB level 5 image format");
- entry->module=AcquireString("MAT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MATTE");
+ entry=AcquireMagickInfo("MATTE","MATTE","MATTE format");
entry->encoder=(EncodeImageHandler *) WriteMATTEImage;
entry->format_type=ExplicitFormatType;
- entry->description=ConstantString("MATTE format");
- entry->module=ConstantString("MATTE");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("8BIM");
+ entry=AcquireMagickInfo("META","8BIM","Photoshop resource format");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Photoshop resource format");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("8BIMTEXT");
+ entry=AcquireMagickInfo("META","8BIMTEXT","Photoshop resource text format");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Photoshop resource text format");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("8BIMWTEXT");
+ entry=AcquireMagickInfo("META","8BIMWTEXT",
+ "Photoshop resource wide text format");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Photoshop resource wide text format");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("APP1");
+ entry=AcquireMagickInfo("META","APP1","Raw application information");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Raw application information");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("APP1JPEG");
+ entry=AcquireMagickInfo("META","APP1JPEG","Raw JPEG binary data");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Raw JPEG binary data");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("EXIF");
+ entry=AcquireMagickInfo("META","EXIF","Exif digital camera binary data");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Exif digital camera binary data");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("XMP");
+ entry=AcquireMagickInfo("META","XMP","Adobe XML metadata");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Adobe XML metadata");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ICM");
+ entry=AcquireMagickInfo("META","ICM","ICC Color Profile");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("ICC Color Profile");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ICC");
+ entry=AcquireMagickInfo("META","ICC","ICC Color Profile");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("ICC Color Profile");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("IPTC");
+ entry=AcquireMagickInfo("META","IPTC","IPTC Newsphoto");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("IPTC Newsphoto");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("IPTCTEXT");
+ entry=AcquireMagickInfo("META","IPTCTEXT","IPTC Newsphoto text format");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("IPTC Newsphoto text format");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("IPTCWTEXT");
+ entry=AcquireMagickInfo("META","IPTCWTEXT","IPTC Newsphoto text format");
entry->decoder=(DecodeImageHandler *) ReadMETAImage;
entry->encoder=(EncodeImageHandler *) WriteMETAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("IPTC Newsphoto text format");
- entry->module=ConstantString("META");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
(void) ConcatenateMagickString(version," and BZlib",MaxTextExtent);
#endif
#endif
- entry=SetMagickInfo("MIFF");
+ entry=AcquireMagickInfo("MIFF","MIFF","Magick Image File Format");
entry->decoder=(DecodeImageHandler *) ReadMIFFImage;
entry->encoder=(EncodeImageHandler *) WriteMIFFImage;
entry->magick=(IsImageFormatHandler *) IsMIFF;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Magick Image File Format");
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("MIFF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MONO");
+ entry=AcquireMagickInfo("MONO","MONO","Raw bi-level bitmap");
entry->decoder=(DecodeImageHandler *) ReadMONOImage;
entry->encoder=(EncodeImageHandler *) WriteMONOImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Raw bi-level bitmap");
- entry->module=ConstantString("MONO");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("CACHE");
- entry->description=ConstantString("Magick Persistent Cache image format");
+ entry=AcquireMagickInfo("MPC","CACHE",
+ "Magick Persistent Cache image format");
entry->module=ConstantString("CACHE");
entry->flags|=CoderStealthFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MPC");
+ entry=AcquireMagickInfo("MPC","MPC","Magick Persistent Cache image format");
entry->decoder=(DecodeImageHandler *) ReadMPCImage;
entry->encoder=(EncodeImageHandler *) WriteMPCImage;
entry->magick=(IsImageFormatHandler *) IsMPC;
- entry->description=ConstantString("Magick Persistent Cache image format");
- entry->module=ConstantString("MPC");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("AVI");
+ entry=AcquireMagickInfo("MPEG","AVI","Microsoft Audio/Visual Interleaved");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->magick=(IsImageFormatHandler *) IsAVI;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Microsoft Audio/Visual Interleaved");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MKV");
+ entry=AcquireMagickInfo("MPEG","MKV","Multimedia Container");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
entry->magick=(IsImageFormatHandler *) IsMPEG;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Multimedia Container");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MOV");
+ entry=AcquireMagickInfo("MPEG","MOV","MPEG Video Stream");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
entry->magick=(IsImageFormatHandler *) IsMPEG;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("MPEG Video Stream");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MPEG");
+ entry=AcquireMagickInfo("MPEG","MPEG","MPEG Video Stream");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
entry->magick=(IsImageFormatHandler *) IsMPEG;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("MPEG Video Stream");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MPG");
+ entry=AcquireMagickInfo("MPEG","MPG","MPEG Video Stream");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
entry->magick=(IsImageFormatHandler *) IsMPEG;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("MPEG Video Stream");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MP4");
+ entry=AcquireMagickInfo("MPEG","MP4","MPEG-4 Video Stream");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
entry->magick=(IsImageFormatHandler *) IsMPEG;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("MPEG-4 Video Stream");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("M2V");
+ entry=AcquireMagickInfo("MPEG","M2V","MPEG Video Stream");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
entry->magick=(IsImageFormatHandler *) IsMPEG;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("MPEG Video Stream");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("M4V");
+ entry=AcquireMagickInfo("MPEG","M4V","Raw MPEG-4 Video");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
entry->magick=(IsImageFormatHandler *) IsMPEG;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Raw MPEG-4 Video");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("WMV");
+ entry=AcquireMagickInfo("MPEG","WMV","Windows Media Video");
entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
entry->magick=(IsImageFormatHandler *) IsMPEG;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Windows Media Video");
- entry->module=ConstantString("MPEG");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MPR");
+ entry=AcquireMagickInfo("MPR","MPR","Magick Persistent Registry");
entry->decoder=(DecodeImageHandler *) ReadMPRImage;
entry->encoder=(EncodeImageHandler *) WriteMPRImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("Magick Persistent Registry");
- entry->module=ConstantString("MPR");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MPRI");
+ entry=AcquireMagickInfo("MPR","MPRI","Magick Persistent Registry");
entry->decoder=(DecodeImageHandler *) ReadMPRImage;
entry->encoder=(EncodeImageHandler *) WriteMPRImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("Magick Persistent Registry");
- entry->module=ConstantString("MPRI");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
#if defined(MAGICKCORE_XML_DELEGATE)
xmlInitParser();
#endif
- entry=SetMagickInfo("MSL");
+ entry=AcquireMagickInfo("MSL","MSL","Magick Scripting Language");
#if defined(MAGICKCORE_XML_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadMSLImage;
entry->encoder=(EncodeImageHandler *) WriteMSLImage;
#endif
- entry->description=ConstantString("Magick Scripting Language");
- entry->module=ConstantString("MSL");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MTV");
+ entry=AcquireMagickInfo("MTV","MTV","MTV Raytracing image format");
entry->decoder=(DecodeImageHandler *) ReadMTVImage;
entry->encoder=(EncodeImageHandler *) WriteMTVImage;
- entry->description=ConstantString("MTV Raytracing image format");
- entry->module=ConstantString("MTV");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("MVG");
+ entry=AcquireMagickInfo("MVG","MVG","Magick Vector Graphics");
entry->decoder=(DecodeImageHandler *) ReadMVGImage;
entry->encoder=(EncodeImageHandler *) WriteMVGImage;
entry->magick=(IsImageFormatHandler *) IsMVG;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Magick Vector Graphics");
- entry->module=ConstantString("MVG");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("NULL");
+ entry=AcquireMagickInfo("NULL","NULL","Constant image of uniform color");
entry->decoder=(DecodeImageHandler *) ReadNULLImage;
entry->encoder=(EncodeImageHandler *) WriteNULLImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Constant image of uniform color");
- entry->module=ConstantString("NULL");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("OTB");
+ entry=AcquireMagickInfo("OTB","OTB","On-the-air bitmap");
entry->decoder=(DecodeImageHandler *) ReadOTBImage;
entry->encoder=(EncodeImageHandler *) WriteOTBImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("On-the-air bitmap");
- entry->module=ConstantString("OTB");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PALM");
+ entry=AcquireMagickInfo("PALM","PALM","Palm pixmap");
entry->decoder=(DecodeImageHandler *) ReadPALMImage;
entry->encoder=(EncodeImageHandler *) WritePALMImage;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Palm pixmap");
- entry->module=ConstantString("PALM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
(void) FormatLocaleString(version,MaxTextExtent,"Pangocairo %s",
PANGO_VERSION_STRING);
#endif
- entry=SetMagickInfo("PANGO");
+ entry=AcquireMagickInfo("PANGO","PANGO","Pango Markup Language");
#if defined(MAGICKCORE_PANGOCAIRO_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPANGOImage;
#endif
- entry->description=ConstantString("Pango Markup Language");
if (*version != '\0')
entry->version=ConstantString(version);
entry->flags^=CoderAdjoinFlag;
- entry->module=ConstantString("PANGO");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PATTERN");
+ entry=AcquireMagickInfo("PATTERN","PATTERN","Predefined pattern");
entry->decoder=(DecodeImageHandler *) ReadPATTERNImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Predefined pattern");
- entry->module=ConstantString("PATTERN");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PCD");
+ entry=AcquireMagickInfo("PCD","PCD","Photo CD");
entry->decoder=(DecodeImageHandler *) ReadPCDImage;
entry->encoder=(EncodeImageHandler *) WritePCDImage;
entry->magick=(IsImageFormatHandler *) IsPCD;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Photo CD");
- entry->module=ConstantString("PCD");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PCDS");
+ entry=AcquireMagickInfo("PCD","PCDS","Photo CD");
entry->decoder=(DecodeImageHandler *) ReadPCDImage;
entry->encoder=(EncodeImageHandler *) WritePCDImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Photo CD");
- entry->module=ConstantString("PCD");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PCL");
+ entry=AcquireMagickInfo("PCL","PCL","Printer Control Language");
entry->decoder=(DecodeImageHandler *) ReadPCLImage;
entry->encoder=(EncodeImageHandler *) WritePCLImage;
entry->magick=(IsImageFormatHandler *) IsPCL;
entry->flags^=CoderBlobSupportFlag;
entry->flags^=CoderDecoderThreadSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Printer Control Language");
- entry->module=ConstantString("PCL");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("DCX");
+ entry=AcquireMagickInfo("PCX","DCX","ZSoft IBM PC multi-page Paintbrush");
entry->decoder=(DecodeImageHandler *) ReadPCXImage;
entry->encoder=(EncodeImageHandler *) WritePCXImage;
entry->flags|=CoderSeekableStreamFlag;
entry->magick=(IsImageFormatHandler *) IsDCX;
- entry->description=ConstantString("ZSoft IBM PC multi-page Paintbrush");
- entry->module=ConstantString("PCX");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PCX");
+ entry=AcquireMagickInfo("PCX","PCX","ZSoft IBM PC Paintbrush");
entry->decoder=(DecodeImageHandler *) ReadPCXImage;
entry->encoder=(EncodeImageHandler *) WritePCXImage;
entry->magick=(IsImageFormatHandler *) IsPCX;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("ZSoft IBM PC Paintbrush");
- entry->module=ConstantString("PCX");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PDB");
+ entry=AcquireMagickInfo("PDB","PDB","Palm Database ImageViewer Format");
entry->decoder=(DecodeImageHandler *) ReadPDBImage;
entry->encoder=(EncodeImageHandler *) WritePDBImage;
entry->magick=(IsImageFormatHandler *) IsPDB;
- entry->description=ConstantString("Palm Database ImageViewer Format");
- entry->module=ConstantString("PDB");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("AI");
+ entry=AcquireMagickInfo("PDF","AI","Adobe Illustrator CS2");
entry->decoder=(DecodeImageHandler *) ReadPDFImage;
entry->encoder=(EncodeImageHandler *) WritePDFImage;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Adobe Illustrator CS2");
entry->mime_type=ConstantString("application/pdf");
- entry->module=ConstantString("PDF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("EPDF");
+ entry=AcquireMagickInfo("PDF","EPDF",
+ "Encapsulated Portable Document Format");
entry->decoder=(DecodeImageHandler *) ReadPDFImage;
entry->encoder=(EncodeImageHandler *) WritePDFImage;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Encapsulated Portable Document Format");
entry->mime_type=ConstantString("application/pdf");
- entry->module=ConstantString("PDF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PDF");
+ entry=AcquireMagickInfo("PDF","PDF","Portable Document Format");
entry->decoder=(DecodeImageHandler *) ReadPDFImage;
entry->encoder=(EncodeImageHandler *) WritePDFImage;
entry->magick=(IsImageFormatHandler *) IsPDF;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Portable Document Format");
entry->mime_type=ConstantString("application/pdf");
- entry->module=ConstantString("PDF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PDFA");
+ entry=AcquireMagickInfo("PDF","PDFA","Portable Document Archive Format");
entry->decoder=(DecodeImageHandler *) ReadPDFImage;
entry->encoder=(EncodeImageHandler *) WritePDFImage;
entry->magick=(IsImageFormatHandler *) IsPDF;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Portable Document Archive Format");
entry->mime_type=ConstantString("application/pdf");
- entry->module=ConstantString("PDF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PES");
+ entry=AcquireMagickInfo("PES","PES","Embrid Embroidery Format");
entry->decoder=(DecodeImageHandler *) ReadPESImage;
entry->magick=(IsImageFormatHandler *) IsPES;
- entry->description=ConstantString("Embrid Embroidery Format");
- entry->module=ConstantString("PES");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PCT");
+ entry=AcquireMagickInfo("PICT","PCT","Apple Macintosh QuickDraw/PICT");
entry->decoder=(DecodeImageHandler *) ReadPICTImage;
entry->encoder=(EncodeImageHandler *) WritePICTImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Apple Macintosh QuickDraw/PICT");
entry->magick=(IsImageFormatHandler *) IsPICT;
- entry->module=ConstantString("PICT");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PICT");
+ entry=AcquireMagickInfo("PICT","PICT","Apple Macintosh QuickDraw/PICT");
entry->decoder=(DecodeImageHandler *) ReadPICTImage;
entry->encoder=(EncodeImageHandler *) WritePICTImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Apple Macintosh QuickDraw/PICT");
entry->magick=(IsImageFormatHandler *) IsPICT;
- entry->module=ConstantString("PICT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PIX");
+ entry=AcquireMagickInfo("PIX","PIX","Alias/Wavefront RLE image format");
entry->decoder=(DecodeImageHandler *) ReadPIXImage;
- entry->description=ConstantString("Alias/Wavefront RLE image format");
- entry->module=ConstantString("PIX");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PLASMA");
+ entry=AcquireMagickInfo("PLASMA","PLASMA","Plasma fractal image");
entry->decoder=(DecodeImageHandler *) ReadPlasmaImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Plasma fractal image");
- entry->module=ConstantString("PLASMA");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("FRACTAL");
+ entry=AcquireMagickInfo("PLASMA","FRACTAL","Plasma fractal image");
entry->decoder=(DecodeImageHandler *) ReadPlasmaImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Plasma fractal image");
- entry->module=ConstantString("PLASMA");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
}
#endif
- entry=SetMagickInfo("MNG");
+ entry=AcquireMagickInfo("PNG","MNG","Multiple-image Network Graphics");
entry->flags|=CoderSeekableStreamFlag; /* To do: eliminate this. */
#if defined(MAGICKCORE_PNG_DELEGATE)
#endif
entry->magick=(IsImageFormatHandler *) IsMNG;
- entry->description=ConstantString("Multiple-image Network Graphics");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("video/x-mng");
- entry->module=ConstantString("PNG");
entry->note=ConstantString(MNGNote);
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNG");
+ entry=AcquireMagickInfo("PNG","PNG","Portable Network Graphics");
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPNGImage;
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Portable Network Graphics");
entry->mime_type=ConstantString("image/png");
- entry->module=ConstantString("PNG");
if (*version != '\0')
entry->version=ConstantString(version);
entry->note=ConstantString(PNGNote);
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNG8");
+ entry=AcquireMagickInfo("PNG","PNG8",
+ "8-bit indexed with optional binary transparency");
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPNGImage;
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(
- "8-bit indexed with optional binary transparency");
entry->mime_type=ConstantString("image/png");
- entry->module=ConstantString("PNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNG24");
+ entry=AcquireMagickInfo("PNG","PNG24",
+ "opaque or binary transparent 24-bit RGB");
*version='\0';
#if defined(ZLIB_VERSION)
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("opaque or binary transparent 24-bit RGB");
entry->mime_type=ConstantString("image/png");
- entry->module=ConstantString("PNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNG32");
+ entry=AcquireMagickInfo("PNG","PNG32","opaque or transparent 32-bit RGBA");
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPNGImage;
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("opaque or transparent 32-bit RGBA");
entry->mime_type=ConstantString("image/png");
- entry->module=ConstantString("PNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNG48");
+ entry=AcquireMagickInfo("PNG","PNG48",
+ "opaque or binary transparent 48-bit RGB");
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPNGImage;
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("opaque or binary transparent 48-bit RGB");
entry->mime_type=ConstantString("image/png");
- entry->module=ConstantString("PNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNG64");
+ entry=AcquireMagickInfo("PNG","PNG64","opaque or transparent 64-bit RGBA");
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPNGImage;
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("opaque or transparent 64-bit RGBA");
entry->mime_type=ConstantString("image/png");
- entry->module=ConstantString("PNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNG00");
+ entry=AcquireMagickInfo("PNG","PNG00",
+ "PNG inheriting bit-depth and color-type from original");
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPNGImage;
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(
- "PNG inheriting bit-depth and color-type from original");
entry->mime_type=ConstantString("image/png");
- entry->module=ConstantString("PNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JNG");
+ entry=AcquireMagickInfo("PNG","JNG","JPEG Network Graphics");
#if defined(JNG_SUPPORTED)
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->magick=(IsImageFormatHandler *) IsJNG;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("JPEG Network Graphics");
entry->mime_type=ConstantString("image/x-jng");
- entry->module=ConstantString("PNG");
entry->note=ConstantString(JNGNote);
(void) RegisterMagickInfo(entry);
MagickInfo
*entry;
- entry=SetMagickInfo("PAM");
+ entry=AcquireMagickInfo("PNM","PAM","Common 2-dimensional bitmap format");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->description=ConstantString("Common 2-dimensional bitmap format");
entry->mime_type=ConstantString("image/x-portable-pixmap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PBM");
+ entry=AcquireMagickInfo("PNM","PBM",
+ "Portable bitmap format (black and white)");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->description=ConstantString("Portable bitmap format (black and white)");
entry->mime_type=ConstantString("image/x-portable-bitmap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PFM");
+ entry=AcquireMagickInfo("PNM","PFM","Portable float format");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Portable float format");
- entry->module=ConstantString("PFM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PGM");
+ entry=AcquireMagickInfo("PNM","PGM","Portable graymap format (gray scale)");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->description=ConstantString("Portable graymap format (gray scale)");
entry->mime_type=ConstantString("image/x-portable-greymap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNM");
+ entry=AcquireMagickInfo("PNM","PNM","Portable anymap");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
entry->magick=(IsImageFormatHandler *) IsPNM;
- entry->description=ConstantString("Portable anymap");
entry->mime_type=ConstantString("image/x-portable-pixmap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PPM");
+ entry=AcquireMagickInfo("PNM","PPM","Portable pixmap format (color)");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->description=ConstantString("Portable pixmap format (color)");
entry->mime_type=ConstantString("image/x-portable-pixmap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PREVIEW");
+ entry=AcquireMagickInfo("PREVIEW","PREVIEW",
+ "Show a preview an image enhancement, effect, or f/x");
entry->encoder=(EncodeImageHandler *) WritePreviewImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString(
- "Show a preview an image enhancement, effect, or f/x");
- entry->module=ConstantString("PREVIEW");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("EPI");
+ entry=AcquireMagickInfo("PS","EPI",
+ "Encapsulated PostScript Interchange format");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString(
- "Encapsulated PostScript Interchange format");
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("EPS");
+ entry=AcquireMagickInfo("PS","EPS","Encapsulated PostScript");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Encapsulated PostScript");
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("EPSF");
+ entry=AcquireMagickInfo("PS","EPSF","Encapsulated PostScript");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Encapsulated PostScript");
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("EPSI");
+ entry=AcquireMagickInfo("PS","EPSI",
+ "Encapsulated PostScript Interchange format");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString(
- "Encapsulated PostScript Interchange format");
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PS");
+ entry=AcquireMagickInfo("PS","PS","PostScript");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS");
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("PostScript");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("EPS2");
+ entry=AcquireMagickInfo("PS2","EPS2","Level II Encapsulated PostScript");
entry->encoder=(EncodeImageHandler *) WritePS2Image;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Level II Encapsulated PostScript");
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS2");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PS2");
+ entry=AcquireMagickInfo("PS2","PS2","Level II PostScript");
entry->encoder=(EncodeImageHandler *) WritePS2Image;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Level II PostScript");
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS2");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("EPS3");
+ entry=AcquireMagickInfo("PS3","EPS3","Level III Encapsulated PostScript");
entry->encoder=(EncodeImageHandler *) WritePS3Image;
- entry->description=ConstantString("Level III Encapsulated PostScript");
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS3");
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PS3");
+ entry=AcquireMagickInfo("PS3","PS3","Level III PostScript");
entry->encoder=(EncodeImageHandler *) WritePS3Image;
- entry->description=ConstantString("Level III PostScript");
entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS3");
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
MagickInfo
*entry;
- entry=SetMagickInfo("PSB");
+ entry=AcquireMagickInfo("PSD","PSB","Adobe Large Document Format");
entry->decoder=(DecodeImageHandler *) ReadPSDImage;
entry->encoder=(EncodeImageHandler *) WritePSDImage;
entry->magick=(IsImageFormatHandler *) IsPSD;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Adobe Large Document Format");
- entry->module=ConstantString("PSD");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PSD");
+ entry=AcquireMagickInfo("PSD","PSD","Adobe Photoshop bitmap");
entry->decoder=(DecodeImageHandler *) ReadPSDImage;
entry->encoder=(EncodeImageHandler *) WritePSDImage;
entry->magick=(IsImageFormatHandler *) IsPSD;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Adobe Photoshop bitmap");
- entry->module=ConstantString("PSD");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("PWP");
+ entry=AcquireMagickInfo("PWP","PWP","Seattle Film Works");
entry->decoder=(DecodeImageHandler *) ReadPWPImage;
entry->magick=(IsImageFormatHandler *) IsPWP;
- entry->description=ConstantString("Seattle Film Works");
- entry->module=ConstantString("PWP");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("R");
+ entry=AcquireMagickInfo("RAW","R","Raw red samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw red samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("C");
+ entry=AcquireMagickInfo("RAW","C","Raw cyan samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw cyan samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("G");
+ entry=AcquireMagickInfo("RAW","G","Raw green samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw green samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("M");
+ entry=AcquireMagickInfo("RAW","M","Raw magenta samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw magenta samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("B");
+ entry=AcquireMagickInfo("RAW","B","Raw blue samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw blue samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("Y");
+ entry=AcquireMagickInfo("RAW","Y","Raw yellow samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw yellow samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("A");
+ entry=AcquireMagickInfo("RAW","A","Raw alpha samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw alpha samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("O");
+ entry=AcquireMagickInfo("RAW","O","Raw opacity samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw opacity samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("K");
+ entry=AcquireMagickInfo("RAW","K","Raw black samples");
entry->decoder=(DecodeImageHandler *) ReadRAWImage;
entry->encoder=(EncodeImageHandler *) WriteRAWImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw black samples");
- entry->module=ConstantString("RAW");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("RGB");
+ entry=AcquireMagickInfo("RGB","RGB",
+ "Raw red, green, and blue samples");
entry->decoder=(DecodeImageHandler *) ReadRGBImage;
entry->encoder=(EncodeImageHandler *) WriteRGBImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw red, green, and blue samples");
- entry->module=ConstantString("RGB");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("RGBA");
+ entry=AcquireMagickInfo("RGB","RGBA",
+ "Raw red, green, blue, and alpha samples");
entry->decoder=(DecodeImageHandler *) ReadRGBImage;
entry->encoder=(EncodeImageHandler *) WriteRGBImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw red, green, blue, and alpha samples");
- entry->module=ConstantString("RGB");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("RGBO");
+ entry=AcquireMagickInfo("RGB","RGBO",
+ "Raw red, green, blue, and opacity samples");
entry->decoder=(DecodeImageHandler *) ReadRGBImage;
entry->encoder=(EncodeImageHandler *) WriteRGBImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw red, green, blue, and opacity samples");
- entry->module=ConstantString("RGB");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("RGF");
+ entry=AcquireMagickInfo("RGF","RGF",
+ "LEGO Mindstorms EV3 Robot Graphic Format (black and white)");
entry->decoder=(DecodeImageHandler *) ReadRGFImage;
entry->encoder=(EncodeImageHandler *) WriteRGFImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(
- "LEGO Mindstorms EV3 Robot Graphic Format (black and white)");
- entry->module=ConstantString("RGF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("RLA");
+ entry=AcquireMagickInfo("RLA","RLA","Alias/Wavefront image");
entry->decoder=(DecodeImageHandler *) ReadRLAImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Alias/Wavefront image");
- entry->module=ConstantString("RLA");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("RLE");
+ entry=AcquireMagickInfo("RLE","RLE","Utah Run length encoded image");
entry->decoder=(DecodeImageHandler *) ReadRLEImage;
entry->magick=(IsImageFormatHandler *) IsRLE;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Utah Run length encoded image");
- entry->module=ConstantString("RLE");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("SCR");
+ entry=AcquireMagickInfo("SCR","SCR","ZX-Spectrum SCREEN$");
entry->decoder=(DecodeImageHandler *) ReadSCRImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("ZX-Spectrum SCREEN$");
- entry->module=ConstantString("SCR");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("SCREENSHOT");
+ entry=AcquireMagickInfo("SCREENSHOT","SCREENSHOT","Screen shot");
entry->decoder=(DecodeImageHandler *) ReadSCREENSHOTImage;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Screen shot");
- entry->module=ConstantString("SCREENSHOT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("SCT");
+ entry=AcquireMagickInfo("SCT","SCT","Scitex HandShake");
entry->decoder=(DecodeImageHandler *) ReadSCTImage;
entry->magick=(IsImageFormatHandler *) IsSCT;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Scitex HandShake");
- entry->module=ConstantString("SCT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("SFW");
+ entry=AcquireMagickInfo("SFW","SFW","Seattle Film Works");
entry->decoder=(DecodeImageHandler *) ReadSFWImage;
entry->magick=(IsImageFormatHandler *) IsSFW;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Seattle Film Works");
- entry->module=ConstantString("SFW");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("SGI");
+ entry=AcquireMagickInfo("SGI","SGI","Irix RGB image");
entry->decoder=(DecodeImageHandler *) ReadSGIImage;
entry->encoder=(EncodeImageHandler *) WriteSGIImage;
entry->magick=(IsImageFormatHandler *) IsSGI;
- entry->description=ConstantString("Irix RGB image");
- entry->module=ConstantString("SGI");
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
MagickInfo
*entry;
- entry=SetMagickInfo("SIXEL");
+ entry=AcquireMagickInfo("SIXEL","SIXEL","DEC SIXEL Graphics Format");
entry->decoder=(DecodeImageHandler *) ReadSIXELImage;
entry->encoder=(EncodeImageHandler *) WriteSIXELImage;
entry->magick=(IsImageFormatHandler *) IsSIXEL;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("DEC SIXEL Graphics Format");
- entry->module=ConstantString("SIXEL");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("SIX");
+ entry=AcquireMagickInfo("SIX","SIX","DEC SIXEL Graphics Format");
entry->decoder=(DecodeImageHandler *) ReadSIXELImage;
entry->encoder=(EncodeImageHandler *) WriteSIXELImage;
entry->magick=(IsImageFormatHandler *) IsSIXEL;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("DEC SIXEL Graphics Format");
- entry->module=ConstantString("SIX");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("STEGANO");
+ entry=AcquireMagickInfo("STEGANO","STEGANO","Steganographic image");
entry->decoder=(DecodeImageHandler *) ReadSTEGANOImage;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Steganographic image");
- entry->module=ConstantString("STEGANO");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("RAS");
+ entry=AcquireMagickInfo("SUN","RAS","SUN Rasterfile");
entry->decoder=(DecodeImageHandler *) ReadSUNImage;
entry->encoder=(EncodeImageHandler *) WriteSUNImage;
entry->magick=(IsImageFormatHandler *) IsSUN;
- entry->description=ConstantString("SUN Rasterfile");
- entry->module=ConstantString("SUN");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("SUN");
+ entry=AcquireMagickInfo("SUN","SUN","SUN Rasterfile");
entry->decoder=(DecodeImageHandler *) ReadSUNImage;
entry->encoder=(EncodeImageHandler *) WriteSUNImage;
- entry->description=ConstantString("SUN Rasterfile");
- entry->module=ConstantString("SUN");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
(void) FormatLocaleString(version,MaxTextExtent,"RSVG %d.%d.%d",
LIBRSVG_MAJOR_VERSION,LIBRSVG_MINOR_VERSION,LIBRSVG_MICRO_VERSION);
#endif
- entry=SetMagickInfo("SVG");
+ entry=AcquireMagickInfo("SVG","SVG","Scalable Vector Graphics");
#if defined(MAGICKCORE_XML_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadSVGImage;
#endif
entry->encoder=(EncodeImageHandler *) WriteSVGImage;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Scalable Vector Graphics");
entry->mime_type=ConstantString("image/svg+xml");
if (*version != '\0')
entry->version=ConstantString(version);
entry->magick=(IsImageFormatHandler *) IsSVG;
- entry->module=ConstantString("SVG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("SVGZ");
+ entry=AcquireMagickInfo("SVG","SVGZ","Compressed Scalable Vector Graphics");
#if defined(MAGICKCORE_XML_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadSVGImage;
#endif
entry->encoder=(EncodeImageHandler *) WriteSVGImage;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("Compressed Scalable Vector Graphics");
entry->mime_type=ConstantString("image/svg+xml");
if (*version != '\0')
entry->version=ConstantString(version);
entry->magick=(IsImageFormatHandler *) IsSVG;
- entry->module=ConstantString("SVG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("MSVG");
+ entry=AcquireMagickInfo("SVG","MSVG",
+ "ImageMagick's own SVG internal renderer");
#if defined(MAGICKCORE_XML_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadSVGImage;
#endif
entry->encoder=(EncodeImageHandler *) WriteSVGImage;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("ImageMagick's own SVG internal renderer");
entry->magick=(IsImageFormatHandler *) IsSVG;
- entry->module=ConstantString("SVG");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("ICB");
+ entry=AcquireMagickInfo("TGA","ICB","Truevision Targa image");
entry->decoder=(DecodeImageHandler *) ReadTGAImage;
entry->encoder=(EncodeImageHandler *) WriteTGAImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Truevision Targa image");
- entry->module=ConstantString("TGA");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("TGA");
+ entry=AcquireMagickInfo("TGA","TGA","Truevision Targa image");
entry->decoder=(DecodeImageHandler *) ReadTGAImage;
entry->encoder=(EncodeImageHandler *) WriteTGAImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Truevision Targa image");
- entry->module=ConstantString("TGA");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("VDA");
+ entry=AcquireMagickInfo("TGA","VDA","Truevision Targa image");
entry->decoder=(DecodeImageHandler *) ReadTGAImage;
entry->encoder=(EncodeImageHandler *) WriteTGAImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Truevision Targa image");
- entry->module=ConstantString("TGA");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("VST");
+ entry=AcquireMagickInfo("TGA","VST","Truevision Targa image");
entry->decoder=(DecodeImageHandler *) ReadTGAImage;
entry->encoder=(EncodeImageHandler *) WriteTGAImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Truevision Targa image");
- entry->module=ConstantString("TGA");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("THUMBNAIL");
+ entry=AcquireMagickInfo("THUMBNAIL","THUMBNAIL","EXIF Profile Thumbnail");
entry->encoder=(EncodeImageHandler *) WriteTHUMBNAILImage;
- entry->description=ConstantString("EXIF Profile Thumbnail");
- entry->module=ConstantString("THUMBNAIL");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
}
#endif
- entry=SetMagickInfo("GROUP4");
+ entry=AcquireMagickInfo("TIFF","GROUP4","Raw CCITT Group4");
#if defined(MAGICKCORE_TIFF_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadGROUP4Image;
entry->encoder=(EncodeImageHandler *) WriteGROUP4Image;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderUseExtensionFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Raw CCITT Group4");
entry->mime_type=ConstantString("image/tiff");
- entry->module=ConstantString("TIFF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PTIF");
+ entry=AcquireMagickInfo("TIFF","PTIF","Pyramid encoded TIFF");
#if defined(MAGICKCORE_TIFF_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTIFFImage;
entry->encoder=(EncodeImageHandler *) WritePTIFImage;
entry->flags|=CoderEndianSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderUseExtensionFlag;
- entry->description=ConstantString("Pyramid encoded TIFF");
entry->mime_type=ConstantString("image/tiff");
- entry->module=ConstantString("TIFF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("TIF");
+ entry=AcquireMagickInfo("TIFF","TIF",TIFFDescription);
#if defined(MAGICKCORE_TIFF_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTIFFImage;
entry->encoder=(EncodeImageHandler *) WriteTIFFImage;
entry->flags|=CoderSeekableStreamFlag;
entry->flags|=CoderStealthFlag;
entry->flags^=CoderUseExtensionFlag;
- entry->description=ConstantString(TIFFDescription);
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/tiff");
- entry->module=ConstantString("TIFF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("TIFF");
+ entry=AcquireMagickInfo("TIFF","TIFF",TIFFDescription);
#if defined(MAGICKCORE_TIFF_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTIFFImage;
entry->encoder=(EncodeImageHandler *) WriteTIFFImage;
entry->flags|=CoderEndianSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderUseExtensionFlag;
- entry->description=ConstantString(TIFFDescription);
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/tiff");
- entry->module=ConstantString("TIFF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("TIFF64");
+ entry=AcquireMagickInfo("TIFF","TIFF64","Tagged Image File Format (64-bit)");
#if defined(TIFF_VERSION_BIG)
entry->decoder=(DecodeImageHandler *) ReadTIFFImage;
entry->encoder=(EncodeImageHandler *) WriteTIFFImage;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderUseExtensionFlag;
- entry->description=ConstantString("Tagged Image File Format (64-bit)");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/tiff");
- entry->module=ConstantString("TIFF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("TILE");
+ entry=AcquireMagickInfo("TILE","TILE","Tile image with a texture");
entry->decoder=(DecodeImageHandler *) ReadTILEImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Tile image with a texture");
- entry->module=ConstantString("TILE");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("TIM");
+ entry=AcquireMagickInfo("TIM","TIM","PSX TIM");
entry->decoder=(DecodeImageHandler *) ReadTIMImage;
- entry->description=ConstantString("PSX TIM");
- entry->module=ConstantString("TIM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
(void) FormatLocaleString(version,MaxTextExtent,"Freetype %d.%d.%d",
FREETYPE_MAJOR,FREETYPE_MINOR,FREETYPE_PATCH);
#endif
- entry=SetMagickInfo("DFONT");
+ entry=AcquireMagickInfo("TTF","DFONT","Multi-face font package");
#if defined(MAGICKCORE_FREETYPE_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTTFImage;
#endif
entry->magick=(IsImageFormatHandler *) IsTTF;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Multi-face font package");
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("TTF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PFA");
+ entry=AcquireMagickInfo("TTF","PFA","Postscript Type 1 font (ASCII)");
#if defined(MAGICKCORE_FREETYPE_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTTFImage;
#endif
entry->magick=(IsImageFormatHandler *) IsPFA;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Postscript Type 1 font (ASCII)");
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("TTF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PFB");
+ entry=AcquireMagickInfo("TTF","PFB","Postscript Type 1 font (binary)");
#if defined(MAGICKCORE_FREETYPE_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTTFImage;
#endif
entry->magick=(IsImageFormatHandler *) IsPFA;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Postscript Type 1 font (binary)");
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("TTF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("OTF");
+ entry=AcquireMagickInfo("TTF","OTF","Open Type font");
#if defined(MAGICKCORE_FREETYPE_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTTFImage;
#endif
entry->magick=(IsImageFormatHandler *) IsTTF;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Open Type font");
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("TTF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("TTC");
+ entry=AcquireMagickInfo("TTF","TTC","TrueType font collection");
#if defined(MAGICKCORE_FREETYPE_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTTFImage;
#endif
entry->magick=(IsImageFormatHandler *) IsTTF;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("TrueType font collection");
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("TTF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("TTF");
+ entry=AcquireMagickInfo("TTF","TTF","TrueType font");
#if defined(MAGICKCORE_FREETYPE_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadTTFImage;
#endif
entry->magick=(IsImageFormatHandler *) IsTTF;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("TrueType font");
if (*version != '\0')
entry->version=ConstantString(version);
- entry->module=ConstantString("TTF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("SPARSE-COLOR");
+ entry=AcquireMagickInfo("TXT","SPARSE-COLOR","Sparse Color");
entry->encoder=(EncodeImageHandler *) WriteTXTImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Sparse Color");
- entry->module=ConstantString("TXT");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("TEXT");
+ entry=AcquireMagickInfo("TXT","TEXT","Text");
entry->decoder=(DecodeImageHandler *) ReadTXTImage;
entry->encoder=(EncodeImageHandler *) WriteTXTImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Text");
- entry->module=ConstantString("TXT");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("TXT");
+ entry=AcquireMagickInfo("TXT","TXT","Text");
entry->decoder=(DecodeImageHandler *) ReadTXTImage;
entry->encoder=(EncodeImageHandler *) WriteTXTImage;
- entry->description=ConstantString("Text");
entry->magick=(IsImageFormatHandler *) IsTXT;
- entry->module=ConstantString("TXT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("UIL");
+ entry=AcquireMagickInfo("UIL","UIL","X-Motif UIL table");
entry->encoder=(EncodeImageHandler *) WriteUILImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("X-Motif UIL table");
- entry->module=ConstantString("UIL");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("HTTP");
+ entry=AcquireMagickInfo("URL","HTTP","Uniform Resource Locator (http://)");
#if (defined(MAGICKCORE_WINDOWS_SUPPORT) && \
!(defined(__MINGW32__) || defined(__MINGW64__))) || \
(defined(MAGICKCORE_XML_DELEGATE) && defined(LIBXML_HTTP_ENABLED))
entry->decoder=(DecodeImageHandler *) ReadURLImage;
#endif
- entry->description=ConstantString("Uniform Resource Locator (http://)");
- entry->module=ConstantString("URL");
entry->flags|=CoderStealthFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("HTTPS");
+ entry=AcquireMagickInfo("URL","HTTPS","Uniform Resource Locator (https://)");
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && \
!(defined(__MINGW32__) || defined(__MINGW64__))
entry->decoder=(DecodeImageHandler *) ReadURLImage;
#endif
- entry->description=ConstantString("Uniform Resource Locator (https://)");
- entry->module=ConstantString("URL");
entry->flags|=CoderStealthFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("FTP");
+ entry=AcquireMagickInfo("URL","FTP","Uniform Resource Locator (ftp://)");
#if (defined(MAGICKCORE_WINDOWS_SUPPORT) && \
!(defined(__MINGW32__) || defined(__MINGW64__))) || \
(defined(MAGICKCORE_XML_DELEGATE) && defined(LIBXML_FTP_ENABLED))
entry->decoder=(DecodeImageHandler *) ReadURLImage;
#endif
- entry->description=ConstantString("Uniform Resource Locator (ftp://)");
- entry->module=ConstantString("URL");
entry->flags|=CoderStealthFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("FILE");
+ entry=AcquireMagickInfo("URL","FILE","Uniform Resource Locator (file://)");
entry->decoder=(DecodeImageHandler *) ReadURLImage;
- entry->description=ConstantString("Uniform Resource Locator (file://)");
- entry->module=ConstantString("URL");
entry->flags|=CoderStealthFlag;
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
MagickInfo
*entry;
- entry=SetMagickInfo("PAL");
+ entry=AcquireMagickInfo("UYVY","PAL","16bit/pixel interleaved YUV");
entry->decoder=(DecodeImageHandler *) ReadUYVYImage;
entry->encoder=(EncodeImageHandler *) WriteUYVYImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("16bit/pixel interleaved YUV");
- entry->module=ConstantString("UYVY");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("UYVY");
+ entry=AcquireMagickInfo("UYVY","UYVY","16bit/pixel interleaved YUV");
entry->decoder=(DecodeImageHandler *) ReadUYVYImage;
entry->encoder=(EncodeImageHandler *) WriteUYVYImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("16bit/pixel interleaved YUV");
- entry->module=ConstantString("UYVY");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("VICAR");
+ entry=AcquireMagickInfo("VICAR","VICAR","VICAR rasterfile format");
entry->decoder=(DecodeImageHandler *) ReadVICARImage;
entry->encoder=(EncodeImageHandler *) WriteVICARImage;
entry->magick=(IsImageFormatHandler *) IsVICAR;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("VICAR rasterfile format");
- entry->module=ConstantString("VICAR");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("VID");
+ entry=AcquireMagickInfo("VID","VID","Visual Image Directory");
entry->decoder=(DecodeImageHandler *) ReadVIDImage;
entry->encoder=(EncodeImageHandler *) WriteVIDImage;
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("Visual Image Directory");
- entry->module=ConstantString("VID");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("VIFF");
+ entry=AcquireMagickInfo("VIFF","VIFF","Khoros Visualization image");
entry->decoder=(DecodeImageHandler *) ReadVIFFImage;
entry->encoder=(EncodeImageHandler *) WriteVIFFImage;
entry->magick=(IsImageFormatHandler *) IsVIFF;
- entry->description=ConstantString("Khoros Visualization image");
- entry->module=ConstantString("VIFF");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("XV");
+ entry=AcquireMagickInfo("VIFF","XV","Khoros Visualization image");
entry->decoder=(DecodeImageHandler *) ReadVIFFImage;
entry->encoder=(EncodeImageHandler *) WriteVIFFImage;
- entry->description=ConstantString("Khoros Visualization image");
- entry->module=ConstantString("VIFF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("VIPS");
+ entry=AcquireMagickInfo("VIPS","VIPS","VIPS image");
entry->decoder=(DecodeImageHandler *) ReadVIPSImage;
entry->encoder=(EncodeImageHandler *) WriteVIPSImage;
entry->magick=(IsImageFormatHandler *) IsVIPS;
- entry->description=ConstantString("VIPS image");
entry->flags|=CoderEndianSupportFlag;
- entry->module=ConstantString("VIPS");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("WBMP");
+ entry=AcquireMagickInfo("WBMP","WBMP","Wireless Bitmap (level 0) image");
entry->decoder=(DecodeImageHandler *) ReadWBMPImage;
entry->encoder=(EncodeImageHandler *) WriteWBMPImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Wireless Bitmap (level 0) image");
- entry->module=ConstantString("WBMP");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
*entry;
*version='\0';
- entry=SetMagickInfo("WEBP");
+ entry=AcquireMagickInfo("WEBP","WEBP","WebP Image Format");
#if defined(MAGICKCORE_WEBP_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadWEBPImage;
entry->encoder=(EncodeImageHandler *) WriteWEBPImage;
(WebPGetDecoderVersion() >> 8) & 0xff,
(WebPGetDecoderVersion() >> 0) & 0xff,WEBP_DECODER_ABI_VERSION);
#endif
- entry->description=ConstantString("WebP Image Format");
entry->mime_type=ConstantString("image/x-webp");
entry->flags^=CoderAdjoinFlag;
- entry->module=ConstantString("WEBP");
entry->magick=(IsImageFormatHandler *) IsWEBP;
if (*version != '\0')
entry->version=ConstantString(version);
MagickInfo
*entry;
- entry = SetMagickInfo("WMZ");
+ entry = AcquireMagickInfo("WMF","WMZ","Compressed Windows Meta File");
#if defined(MAGICKCORE_WMF_DELEGATE) || defined(MAGICKCORE_WMFLITE_DELEGATE)
entry->decoder=ReadWMFImage;
#endif
- entry->description=ConstantString("Compressed Windows Meta File");
- entry->module=ConstantString("WMZ");
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("WMF");
+ entry=AcquireMagickInfo("WMF","WMF","Windows Meta File");
#if defined(MAGICKCORE_WMF_DELEGATE) || defined(MAGICKCORE_WMFLITE_DELEGATE)
entry->decoder=ReadWMFImage;
#endif
- entry->description=ConstantString("Windows Meta File");
- entry->module=ConstantString("WMF");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("WPG");
+ entry=AcquireMagickInfo("WPG","WPG","Word Perfect Graphics");
entry->decoder=(DecodeImageHandler *) ReadWPGImage;
entry->magick=(IsImageFormatHandler *) IsWPG;
- entry->description=AcquireString("Word Perfect Graphics");
- entry->module=ConstantString("WPG");
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
MagickInfo
*entry;
- entry=SetMagickInfo("X");
+ entry=SetMagickInfo("X","X","X Image");
#if defined(MAGICKCORE_X11_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadXImage;
entry->encoder=(EncodeImageHandler *) WriteXImage;
#endif
entry->format_type=ImplicitFormatType;
- entry->description=ConstantString("X Image");
- entry->module=ConstantString("X");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("XBM");
+ entry=AcquireMagickInfo("XBM","XBM",
+ "X Windows system bitmap (black and white)");
entry->decoder=(DecodeImageHandler *) ReadXBMImage;
entry->encoder=(EncodeImageHandler *) WriteXBMImage;
entry->magick=(IsImageFormatHandler *) IsXBM;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(
- "X Windows system bitmap (black and white)");
- entry->module=ConstantString("XBM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("XC");
+ entry=AcquireMagickInfo("XC","XC","Constant image uniform color");
entry->decoder=(DecodeImageHandler *) ReadXCImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Constant image uniform color");
- entry->module=ConstantString("XC");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("CANVAS");
+ entry=AcquireMagickInfo("XC","CANVAS","Constant image uniform color");
entry->decoder=(DecodeImageHandler *) ReadXCImage;
entry->flags^=CoderAdjoinFlag;
entry->format_type=ImplicitFormatType;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Constant image uniform color");
- entry->module=ConstantString("XC");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("XCF");
+ entry=AcquireMagickInfo("XCF","XCF","GIMP image");
entry->decoder=(DecodeImageHandler *) ReadXCFImage;
entry->magick=(IsImageFormatHandler *) IsXCF;
- entry->description=ConstantString("GIMP image");
- entry->module=ConstantString("XCF");
entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
MagickInfo
*entry;
- entry=SetMagickInfo("PICON");
+ entry=AcquireMagickInfo("XPM","PICON","Personal Icon");
entry->decoder=(DecodeImageHandler *) ReadXPMImage;
entry->encoder=(EncodeImageHandler *) WritePICONImage;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("Personal Icon");
- entry->module=ConstantString("XPM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PM");
+ entry=AcquireMagickInfo("XPM","PM","X Windows system pixmap (color)");
entry->decoder=(DecodeImageHandler *) ReadXPMImage;
entry->encoder=(EncodeImageHandler *) WriteXPMImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("X Windows system pixmap (color)");
- entry->module=ConstantString("XPM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("XPM");
+ entry=AcquireMagickInfo("XPM","XPM","X Windows system pixmap (color)");
entry->decoder=(DecodeImageHandler *) ReadXPMImage;
entry->encoder=(EncodeImageHandler *) WriteXPMImage;
entry->magick=(IsImageFormatHandler *) IsXPM;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("X Windows system pixmap (color)");
- entry->module=ConstantString("XPM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("XPS");
+ entry=AcquireMagickInfo("XPS","XPS","Microsoft XML Paper Specification");
entry->decoder=(DecodeImageHandler *) ReadXPSImage;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags^=CoderDecoderThreadSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString("Microsoft XML Paper Specification");
- entry->module=ConstantString("XPS");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("XTRNFILE");
+ entry=AcquireMagickInfo("XTRN","XTRNFILE","External transfer of a file");
#if defined(_VISUALC_)
entry->decoder=ReadXTRNImage;
entry->encoder=WriteXTRNImage;
#endif
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("External transfer of a file");
- entry->module=ConstantString("XTRN");
RegisterMagickInfo(entry);
- entry=SetMagickInfo("XTRNIMAGE");
+ entry=AcquireMagickInfo("XTRN","XTRNIMAGE",
+ "External transfer of a image in memory");
#if defined(_VISUALC_)
entry->decoder=ReadXTRNImage;
entry->encoder=WriteXTRNImage;
#endif
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("External transfer of a image in memory");
- entry->module=ConstantString("XTRN");
RegisterMagickInfo(entry);
- entry=SetMagickInfo("XTRNBLOB");
+ entry=AcquireMagickInfo("XTRN","XTRNBLOB",
+ "IExternal transfer of a blob in memory");
#if defined(_VISUALC_)
entry->decoder=ReadXTRNImage;
entry->encoder=WriteXTRNImage;
#endif
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString("IExternal transfer of a blob in memory");
- entry->module=ConstantString("XTRN");
RegisterMagickInfo(entry);
- entry=SetMagickInfo("XTRNARRAY");
+ entry=AcquireMagickInfo("XTRN","XTRNARRAY",
+ "External transfer via a smart array interface");
#if defined(_VISUALC_)
entry->decoder=ReadXTRNImage;
entry->encoder=WriteXTRNImage;
#endif
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderStealthFlag;
- entry->description=ConstantString(
- "External transfer via a smart array interface");
- entry->module=ConstantString("XTRN");
RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("XWD");
+ entry=SetMagickInfo("XWD","XWD","X Windows system window dump (color)");
#if defined(MAGICKCORE_X11_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadXWDImage;
entry->encoder=(EncodeImageHandler *) WriteXWDImage;
#endif
entry->magick=(IsImageFormatHandler *) IsXWD;
entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString("X Windows system window dump (color)");
- entry->module=ConstantString("XWD");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("YCbCr");
+ entry=AcquireMagickInfo("YCbCr","YCbCr","Raw Y, Cb, and Cr samples");
entry->decoder=(DecodeImageHandler *) ReadYCBCRImage;
entry->encoder=(EncodeImageHandler *) WriteYCBCRImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw Y, Cb, and Cr samples");
- entry->module=ConstantString("YCbCr");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("YCbCrA");
+ entry=AcquireMagickInfo("YCbCr","YCbCrA","Raw Y, Cb, Cr, and alpha samples");
entry->decoder=(DecodeImageHandler *) ReadYCBCRImage;
entry->encoder=(EncodeImageHandler *) WriteYCBCRImage;
entry->flags|=CoderRawSupportFlag;
entry->flags|=CoderEndianSupportFlag;
- entry->description=ConstantString("Raw Y, Cb, Cr, and alpha samples");
- entry->module=ConstantString("YCbCr");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
MagickInfo
*entry;
- entry=SetMagickInfo("YUV");
+ entry=AcquireMagickInfo("YUV","YUV","CCIR 601 4:1:1 or 4:2:2");
entry->decoder=(DecodeImageHandler *) ReadYUVImage;
entry->encoder=(EncodeImageHandler *) WriteYUVImage;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderRawSupportFlag;
- entry->description=ConstantString("CCIR 601 4:1:1 or 4:2:2");
- entry->module=ConstantString("YUV");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}