Renamed SetMagickInfo to AcquireMagickInfo and made the module and description mandatory.
Changed RegisterMagickInfo to return a boolean instead of the supplied pointer.
diff --git a/Magick++/lib/Magick++/Include.h b/Magick++/lib/Magick++/Include.h
index b6bf88b..d78f8c2 100644
--- a/Magick++/lib/Magick++/Include.h
+++ b/Magick++/lib/Magick++/Include.h
@@ -1081,6 +1081,7 @@
using MagickCore::AcquireVirtualCacheView;
using MagickCore::AcquireImage;
using MagickCore::AcquireKernelInfo;
+ using MagickCore::AcquireMagickInfo;
using MagickCore::AcquireMagickMemory;
using MagickCore::AcquireQuantumInfo;
using MagickCore::AcquireString;
@@ -1395,7 +1396,6 @@
using MagickCore::SetImageRegistry;
using MagickCore::SetImageType;
using MagickCore::SetLogEventMask;
- using MagickCore::SetMagickInfo;
using MagickCore::SetMagickResourceLimit;
using MagickCore::SetImageVirtualPixelMethod;
using MagickCore::SetPixelChannel;
diff --git a/MagickCore/magick.c b/MagickCore/magick.c
index bc9a7f3..99fb285 100644
--- a/MagickCore/magick.c
+++ b/MagickCore/magick.c
@@ -136,6 +136,60 @@
% %
% %
% %
+% 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);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+ G e t I m a g e D e c o d e r %
% %
% %
@@ -953,13 +1007,7 @@
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)
@@ -1532,7 +1580,7 @@
% o magick_info: the magick info.
%
*/
-MagickExport MagickInfo *RegisterMagickInfo(MagickInfo *magick_info)
+MagickExport MagickBooleanType RegisterMagickInfo(MagickInfo *magick_info)
{
MagickBooleanType
status;
@@ -1544,60 +1592,12 @@
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);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-+ 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);
}
/*
diff --git a/MagickCore/magick.h b/MagickCore/magick.h
index 2c43a83..19dd614 100644
--- a/MagickCore/magick.h
+++ b/MagickCore/magick.h
@@ -122,6 +122,7 @@
GetMagickStealth(const MagickInfo *),
GetMagickUseExtension(const MagickInfo *),
IsMagickCoreInstantiated(void),
+ RegisterMagickInfo(MagickInfo *),
UnregisterMagickInfo(const char *);
extern const MagickExport MagickInfo
@@ -129,8 +130,7 @@
**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),
diff --git a/MagickCore/methods.h b/MagickCore/methods.h
index db38132..d64afd3 100644
--- a/MagickCore/methods.h
+++ b/MagickCore/methods.h
@@ -1092,7 +1092,7 @@
#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)
diff --git a/coders/aai.c b/coders/aai.c
index a069a63..2e00fb2 100644
--- a/coders/aai.c
+++ b/coders/aai.c
@@ -262,11 +262,9 @@
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);
}
diff --git a/coders/art.c b/coders/art.c
index c26778b..708c5fa 100644
--- a/coders/art.c
+++ b/coders/art.c
@@ -215,13 +215,11 @@
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);
}
diff --git a/coders/avs.c b/coders/avs.c
index 93a770e..a2466e6 100644
--- a/coders/avs.c
+++ b/coders/avs.c
@@ -259,11 +259,9 @@
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);
}
diff --git a/coders/bgr.c b/coders/bgr.c
index e64ba72..7ed112b 100644
--- a/coders/bgr.c
+++ b/coders/bgr.c
@@ -1021,29 +1021,25 @@
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);
}
diff --git a/coders/bmp.c b/coders/bmp.c
index 217863f..f555c14 100644
--- a/coders/bmp.c
+++ b/coders/bmp.c
@@ -1432,28 +1432,22 @@
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);
diff --git a/coders/braille.c b/coders/braille.c
index 9061f55..2ceabe1 100644
--- a/coders/braille.c
+++ b/coders/braille.c
@@ -96,23 +96,17 @@
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);
}
diff --git a/coders/cals.c b/coders/cals.c
index dde4871..550c960 100644
--- a/coders/cals.c
+++ b/coders/cals.c
@@ -309,40 +309,29 @@
*/
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);
}
diff --git a/coders/caption.c b/coders/caption.c
index 516829c..4be097d 100644
--- a/coders/caption.c
+++ b/coders/caption.c
@@ -325,11 +325,9 @@
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);
}
diff --git a/coders/cin.c b/coders/cin.c
index 805ce07..b2e094d 100644
--- a/coders/cin.c
+++ b/coders/cin.c
@@ -810,13 +810,11 @@
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);
}
diff --git a/coders/cip.c b/coders/cip.c
index d1369aa..0badf22 100644
--- a/coders/cip.c
+++ b/coders/cip.c
@@ -98,11 +98,9 @@
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);
}
diff --git a/coders/clip.c b/coders/clip.c
index c02589f..59a3705 100644
--- a/coders/clip.c
+++ b/coders/clip.c
@@ -154,11 +154,9 @@
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);
}
diff --git a/coders/clipboard.c b/coders/clipboard.c
index 516a601..1937001 100644
--- a/coders/clipboard.c
+++ b/coders/clipboard.c
@@ -268,15 +268,13 @@
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);
}
diff --git a/coders/cmyk.c b/coders/cmyk.c
index 6d05da5..ee4f063 100644
--- a/coders/cmyk.c
+++ b/coders/cmyk.c
@@ -1139,23 +1139,19 @@
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);
}
diff --git a/coders/cut.c b/coders/cut.c
index 85b0022..e7be764 100644
--- a/coders/cut.c
+++ b/coders/cut.c
@@ -639,11 +639,9 @@
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);
}
diff --git a/coders/dcm.c b/coders/dcm.c
index a6b67d0..fe65a80 100644
--- a/coders/dcm.c
+++ b/coders/dcm.c
@@ -4146,15 +4146,13 @@
"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);
}
diff --git a/coders/dds.c b/coders/dds.c
index f91f3cc..83e562e 100644
--- a/coders/dds.c
+++ b/coders/dds.c
@@ -2304,29 +2304,23 @@
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);
}
diff --git a/coders/debug.c b/coders/debug.c
index e51bd05..3c3bdb9 100644
--- a/coders/debug.c
+++ b/coders/debug.c
@@ -102,12 +102,10 @@
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);
}
diff --git a/coders/dib.c b/coders/dib.c
index b324f20..34ae5fd 100644
--- a/coders/dib.c
+++ b/coders/dib.c
@@ -931,15 +931,13 @@
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);
}
diff --git a/coders/djvu.c b/coders/djvu.c
index 0210570..e359ab3 100644
--- a/coders/djvu.c
+++ b/coders/djvu.c
@@ -946,15 +946,13 @@
(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);
diff --git a/coders/dng.c b/coders/dng.c
index 2ef1e55..8e8c41c 100644
--- a/coders/dng.c
+++ b/coders/dng.c
@@ -240,189 +240,144 @@
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");
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("DNG","ARW","Sony Alpha Raw Image Format");
+ entry->decoder=(DecodeImageHandler *) ReadDNGImage;
+ entry->flags^=CoderBlobSupportFlag;
+ entry->flags|=CoderSeekableStreamFlag;
+ entry->format_type=ExplicitFormatType;
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("DNG","DNG","Digital Negative");
+ entry->decoder=(DecodeImageHandler *) ReadDNGImage;
+ entry->flags^=CoderBlobSupportFlag;
+ entry->flags|=CoderSeekableStreamFlag;
+ entry->format_type=ExplicitFormatType;
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("DNG","CR2","Canon Digital Camera Raw Image Format");
+ entry->decoder=(DecodeImageHandler *) ReadDNGImage;
+ entry->flags^=CoderBlobSupportFlag;
+ entry->flags|=CoderSeekableStreamFlag;
+ entry->format_type=ExplicitFormatType;
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("DNG","CRW","Canon Digital Camera Raw Image Format");
+ entry->decoder=(DecodeImageHandler *) ReadDNGImage;
+ entry->flags^=CoderBlobSupportFlag;
+ entry->flags|=CoderSeekableStreamFlag;
+ entry->format_type=ExplicitFormatType;
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("DNG","DCR","Kodak Digital Camera Raw Image File");
+ entry->decoder=(DecodeImageHandler *) ReadDNGImage;
+ entry->flags^=CoderBlobSupportFlag;
+ entry->flags|=CoderSeekableStreamFlag;
+ entry->format_type=ExplicitFormatType;
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("DNG","ERF","Epson RAW Format");
+ entry->decoder=(DecodeImageHandler *) ReadDNGImage;
+ entry->flags^=CoderBlobSupportFlag;
+ entry->flags|=CoderSeekableStreamFlag;
+ entry->format_type=ExplicitFormatType;
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("DNG","IIQ","Phase One Raw Image Format");
+ entry->decoder=(DecodeImageHandler *) ReadDNGImage;
+ entry->flags^=CoderBlobSupportFlag;
+ entry->flags|=CoderSeekableStreamFlag;
+ entry->format_type=ExplicitFormatType;
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ARW");
+ 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("Sony Alpha Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("DNG");
+ 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("Digital Negative");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("CR2");
+ 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("Canon Digital Camera Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("CRW");
+ 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("Canon Digital Camera Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("DCR");
+ 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("Kodak Digital Camera Raw Image File");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("ERF");
+ 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("Epson RAW Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("IIQ");
+ 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("Phase One Raw Image Format");
- entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("KDC");
+ entry=AcquireMagickInfo("DNG","PEF","Pentax Electronic File");
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","RAF","Fuji CCD-RAW Graphic File");
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","RAW","Raw");
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","RMF","Raw Media Format");
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","RW2","Panasonic Lumix Raw Image");
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","SRF","Sony Raw Format");
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","SR2","Sony Raw Format 2");
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","X3F","Sigma Camera RAW Picture 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->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->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->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->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->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->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->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);
}
diff --git a/coders/dot.c b/coders/dot.c
index 27bae00..30be265 100644
--- a/coders/dot.c
+++ b/coders/dot.c
@@ -193,21 +193,17 @@
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();
diff --git a/coders/dps.c b/coders/dps.c
index 115de62..9ddfa21 100644
--- a/coders/dps.c
+++ b/coders/dps.c
@@ -543,13 +543,11 @@
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);
}
diff --git a/coders/dpx.c b/coders/dpx.c
index c1b1d34..218bfd9 100644
--- a/coders/dpx.c
+++ b/coders/dpx.c
@@ -1334,15 +1334,13 @@
"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);
}
diff --git a/coders/emf.c b/coders/emf.c
index 9808890..a5044a3 100644
--- a/coders/emf.c
+++ b/coders/emf.c
@@ -810,24 +810,19 @@
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);
}
diff --git a/coders/ept.c b/coders/ept.c
index 5a99c46..9bf8c44 100644
--- a/coders/ept.c
+++ b/coders/ept.c
@@ -279,37 +279,31 @@
MagickInfo
*entry;
- entry=SetMagickInfo("EPT");
- entry->decoder=(DecodeImageHandler *) ReadEPTImage;
- entry->encoder=(EncodeImageHandler *) WriteEPTImage;
- entry->magick=(IsImageFormatHandler *) IsEPT;
- entry->flags|=CoderSeekableStreamFlag;
- entry->flags^=CoderAdjoinFlag;
- entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString(
+ entry=AcquireMagickInfo("EPT","EPT",
"Encapsulated PostScript with TIFF preview");
- entry->module=ConstantString("EPT");
+ entry->decoder=(DecodeImageHandler *) ReadEPTImage;
+ entry->encoder=(EncodeImageHandler *) WriteEPTImage;
+ entry->magick=(IsImageFormatHandler *) IsEPT;
+ entry->flags|=CoderSeekableStreamFlag;
+ entry->flags^=CoderAdjoinFlag;
+ entry->flags^=CoderBlobSupportFlag;
(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);
}
diff --git a/coders/exr.c b/coders/exr.c
index d4af8e1..085ed6b 100644
--- a/coders/exr.c
+++ b/coders/exr.c
@@ -287,16 +287,14 @@
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);
}
diff --git a/coders/fax.c b/coders/fax.c
index 142b72e..9700cfe 100644
--- a/coders/fax.c
+++ b/coders/fax.c
@@ -228,21 +228,17 @@
"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);
}
diff --git a/coders/fd.c b/coders/fd.c
index bd8c49f..7e2d4cd 100644
--- a/coders/fd.c
+++ b/coders/fd.c
@@ -154,10 +154,8 @@
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);
diff --git a/coders/fits.c b/coders/fits.c
index 254cb51..817e9c9 100644
--- a/coders/fits.c
+++ b/coders/fits.c
@@ -537,23 +537,19 @@
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);
}
diff --git a/coders/fpx.c b/coders/fpx.c
index 2db31f2..0526b9c 100644
--- a/coders/fpx.c
+++ b/coders/fpx.c
@@ -492,7 +492,7 @@
MagickInfo
*entry;
- entry=SetMagickInfo("FPX");
+ entry=AcquireMagickInfo("FPX","FPX","FlashPix Format");
#if defined(MAGICKCORE_FPX_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadFPXImage;
entry->encoder=(EncodeImageHandler *) WriteFPXImage;
@@ -500,8 +500,6 @@
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderBlobSupportFlag;
- entry->description=ConstantString("FlashPix Format");
- entry->module=ConstantString("FPX");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
diff --git a/coders/gif.c b/coders/gif.c
index 0a6307b..9af80a7 100644
--- a/coders/gif.c
+++ b/coders/gif.c
@@ -1399,23 +1399,21 @@
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);
}
diff --git a/coders/gradient.c b/coders/gradient.c
index 7a3f0f3..3ea5bd1 100644
--- a/coders/gradient.c
+++ b/coders/gradient.c
@@ -203,23 +203,19 @@
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);
}
diff --git a/coders/gray.c b/coders/gray.c
index 0af76d0..2529eec 100644
--- a/coders/gray.c
+++ b/coders/gray.c
@@ -311,13 +311,11 @@
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);
}
diff --git a/coders/hald.c b/coders/hald.c
index 1de3e97..3ff438e 100644
--- a/coders/hald.c
+++ b/coders/hald.c
@@ -194,14 +194,13 @@
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);
}
diff --git a/coders/hdr.c b/coders/hdr.c
index 73bf70e..4cc2f1c 100644
--- a/coders/hdr.c
+++ b/coders/hdr.c
@@ -533,11 +533,9 @@
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);
diff --git a/coders/histogram.c b/coders/histogram.c
index 6610ad5..b693787 100644
--- a/coders/histogram.c
+++ b/coders/histogram.c
@@ -102,12 +102,10 @@
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);
}
diff --git a/coders/hrz.c b/coders/hrz.c
index 41d1a76..26fc655 100644
--- a/coders/hrz.c
+++ b/coders/hrz.c
@@ -207,12 +207,10 @@
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);
}
diff --git a/coders/html.c b/coders/html.c
index 33beb89..ea71c44 100644
--- a/coders/html.c
+++ b/coders/html.c
@@ -129,29 +129,23 @@
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);
}
diff --git a/coders/icon.c b/coders/icon.c
index c8d6d6e..0f3d00d 100644
--- a/coders/icon.c
+++ b/coders/icon.c
@@ -767,28 +767,22 @@
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);
}
diff --git a/coders/info.c b/coders/info.c
index d12c269..bb3b3f2 100644
--- a/coders/info.c
+++ b/coders/info.c
@@ -96,11 +96,10 @@
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);
}
diff --git a/coders/inline.c b/coders/inline.c
index 11d5ad5..7df6801 100644
--- a/coders/inline.c
+++ b/coders/inline.c
@@ -196,12 +196,10 @@
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);
}
diff --git a/coders/ipl.c b/coders/ipl.c
index 6dda266..827d9e1 100644
--- a/coders/ipl.c
+++ b/coders/ipl.c
@@ -439,13 +439,11 @@
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);
}
diff --git a/coders/jbig.c b/coders/jbig.c
index eb18d4d..e44ae5e 100644
--- a/coders/jbig.c
+++ b/coders/jbig.c
@@ -306,36 +306,30 @@
#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);
}
diff --git a/coders/jnx.c b/coders/jnx.c
index 841861f..a64bc13 100644
--- a/coders/jnx.c
+++ b/coders/jnx.c
@@ -356,11 +356,9 @@
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);
}
diff --git a/coders/jp2.c b/coders/jp2.c
index 412547c..ffd5d12 100644
--- a/coders/jp2.c
+++ b/coders/jp2.c
@@ -542,12 +542,10 @@
#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;
@@ -556,12 +554,10 @@
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;
@@ -570,12 +566,10 @@
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;
@@ -584,12 +578,10 @@
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;
@@ -598,12 +590,10 @@
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;
@@ -612,12 +602,10 @@
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;
diff --git a/coders/jpeg.c b/coders/jpeg.c
index ea86abd..cab17ad 100644
--- a/coders/jpeg.c
+++ b/coders/jpeg.c
@@ -1513,20 +1513,19 @@
*/
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
@@ -1537,13 +1536,11 @@
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
@@ -1553,13 +1550,11 @@
#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
@@ -1569,13 +1564,11 @@
#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
@@ -1585,13 +1578,11 @@
#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
@@ -1601,11 +1592,9 @@
#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);
}
diff --git a/coders/json.c b/coders/json.c
index 37b919d..0b8db16 100644
--- a/coders/json.c
+++ b/coders/json.c
@@ -109,11 +109,10 @@
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);
}
diff --git a/coders/label.c b/coders/label.c
index 9d4fb69..78f4fe8 100644
--- a/coders/label.c
+++ b/coders/label.c
@@ -279,12 +279,10 @@
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);
}
diff --git a/coders/mac.c b/coders/mac.c
index df20cf5..043a47f 100644
--- a/coders/mac.c
+++ b/coders/mac.c
@@ -274,10 +274,8 @@
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);
}
diff --git a/coders/magick.c b/coders/magick.c
index e3e8fe6..b7b6b64 100644
--- a/coders/magick.c
+++ b/coders/magick.c
@@ -13099,61 +13099,47 @@
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);
}
diff --git a/coders/map.c b/coders/map.c
index cac5692..d1809e8 100644
--- a/coders/map.c
+++ b/coders/map.c
@@ -272,15 +272,13 @@
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);
}
diff --git a/coders/mask.c b/coders/mask.c
index fafe681..0363007 100644
--- a/coders/mask.c
+++ b/coders/mask.c
@@ -153,11 +153,9 @@
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);
}
diff --git a/coders/mat.c b/coders/mat.c
index 913c827..6f729bd 100644
--- a/coders/mat.c
+++ b/coders/mat.c
@@ -1110,13 +1110,11 @@
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);
}
diff --git a/coders/matte.c b/coders/matte.c
index 9a0a498..1894dcf 100644
--- a/coders/matte.c
+++ b/coders/matte.c
@@ -93,11 +93,9 @@
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);
}
diff --git a/coders/meta.c b/coders/meta.c
index c5634ee..b60564d 100644
--- a/coders/meta.c
+++ b/coders/meta.c
@@ -1391,113 +1391,90 @@
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);
}
diff --git a/coders/miff.c b/coders/miff.c
index 3020aee..2840f11 100644
--- a/coders/miff.c
+++ b/coders/miff.c
@@ -1664,15 +1664,13 @@
(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);
}
diff --git a/coders/mono.c b/coders/mono.c
index 919ae4d..74ee20b 100644
--- a/coders/mono.c
+++ b/coders/mono.c
@@ -221,14 +221,12 @@
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);
}
diff --git a/coders/mpc.c b/coders/mpc.c
index 733da24..f555c6a 100644
--- a/coders/mpc.c
+++ b/coders/mpc.c
@@ -989,17 +989,15 @@
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);
}
diff --git a/coders/mpeg.c b/coders/mpeg.c
index f38fe2d..0b73601 100644
--- a/coders/mpeg.c
+++ b/coders/mpeg.c
@@ -240,76 +240,58 @@
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);
}
diff --git a/coders/mpr.c b/coders/mpr.c
index 9281dca..f6ec3e1 100644
--- a/coders/mpr.c
+++ b/coders/mpr.c
@@ -132,23 +132,19 @@
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);
}
diff --git a/coders/msl.c b/coders/msl.c
index 5606f46..871c77f 100644
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -7870,13 +7870,11 @@
#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);
}
diff --git a/coders/mtv.c b/coders/mtv.c
index 3778de3..0e925b6 100644
--- a/coders/mtv.c
+++ b/coders/mtv.c
@@ -261,11 +261,9 @@
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);
}
diff --git a/coders/mvg.c b/coders/mvg.c
index facf49d..3ae33fd 100644
--- a/coders/mvg.c
+++ b/coders/mvg.c
@@ -246,14 +246,12 @@
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);
}
diff --git a/coders/null.c b/coders/null.c
index 69c218e..0f271c9 100644
--- a/coders/null.c
+++ b/coders/null.c
@@ -179,13 +179,11 @@
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);
}
diff --git a/coders/otb.c b/coders/otb.c
index 408bfe5..ede66cb 100644
--- a/coders/otb.c
+++ b/coders/otb.c
@@ -238,12 +238,10 @@
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);
}
diff --git a/coders/palm.c b/coders/palm.c
index 9b951b2..e785f87 100644
--- a/coders/palm.c
+++ b/coders/palm.c
@@ -604,12 +604,10 @@
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);
}
diff --git a/coders/pango.c b/coders/pango.c
index 4314c7f..1ba0e08 100644
--- a/coders/pango.c
+++ b/coders/pango.c
@@ -500,15 +500,13 @@
(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);
}
diff --git a/coders/pattern.c b/coders/pattern.c
index d9426da..cad1be4 100644
--- a/coders/pattern.c
+++ b/coders/pattern.c
@@ -1023,11 +1023,9 @@
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);
}
diff --git a/coders/pcd.c b/coders/pcd.c
index fe34c7a..298b426 100644
--- a/coders/pcd.c
+++ b/coders/pcd.c
@@ -869,22 +869,18 @@
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);
}
diff --git a/coders/pcl.c b/coders/pcl.c
index 07bfe80..d978a4b 100644
--- a/coders/pcl.c
+++ b/coders/pcl.c
@@ -421,15 +421,13 @@
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);
}
diff --git a/coders/pcx.c b/coders/pcx.c
index 8505d50..76a8137 100644
--- a/coders/pcx.c
+++ b/coders/pcx.c
@@ -707,22 +707,18 @@
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);
}
diff --git a/coders/pdb.c b/coders/pdb.c
index cafb542..d1dfaa4 100644
--- a/coders/pdb.c
+++ b/coders/pdb.c
@@ -624,12 +624,10 @@
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);
}
diff --git a/coders/pdf.c b/coders/pdf.c
index 5a0dae0..e94bc32 100644
--- a/coders/pdf.c
+++ b/coders/pdf.c
@@ -866,45 +866,38 @@
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);
}
diff --git a/coders/pes.c b/coders/pes.c
index cfce5c9..38cea7c 100644
--- a/coders/pes.c
+++ b/coders/pes.c
@@ -697,11 +697,9 @@
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);
}
diff --git a/coders/pict.c b/coders/pict.c
index 0a221e2..bf7f0cd 100644
--- a/coders/pict.c
+++ b/coders/pict.c
@@ -1520,23 +1520,19 @@
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);
}
diff --git a/coders/pix.c b/coders/pix.c
index 62085bf..0673c6c 100644
--- a/coders/pix.c
+++ b/coders/pix.c
@@ -275,10 +275,8 @@
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);
}
diff --git a/coders/plasma.c b/coders/plasma.c
index cd8b906..77a8e02 100644
--- a/coders/plasma.c
+++ b/coders/plasma.c
@@ -239,19 +239,15 @@
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);
}
diff --git a/coders/png.c b/coders/png.c
index 701f915..6dd3a12 100644
--- a/coders/png.c
+++ b/coders/png.c
@@ -7378,7 +7378,7 @@
}
#endif
- entry=SetMagickInfo("MNG");
+ entry=AcquireMagickInfo("PNG","MNG","Multiple-image Network Graphics");
entry->flags|=CoderSeekableStreamFlag; /* To do: eliminate this. */
#if defined(MAGICKCORE_PNG_DELEGATE)
@@ -7387,17 +7387,15 @@
#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;
@@ -7406,9 +7404,7 @@
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);
@@ -7416,7 +7412,8 @@
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;
@@ -7425,13 +7422,11 @@
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)
@@ -7455,12 +7450,10 @@
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;
@@ -7469,12 +7462,11 @@
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;
@@ -7483,12 +7475,10 @@
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;
@@ -7497,27 +7487,23 @@
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");
-
-#if defined(MAGICKCORE_PNG_DELEGATE)
- entry->decoder=(DecodeImageHandler *) ReadPNGImage;
- entry->encoder=(EncodeImageHandler *) WritePNGImage;
-#endif
-
- entry->magick=(IsImageFormatHandler *) IsPNG;
- entry->flags^=CoderAdjoinFlag;
- entry->description=ConstantString(
+ entry=AcquireMagickInfo("PNG","PNG00",
"PNG inheriting bit-depth and color-type from original");
+
+#if defined(MAGICKCORE_PNG_DELEGATE)
+ entry->decoder=(DecodeImageHandler *) ReadPNGImage;
+ entry->encoder=(EncodeImageHandler *) WritePNGImage;
+#endif
+
+ entry->magick=(IsImageFormatHandler *) IsPNG;
+ entry->flags^=CoderAdjoinFlag;
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)
@@ -7528,9 +7514,7 @@
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);
diff --git a/coders/pnm.c b/coders/pnm.c
index 6a2a6f1..d31bd47 100644
--- a/coders/pnm.c
+++ b/coders/pnm.c
@@ -1409,48 +1409,37 @@
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);
}
diff --git a/coders/preview.c b/coders/preview.c
index 02ff75f..c9b6542 100644
--- a/coders/preview.c
+++ b/coders/preview.c
@@ -98,13 +98,11 @@
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);
}
diff --git a/coders/ps.c b/coders/ps.c
index 0e605e7..0fb50bf 100644
--- a/coders/ps.c
+++ b/coders/ps.c
@@ -1034,61 +1034,51 @@
MagickInfo
*entry;
- entry=SetMagickInfo("EPI");
- entry->decoder=(DecodeImageHandler *) ReadPSImage;
- entry->encoder=(EncodeImageHandler *) WritePSImage;
- entry->magick=(IsImageFormatHandler *) IsPS;
- entry->flags^=CoderAdjoinFlag;
- entry->flags^=CoderBlobSupportFlag;
- entry->flags|=CoderSeekableStreamFlag;
- entry->description=ConstantString(
+ entry=AcquireMagickInfo("PS","EPI",
"Encapsulated PostScript Interchange format");
- entry->mime_type=ConstantString("application/postscript");
- entry->module=ConstantString("PS");
- (void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("EPS");
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","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("EPSI");
+ 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(
+ entry->mime_type=ConstantString("application/postscript");
+ (void) RegisterMagickInfo(entry);
+ 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->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);
}
diff --git a/coders/ps2.c b/coders/ps2.c
index 908e321..cbbde50 100644
--- a/coders/ps2.c
+++ b/coders/ps2.c
@@ -113,20 +113,16 @@
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);
}
diff --git a/coders/ps3.c b/coders/ps3.c
index 58c81ae..cb11b4c 100644
--- a/coders/ps3.c
+++ b/coders/ps3.c
@@ -129,18 +129,14 @@
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);
diff --git a/coders/psd.c b/coders/psd.c
index 1085990..53f6c9e 100644
--- a/coders/psd.c
+++ b/coders/psd.c
@@ -1880,21 +1880,17 @@
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);
}
diff --git a/coders/pwp.c b/coders/pwp.c
index 357687d..23d1851 100644
--- a/coders/pwp.c
+++ b/coders/pwp.c
@@ -291,11 +291,9 @@
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);
}
diff --git a/coders/raw.c b/coders/raw.c
index 52f0562..fddac83 100644
--- a/coders/raw.c
+++ b/coders/raw.c
@@ -305,77 +305,59 @@
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);
}
diff --git a/coders/rgb.c b/coders/rgb.c
index f9e3e65..67ecdc0 100644
--- a/coders/rgb.c
+++ b/coders/rgb.c
@@ -1012,29 +1012,26 @@
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);
}
diff --git a/coders/rgf.c b/coders/rgf.c
index cdbd3d8..5a6131c 100644
--- a/coders/rgf.c
+++ b/coders/rgf.c
@@ -247,13 +247,11 @@
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);
}
diff --git a/coders/rla.c b/coders/rla.c
index a1abc19..c80ff7a 100644
--- a/coders/rla.c
+++ b/coders/rla.c
@@ -423,12 +423,10 @@
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);
}
diff --git a/coders/rle.c b/coders/rle.c
index f4ed8a6..3d7bb90 100644
--- a/coders/rle.c
+++ b/coders/rle.c
@@ -683,12 +683,10 @@
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);
}
diff --git a/coders/scr.c b/coders/scr.c
index 32743da..9b73ecf 100644
--- a/coders/scr.c
+++ b/coders/scr.c
@@ -274,11 +274,9 @@
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);
}
diff --git a/coders/screenshot.c b/coders/screenshot.c
index a2d9afc..e821f1a 100644
--- a/coders/screenshot.c
+++ b/coders/screenshot.c
@@ -277,11 +277,9 @@
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);
}
diff --git a/coders/sct.c b/coders/sct.c
index 11a16df..6937077 100644
--- a/coders/sct.c
+++ b/coders/sct.c
@@ -312,12 +312,10 @@
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);
}
diff --git a/coders/sfw.c b/coders/sfw.c
index dbc8bff..ff7e8e2 100644
--- a/coders/sfw.c
+++ b/coders/sfw.c
@@ -398,12 +398,10 @@
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);
}
diff --git a/coders/sgi.c b/coders/sgi.c
index 0be78b1..627f752 100644
--- a/coders/sgi.c
+++ b/coders/sgi.c
@@ -743,12 +743,10 @@
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);
diff --git a/coders/sixel.c b/coders/sixel.c
index bfab580..fcd5221 100644
--- a/coders/sixel.c
+++ b/coders/sixel.c
@@ -1105,21 +1105,17 @@
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);
}
diff --git a/coders/stegano.c b/coders/stegano.c
index 26c2aff..06c0e95 100644
--- a/coders/stegano.c
+++ b/coders/stegano.c
@@ -250,11 +250,9 @@
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);
}
diff --git a/coders/sun.c b/coders/sun.c
index 8d605da..91b59bc 100644
--- a/coders/sun.c
+++ b/coders/sun.c
@@ -634,18 +634,14 @@
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);
}
diff --git a/coders/svg.c b/coders/svg.c
index 05f87f3..7db99cb 100644
--- a/coders/svg.c
+++ b/coders/svg.c
@@ -3242,41 +3242,36 @@
(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);
}
diff --git a/coders/tga.c b/coders/tga.c
index b09638d..96c59ed 100644
--- a/coders/tga.c
+++ b/coders/tga.c
@@ -570,33 +570,25 @@
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);
}
diff --git a/coders/thumbnail.c b/coders/thumbnail.c
index 90eba4b..d54a675 100644
--- a/coders/thumbnail.c
+++ b/coders/thumbnail.c
@@ -92,10 +92,8 @@
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);
}
diff --git a/coders/tiff.c b/coders/tiff.c
index d502f56..a85eebe 100644
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -2152,7 +2152,7 @@
}
#endif
- entry=SetMagickInfo("GROUP4");
+ entry=AcquireMagickInfo("TIFF","GROUP4","Raw CCITT Group4");
#if defined(MAGICKCORE_TIFF_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadGROUP4Image;
entry->encoder=(EncodeImageHandler *) WriteGROUP4Image;
@@ -2163,11 +2163,9 @@
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;
@@ -2175,11 +2173,9 @@
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;
@@ -2188,13 +2184,11 @@
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;
@@ -2203,13 +2197,11 @@
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;
@@ -2218,11 +2210,9 @@
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);
}
diff --git a/coders/tile.c b/coders/tile.c
index ad0d65b..03924e4 100644
--- a/coders/tile.c
+++ b/coders/tile.c
@@ -167,13 +167,11 @@
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);
}
diff --git a/coders/tim.c b/coders/tim.c
index 4f26bc2..1b51871 100644
--- a/coders/tim.c
+++ b/coders/tim.c
@@ -448,10 +448,8 @@
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);
}
diff --git a/coders/ttf.c b/coders/ttf.c
index 4a1f6ea..559f6be 100644
--- a/coders/ttf.c
+++ b/coders/ttf.c
@@ -328,71 +328,59 @@
(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);
}
diff --git a/coders/txt.c b/coders/txt.c
index 6a6c6c8..fa321a0 100644
--- a/coders/txt.c
+++ b/coders/txt.c
@@ -596,27 +596,21 @@
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);
}
diff --git a/coders/uil.c b/coders/uil.c
index 555b531..ad42fdf 100644
--- a/coders/uil.c
+++ b/coders/uil.c
@@ -96,11 +96,9 @@
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);
}
diff --git a/coders/url.c b/coders/url.c
index 10b554d..b8b241e 100644
--- a/coders/url.c
+++ b/coders/url.c
@@ -293,39 +293,31 @@
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);
diff --git a/coders/uyvy.c b/coders/uyvy.c
index 08b3660..b31eb44 100644
--- a/coders/uyvy.c
+++ b/coders/uyvy.c
@@ -214,23 +214,19 @@
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);
}
diff --git a/coders/vicar.c b/coders/vicar.c
index a70b0c6..876a42c 100644
--- a/coders/vicar.c
+++ b/coders/vicar.c
@@ -355,13 +355,11 @@
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);
}
diff --git a/coders/vid.c b/coders/vid.c
index a417273..68ee524 100644
--- a/coders/vid.c
+++ b/coders/vid.c
@@ -243,12 +243,10 @@
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);
}
diff --git a/coders/viff.c b/coders/viff.c
index f950bde..3a4a8a8 100644
--- a/coders/viff.c
+++ b/coders/viff.c
@@ -783,18 +783,14 @@
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);
}
diff --git a/coders/vips.c b/coders/vips.c
index 39d4dda..4267fa1 100644
--- a/coders/vips.c
+++ b/coders/vips.c
@@ -545,13 +545,11 @@
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);
}
diff --git a/coders/wbmp.c b/coders/wbmp.c
index c9b7fc9..c76132f 100644
--- a/coders/wbmp.c
+++ b/coders/wbmp.c
@@ -252,12 +252,10 @@
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);
}
diff --git a/coders/webp.c b/coders/webp.c
index d9b6522..372b109 100644
--- a/coders/webp.c
+++ b/coders/webp.c
@@ -401,7 +401,7 @@
*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;
@@ -410,10 +410,8 @@
(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);
diff --git a/coders/wmf.c b/coders/wmf.c
index 3df5101..a0ad8aa 100644
--- a/coders/wmf.c
+++ b/coders/wmf.c
@@ -2948,20 +2948,16 @@
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);
}
diff --git a/coders/wpg.c b/coders/wpg.c
index b563288..ef961f0 100644
--- a/coders/wpg.c
+++ b/coders/wpg.c
@@ -1492,11 +1492,9 @@
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);
diff --git a/coders/x.c b/coders/x.c
index 279da1e..ab7fa98 100644
--- a/coders/x.c
+++ b/coders/x.c
@@ -135,14 +135,12 @@
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);
}
diff --git a/coders/xbm.c b/coders/xbm.c
index 3b3b314..c3c0800 100644
--- a/coders/xbm.c
+++ b/coders/xbm.c
@@ -418,14 +418,12 @@
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);
}
diff --git a/coders/xc.c b/coders/xc.c
index f5d84d7..ff84567 100644
--- a/coders/xc.c
+++ b/coders/xc.c
@@ -186,23 +186,19 @@
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);
}
diff --git a/coders/xcf.c b/coders/xcf.c
index 5ec3d72..3e3a331 100644
--- a/coders/xcf.c
+++ b/coders/xcf.c
@@ -1447,11 +1447,9 @@
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);
diff --git a/coders/xpm.c b/coders/xpm.c
index 6d8229e..8c3bb1c 100644
--- a/coders/xpm.c
+++ b/coders/xpm.c
@@ -497,28 +497,22 @@
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);
}
diff --git a/coders/xps.c b/coders/xps.c
index 9a9752b..af6e893 100644
--- a/coders/xps.c
+++ b/coders/xps.c
@@ -374,14 +374,12 @@
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);
}
diff --git a/coders/xtrn.c b/coders/xtrn.c
index cf42ce3..5479825 100644
--- a/coders/xtrn.c
+++ b/coders/xtrn.c
@@ -256,46 +256,40 @@
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");
-#if defined(_VISUALC_)
- entry->decoder=ReadXTRNImage;
- entry->encoder=WriteXTRNImage;
-#endif
- entry->flags^=CoderAdjoinFlag;
- entry->flags|=CoderStealthFlag;
- entry->description=ConstantString(
+ entry=AcquireMagickInfo("XTRN","XTRNARRAY",
"External transfer via a smart array interface");
- entry->module=ConstantString("XTRN");
+#if defined(_VISUALC_)
+ entry->decoder=ReadXTRNImage;
+ entry->encoder=WriteXTRNImage;
+#endif
+ entry->flags^=CoderAdjoinFlag;
+ entry->flags|=CoderStealthFlag;
RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
diff --git a/coders/xwd.c b/coders/xwd.c
index dba43a1..d419932 100644
--- a/coders/xwd.c
+++ b/coders/xwd.c
@@ -598,15 +598,13 @@
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);
}
diff --git a/coders/ycbcr.c b/coders/ycbcr.c
index 152f21f..cf2f2eb 100644
--- a/coders/ycbcr.c
+++ b/coders/ycbcr.c
@@ -923,21 +923,17 @@
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);
}
diff --git a/coders/yuv.c b/coders/yuv.c
index 317e5a7..f92d6d6 100644
--- a/coders/yuv.c
+++ b/coders/yuv.c
@@ -492,13 +492,11 @@
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);
}
