]> granicus.if.org Git - imagemagick/commitdiff
Renamed SetMagickInfo to AcquireMagickInfo and made the module and description mandatory.
authordirk <dirk@git.imagemagick.org>
Mon, 6 Apr 2015 18:59:17 +0000 (18:59 +0000)
committerdirk <dirk@git.imagemagick.org>
Mon, 6 Apr 2015 18:59:17 +0000 (18:59 +0000)
Changed RegisterMagickInfo to return a boolean instead of the supplied pointer.

131 files changed:
Magick++/lib/Magick++/Include.h
MagickCore/magick.c
MagickCore/magick.h
MagickCore/methods.h
coders/aai.c
coders/art.c
coders/avs.c
coders/bgr.c
coders/bmp.c
coders/braille.c
coders/cals.c
coders/caption.c
coders/cin.c
coders/cip.c
coders/clip.c
coders/clipboard.c
coders/cmyk.c
coders/cut.c
coders/dcm.c
coders/dds.c
coders/debug.c
coders/dib.c
coders/djvu.c
coders/dng.c
coders/dot.c
coders/dps.c
coders/dpx.c
coders/emf.c
coders/ept.c
coders/exr.c
coders/fax.c
coders/fd.c
coders/fits.c
coders/fpx.c
coders/gif.c
coders/gradient.c
coders/gray.c
coders/hald.c
coders/hdr.c
coders/histogram.c
coders/hrz.c
coders/html.c
coders/icon.c
coders/info.c
coders/inline.c
coders/ipl.c
coders/jbig.c
coders/jnx.c
coders/jp2.c
coders/jpeg.c
coders/json.c
coders/label.c
coders/mac.c
coders/magick.c
coders/map.c
coders/mask.c
coders/mat.c
coders/matte.c
coders/meta.c
coders/miff.c
coders/mono.c
coders/mpc.c
coders/mpeg.c
coders/mpr.c
coders/msl.c
coders/mtv.c
coders/mvg.c
coders/null.c
coders/otb.c
coders/palm.c
coders/pango.c
coders/pattern.c
coders/pcd.c
coders/pcl.c
coders/pcx.c
coders/pdb.c
coders/pdf.c
coders/pes.c
coders/pict.c
coders/pix.c
coders/plasma.c
coders/png.c
coders/pnm.c
coders/preview.c
coders/ps.c
coders/ps2.c
coders/ps3.c
coders/psd.c
coders/pwp.c
coders/raw.c
coders/rgb.c
coders/rgf.c
coders/rla.c
coders/rle.c
coders/scr.c
coders/screenshot.c
coders/sct.c
coders/sfw.c
coders/sgi.c
coders/sixel.c
coders/stegano.c
coders/sun.c
coders/svg.c
coders/tga.c
coders/thumbnail.c
coders/tiff.c
coders/tile.c
coders/tim.c
coders/ttf.c
coders/txt.c
coders/uil.c
coders/url.c
coders/uyvy.c
coders/vicar.c
coders/vid.c
coders/viff.c
coders/vips.c
coders/wbmp.c
coders/webp.c
coders/wmf.c
coders/wpg.c
coders/x.c
coders/xbm.c
coders/xc.c
coders/xcf.c
coders/xpm.c
coders/xps.c
coders/xtrn.c
coders/xwd.c
coders/ycbcr.c
coders/yuv.c

index b6bf88b2bd5ccd69cf07f806814a27c8f67a308d..d78f8c2b0009f3e95febb5b6ebe64207418e2eae 100644 (file)
@@ -1081,6 +1081,7 @@ namespace Magick
   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 @@ namespace Magick
   using MagickCore::SetImageRegistry;
   using MagickCore::SetImageType;
   using MagickCore::SetLogEventMask;
-  using MagickCore::SetMagickInfo;
   using MagickCore::SetMagickResourceLimit;
   using MagickCore::SetImageVirtualPixelMethod;
   using MagickCore::SetPixelChannel;
index bc9a7f35db353f39fe3f67160b4c40947fb095e2..99fb285758ca55a0af1d7c2b05a1aef79e535435 100644 (file)
@@ -136,6 +136,60 @@ static MagickBooleanType
 %                                                                             %
 %                                                                             %
 %                                                                             %
+%    A c q u i r e M a g i c k I n f o                                        %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  AcquireMagickInfo() allocates a MagickInfo structure and initializes the
+%  members to default values.
+%
+%  The format of the AcquireMagickInfo method is:
+%
+%      MagickInfo *AcquireMagickInfo(const char *module, const char *name,)
+%
+%  A description of each parameter follows:
+%
+%    o module: a character string that represents the module associated
+%      with the MagickInfo structure.
+%
+%    o name: a character string that represents the image format associated
+%      with the MagickInfo structure.
+%
+%    o description: a character string that represents the image format
+%      associated with the MagickInfo structure.
+%
+*/
+MagickExport MagickInfo *AcquireMagickInfo(const char *module,
+  const char *name, const char *description)
+{
+  MagickInfo
+    *magick_info;
+
+  assert(module != (const char *) NULL);
+  assert(name != (const char *) NULL);
+  assert(description != (const char *) NULL);
+  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
+  magick_info=(MagickInfo *) AcquireMagickMemory(sizeof(*magick_info));
+  if (magick_info == (MagickInfo *) NULL)
+    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+  (void) ResetMagickMemory(magick_info,0,sizeof(*magick_info));
+  magick_info->module=ConstantString(module);
+  magick_info->name=ConstantString(name);
+  magick_info->description=ConstantString(description);
+  magick_info->flags=CoderAdjoinFlag | CoderBlobSupportFlag |
+    CoderDecoderThreadSupportFlag | CoderEncoderThreadSupportFlag |
+    CoderUseExtensionFlag;
+  magick_info->signature=MagickSignature;
+  return(magick_info);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
 +   G e t I m a g e D e c o d e r                                             %
 %                                                                             %
 %                                                                             %
@@ -953,13 +1007,7 @@ static MagickBooleanType IsMagickTreeInstantiated(ExceptionInfo *exception)
           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 @@ MagickExport void MagickCoreTerminus(void)
 %    o magick_info: the magick info.
 %
 */
-MagickExport MagickInfo *RegisterMagickInfo(MagickInfo *magick_info)
+MagickExport MagickBooleanType RegisterMagickInfo(MagickInfo *magick_info)
 {
   MagickBooleanType
     status;
@@ -1544,60 +1592,12 @@ MagickExport MagickInfo *RegisterMagickInfo(MagickInfo *magick_info)
   assert(magick_info->signature == MagickSignature);
   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",magick_info->name);
   if (magick_list == (SplayTreeInfo *) NULL)
-    return((MagickInfo *) NULL);
+    return(MagickFalse);
   if ((GetMagickDecoderThreadSupport(magick_info) == MagickFalse) ||
       (GetMagickEncoderThreadSupport(magick_info) == MagickFalse))
     magick_info->semaphore=AcquireSemaphoreInfo();
   status=AddValueToSplayTree(magick_list,magick_info->name,magick_info);
-  if (status == MagickFalse)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
-  return(magick_info);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
-+   S e t M a g i c k I n f o                                                 %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  SetMagickInfo() allocates a MagickInfo structure and initializes the members
-%  to default values.
-%
-%  The format of the SetMagickInfo method is:
-%
-%      MagickInfo *SetMagickInfo(const char *name)
-%
-%  A description of each parameter follows:
-%
-%    o magick_info: Method SetMagickInfo returns the allocated and initialized
-%      MagickInfo structure.
-%
-%    o name: a character string that represents the image format associated
-%      with the MagickInfo structure.
-%
-*/
-MagickExport MagickInfo *SetMagickInfo(const char *name)
-{
-  MagickInfo
-    *magick_info;
-
-  assert(name != (const char *) NULL);
-  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
-  magick_info=(MagickInfo *) AcquireMagickMemory(sizeof(*magick_info));
-  if (magick_info == (MagickInfo *) NULL)
-    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
-  (void) ResetMagickMemory(magick_info,0,sizeof(*magick_info));
-  magick_info->name=ConstantString(name);
-  magick_info->flags=CoderAdjoinFlag | CoderBlobSupportFlag |
-    CoderDecoderThreadSupportFlag | CoderEncoderThreadSupportFlag |
-    CoderUseExtensionFlag;
-  magick_info->signature=MagickSignature;
-  return(magick_info);
+  return(status);
 }
 \f
 /*
index 2c43a83c4d58dbc0e1861c05d777465a8a421028..19dd614cf27c9dd546062550d2867da61f74a469 100644 (file)
@@ -122,6 +122,7 @@ extern MagickExport MagickBooleanType
   GetMagickStealth(const MagickInfo *),
   GetMagickUseExtension(const MagickInfo *),
   IsMagickCoreInstantiated(void),
+  RegisterMagickInfo(MagickInfo *),
   UnregisterMagickInfo(const char *);
 
 extern const MagickExport MagickInfo
@@ -129,8 +130,7 @@ extern const MagickExport MagickInfo
   **GetMagickInfoList(const char *,size_t *,ExceptionInfo *);
 
 extern MagickExport MagickInfo
-  *RegisterMagickInfo(MagickInfo *),
-  *SetMagickInfo(const char *);
+  *AcquireMagickInfo(const char *, const char *, const char *);
 
 extern MagickExport void
   MagickCoreGenesis(const char *,const MagickBooleanType),
index db38132d5caacaf23d1175a8d6a80fd3c406aa58..d64afd3162b6e62702925b8376d028a630c7b62a 100644 (file)
@@ -1092,7 +1092,7 @@ extern "C" {
 #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)
index a069a636a9bcaefe08c2ee64e68d3ce5938031e6..2e00fb20b6f029b6b48e0d9714a5eac6e91336c0 100644 (file)
@@ -262,11 +262,9 @@ ModuleExport size_t RegisterAAIImage(void)
   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);
 }
index c26778b36dfe7b05e607a21989b85b082591bedb..708c5fa1ee70c378af7eaf281010d55ef6ad1a07 100644 (file)
@@ -215,13 +215,11 @@ ModuleExport size_t RegisterARTImage(void)
   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);
 }
index 93a770e969f436c6089e0eaaceebb3fefe1cc695..a2466e6f11bd01c904892273def3f12b15822bb1 100644 (file)
@@ -259,11 +259,9 @@ ModuleExport size_t RegisterAVSImage(void)
   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);
 }
index e64ba72d9612587bbc589d84a7cb2b7802192a12..7ed112b405c666df678a4a098decbbc78022917c 100644 (file)
@@ -1021,29 +1021,25 @@ ModuleExport size_t RegisterBGRImage(void)
   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);
 }
index 217863fff29b77c0da5aa8fb691f562b4180d5c3..f555c146564016dad96b1131ca5d15843955011c 100644 (file)
@@ -1432,28 +1432,22 @@ ModuleExport size_t RegisterBMPImage(void)
   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);
index 9061f5583e8b72ab7cfc7677d523614682faa36c..2ceabe19beac10490155692d2f70622fe7e090b0 100644 (file)
@@ -96,23 +96,17 @@ ModuleExport size_t RegisterBRAILLEImage(void)
   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);
 }
index dde4871f9fed0805894fb355c6c31580676a2e14..550c960756fcad80a8a152f07cf7d353047beaf5 100644 (file)
@@ -309,40 +309,29 @@ static Image *ReadCALSImage(const ImageInfo *image_info,
 */
 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);
 }
index 516829ccc2defaec5ca5db8050c869fd27809b59..4be097d1337b86cb701f05ef63c363901d3a4426 100644 (file)
@@ -325,11 +325,9 @@ ModuleExport size_t RegisterCAPTIONImage(void)
   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);
 }
index 805ce0712066ffaf8c0e9181c81c2670b850992e..b2e094d696431f28e4adb6fc6f9536c3cc1e8065 100644 (file)
@@ -810,13 +810,11 @@ ModuleExport size_t RegisterCINImage(void)
   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);
 }
index d1369aafd210867cba1b68c074717041bb7a524c..0badf22cd3a0faceca7ac1d5db153360bf43a382 100644 (file)
@@ -98,11 +98,9 @@ ModuleExport size_t RegisterCIPImage(void)
   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);
 }
index c02589fe4349710dc2c2ca5d3bb90ef890a63140..59a3705c2591505bb68b633dd7022a0d7748961c 100644 (file)
@@ -154,11 +154,9 @@ ModuleExport size_t RegisterCLIPImage(void)
   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);
 }
index 516a60116e1f3fe21403e2285f2a7b3d37f2e239..1937001e781b58d25c2ff84548d3a607ed2f6700 100644 (file)
@@ -268,15 +268,13 @@ ModuleExport size_t RegisterCLIPBOARDImage(void)
   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);
 }
index 6d05da517c1c39e9e7fc35ccbb5f5661a597460a..ee4f06341abcecd2bba791f887c32fcfa07e5e33 100644 (file)
@@ -1139,23 +1139,19 @@ ModuleExport size_t RegisterCMYKImage(void)
   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);
 }
index 85b00226bf54d07efd1c465049c7dc8970376edd..e7be764a01cca98d1e8da9e1acda3a84b587c8ec 100644 (file)
@@ -639,11 +639,9 @@ ModuleExport size_t RegisterCUTImage(void)
   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);
 }
index a6b67d09c683119e15664c8859711916cd746de2..fe65a80f700e3dd924328f37c03e92a62660d1a1 100644 (file)
@@ -4146,15 +4146,13 @@ ModuleExport size_t RegisterDCMImage(void)
       "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);
 }
index f91f3cc6cb0dae9249797be9f0df757d2a0e1771..83e562eab7123f6a9fa07ea103ca14ff675717ab 100644 (file)
@@ -2304,29 +2304,23 @@ ModuleExport size_t RegisterDDSImage(void)
   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);
 }
index e51bd0537890bbc7df8c2acb255dacfeba571a52..3c3bdb9deb74aabe6811983ebf2b8031cd7df483 100644 (file)
@@ -102,12 +102,10 @@ ModuleExport size_t RegisterDEBUGImage(void)
   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);
 }
index b324f20e36121d749dc4eca5f0ab320b2f8f6c54..34ae5fd629f285b5edb6c4c46569b6563e406697 100644 (file)
@@ -931,15 +931,13 @@ ModuleExport size_t RegisterDIBImage(void)
   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);
 }
index 02105706f3d60ab83448c918c2f7d8a61b9ebfde..e359ab3af52a858c77e140c76462d2be89593dcc 100644 (file)
@@ -946,15 +946,13 @@ ModuleExport size_t RegisterDJVUImage(void)
   (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);
index 2ef1e55b65916afe512a46113ea6f83d0ed05945..8e8c41cbbb9fae98444a3402634a2a333a1ee594 100644 (file)
@@ -240,189 +240,144 @@ ModuleExport size_t RegisterDNGImage(void)
   MagickInfo
     *entry;
 
-  entry=SetMagickInfo("3FR");
+  entry=AcquireMagickInfo("DNG","3FR","Hasselblad CFV/H3D39II");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Hasselblad CFV/H3D39II");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("ARW");
+  entry=AcquireMagickInfo("DNG","ARW","Sony Alpha Raw Image Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Sony Alpha Raw Image Format");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("DNG");
+  entry=AcquireMagickInfo("DNG","DNG","Digital Negative");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Digital Negative");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("CR2");
+  entry=AcquireMagickInfo("DNG","CR2","Canon Digital Camera Raw Image Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Canon Digital Camera Raw Image Format");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("CRW");
+  entry=AcquireMagickInfo("DNG","CRW","Canon Digital Camera Raw Image Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Canon Digital Camera Raw Image Format");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("DCR");
+  entry=AcquireMagickInfo("DNG","DCR","Kodak Digital Camera Raw Image File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Kodak Digital Camera Raw Image File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("ERF");
+  entry=AcquireMagickInfo("DNG","ERF","Epson RAW Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Epson RAW Format");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("IIQ");
+  entry=AcquireMagickInfo("DNG","IIQ","Phase One Raw Image Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Phase One Raw Image Format");
   entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("KDC");
+  entry=AcquireMagickInfo("DNG","KDC","Kodak Digital Camera Raw Image Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Kodak Digital Camera Raw Image Format");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("K25");
+  entry=AcquireMagickInfo("DNG","K25","Kodak Digital Camera Raw Image Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Kodak Digital Camera Raw Image Format");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("MEF");
+  entry=AcquireMagickInfo("DNG","MEF","Mamiya Raw Image File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Mamiya Raw Image File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("MRW");
+  entry=AcquireMagickInfo("DNG","MRW","Sony (Minolta) Raw Image File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Sony (Minolta) Raw Image File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("NEF");
+  entry=AcquireMagickInfo("DNG","NEF","Nikon Digital SLR Camera Raw Image File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Nikon Digital SLR Camera Raw Image File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("NRW");
+  entry=AcquireMagickInfo("DNG","NRW","Nikon Digital SLR Camera Raw Image File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Nikon Digital SLR Camera Raw Image File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("ORF");
+  entry=AcquireMagickInfo("DNG","ORF","Olympus Digital Camera Raw Image File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Olympus Digital Camera Raw Image File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("PEF");
+  entry=AcquireMagickInfo("DNG","PEF","Pentax Electronic File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Pentax Electronic File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("RAF");
+  entry=AcquireMagickInfo("DNG","RAF","Fuji CCD-RAW Graphic File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Fuji CCD-RAW Graphic File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("RAW");
+  entry=AcquireMagickInfo("DNG","RAW","Raw");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Raw");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("RMF");
+  entry=AcquireMagickInfo("DNG","RMF","Raw Media Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Raw Media Format");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("RW2");
+  entry=AcquireMagickInfo("DNG","RW2","Panasonic Lumix Raw Image");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Panasonic Lumix Raw Image");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("SRF");
+  entry=AcquireMagickInfo("DNG","SRF","Sony Raw Format");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Sony Raw Format");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("SR2");
+  entry=AcquireMagickInfo("DNG","SR2","Sony Raw Format 2");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Sony Raw Format 2");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("X3F");
+  entry=AcquireMagickInfo("DNG","X3F","Sigma Camera RAW Picture File");
   entry->decoder=(DecodeImageHandler *) ReadDNGImage;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->format_type=ExplicitFormatType;
-  entry->description=ConstantString("Sigma Camera RAW Picture File");
-  entry->module=ConstantString("DNG");
   (void) RegisterMagickInfo(entry);
   return(MagickImageCoderSignature);
 }
index 27bae00751790fa62279a79cc2202da8c8a593d8..30be265c5b289835488ef53463c6071a6407ac8b 100644 (file)
@@ -193,21 +193,17 @@ ModuleExport size_t RegisterDOTImage(void)
   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();
index 115de620dacfbbb6d63d53fdf4f68e961bf806cb..9ddfa21982366653e856fdd77b56884ea1f92c0f 100644 (file)
@@ -543,13 +543,11 @@ ModuleExport size_t RegisterDPSImage(void)
   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);
 }
index c1b1d34272498ebd5b0442ed6b1a4e3671eef103..218bfd9959b2c12067c0b868a63711da6e4ee157 100644 (file)
@@ -1334,15 +1334,13 @@ ModuleExport size_t RegisterDPXImage(void)
       "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);
 }
index 98088904c9caa9688e8ae539b59f3af7aae50a6e..a5044a3a7e6752bce99a3f6de238e1764cfb52eb 100644 (file)
@@ -810,24 +810,19 @@ ModuleExport size_t RegisterEMFImage(void)
   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);
 }
index 5a99c468c95a2e15b74dc57de3508b2e0a905b0a..9bf8c44920dd5b7264d1edd81909672c37952a1d 100644 (file)
@@ -279,37 +279,31 @@ ModuleExport size_t RegisterEPTImage(void)
   MagickInfo
     *entry;
 
-  entry=SetMagickInfo("EPT");
+  entry=AcquireMagickInfo("EPT","EPT",
+    "Encapsulated PostScript with TIFF preview");
   entry->decoder=(DecodeImageHandler *) ReadEPTImage;
   entry->encoder=(EncodeImageHandler *) WriteEPTImage;
   entry->magick=(IsImageFormatHandler *) IsEPT;
   entry->flags|=CoderSeekableStreamFlag;
   entry->flags^=CoderAdjoinFlag;
   entry->flags^=CoderBlobSupportFlag;
-  entry->description=ConstantString(
-    "Encapsulated PostScript with TIFF preview");
-  entry->module=ConstantString("EPT");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("EPT2");
+  entry=AcquireMagickInfo("EPT","EPT2",
+    "Encapsulated PostScript Level II with TIFF preview");
   entry->decoder=(DecodeImageHandler *) ReadEPTImage;
   entry->encoder=(EncodeImageHandler *) WriteEPTImage;
   entry->magick=(IsImageFormatHandler *) IsEPT;
   entry->flags^=CoderAdjoinFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->flags^=CoderBlobSupportFlag;
-  entry->description=ConstantString(
-    "Encapsulated PostScript Level II with TIFF preview");
-  entry->module=ConstantString("EPT");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("EPT3");
+  entry=AcquireMagickInfo("EPT","EPT3",
+    "Encapsulated PostScript Level III with TIFF preview");
   entry->decoder=(DecodeImageHandler *) ReadEPTImage;
   entry->encoder=(EncodeImageHandler *) WriteEPTImage;
   entry->magick=(IsImageFormatHandler *) IsEPT;
   entry->flags|=CoderSeekableStreamFlag;
   entry->flags^=CoderBlobSupportFlag;
-  entry->description=ConstantString(
-    "Encapsulated PostScript Level III with TIFF preview");
-  entry->module=ConstantString("EPT");
   (void) RegisterMagickInfo(entry);
   return(MagickImageCoderSignature);
 }
index d4af8e1dd2de2b5a8268c1596cc8fc90235a4d7a..085ed6bdbbd6796912da601a52a7137f3e9ec74f 100644 (file)
@@ -287,16 +287,14 @@ ModuleExport size_t RegisterEXRImage(void)
   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);
 }
index 142b72e49909021e2b6d6315d1341b0bda537439..9700cfe115e57a02e88d5915557b508bfc137f69 100644 (file)
@@ -228,21 +228,17 @@ ModuleExport size_t RegisterFAXImage(void)
       "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);
 }
index bd8c49f83613d95f24bec9c1c42d735ffeb37362..7e2d4cd4b9f67f58cc66bb50c05fbeed1258982a 100644 (file)
@@ -154,10 +154,8 @@ ModuleExport size_t RegisterFDImage(void)
   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);
index 254cb51f233f18c6b5354280dbc75beebc9142b3..817e9c9b2bf47be15118267ff7b45a5c86054fc0 100644 (file)
@@ -537,23 +537,19 @@ ModuleExport size_t RegisterFITSImage(void)
   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);
 }
index 2db31f20a1fe49d13ab5187def34ffac841ca9f5..0526b9c69c59d3554227e44473e15601bf35d826 100644 (file)
@@ -492,7 +492,7 @@ ModuleExport size_t RegisterFPXImage(void)
   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 @@ ModuleExport size_t RegisterFPXImage(void)
   entry->flags^=CoderAdjoinFlag;
   entry->flags|=CoderSeekableStreamFlag;
   entry->flags^=CoderBlobSupportFlag;
-  entry->description=ConstantString("FlashPix Format");
-  entry->module=ConstantString("FPX");
   (void) RegisterMagickInfo(entry);
   return(MagickImageCoderSignature);
 }
index 0a6307bf5b9f38d932e5eee9d9bc9ec755c071bc..9af80a739cec3db0c2dddaa774a00e66b3ea1e51 100644 (file)
@@ -1399,23 +1399,21 @@ ModuleExport size_t RegisterGIFImage(void)
   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);
 }
index 7a3f0f31757e9702ea50b20ef03d137de70d0aa0..3ea5bd1bd96f7dad2892e2b207f99a0677045298 100644 (file)
@@ -203,23 +203,19 @@ ModuleExport size_t RegisterGRADIENTImage(void)
   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);
 }
index 0af76d01ae0f7e2349c8234a793eb055ebbfc618..2529eecc1c55cc36d890869e1bab0efd42fd62e9 100644 (file)
@@ -311,13 +311,11 @@ ModuleExport size_t RegisterGRAYImage(void)
   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);
 }
index 1de3e977cc015e339d21fce88687a316a2020e04..3ff438e9864902e69a138be82d1f2e2d0eaff79f 100644 (file)
@@ -194,14 +194,13 @@ ModuleExport size_t RegisterHALDImage(void)
   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);
 }
index 73bf70e081794d7878de9d8ba1886411817b5334..4cc2f1c0df6feed65cf5441d55192fb17391f974 100644 (file)
@@ -533,11 +533,9 @@ ModuleExport size_t RegisterHDRImage(void)
   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);
index 6610ad5f635647961e015bc1b7fe52fe931d67ba..b6937877ab7c86239436e65107f60c4c58db62b9 100644 (file)
@@ -102,12 +102,10 @@ ModuleExport size_t RegisterHISTOGRAMImage(void)
   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);
 }
index 41d1a76e8dcb4b865e0afb3cc4706a90c846a9d5..26fc655d6f548fa9c48b78045d86025271aba635 100644 (file)
@@ -207,12 +207,10 @@ ModuleExport size_t RegisterHRZImage(void)
   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);
 }
index 33beb899b3deefce0ef046c58c6c133ceaff1e43..ea71c449274f414165b7b5424f27731643ce4644 100644 (file)
@@ -129,29 +129,23 @@ ModuleExport size_t RegisterHTMLImage(void)
   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);
 }
index c8d6d6e6065ddcdb0ce939933a714bbd7e010405..0f3d00d439cde31b7f98ce3b9cf0909d3e09c7e3 100644 (file)
@@ -767,28 +767,22 @@ ModuleExport size_t RegisterICONImage(void)
   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);
 }
index d12c26963102bd08568b7941d954492bddd23e11..bb3b3f20b58a6421814394fb0b1bc565972618f3 100644 (file)
@@ -96,11 +96,10 @@ ModuleExport size_t RegisterINFOImage(void)
   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);
 }
index 11d5ad544c416a57ae78d0c96f294cb7cbe2078d..7df6801012c9e393e002ade5cd44bfc9e1f35ff9 100644 (file)
@@ -196,12 +196,10 @@ ModuleExport size_t RegisterINLINEImage(void)
   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);
 }
index 6dda26680fbd30d0e40fee52de64c19dbe36d700..827d9e138006dad9b1a27791402a31585076b894 100644 (file)
@@ -439,13 +439,11 @@ ModuleExport size_t RegisterIPLImage(void)
   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);
 }
index eb18d4d27338855ff7e88cef4ab5291b79c9ae8e..e44ae5e1ae869a3db23483636f2ca8331ac0b78b 100644 (file)
@@ -306,36 +306,30 @@ ModuleExport size_t RegisterJBIGImage(void)
 #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);
 }
index 841861f8529ad5201ffe556004c6eb9fa09c813f..a64bc139930f65d7842635182476a7753d54073f 100644 (file)
@@ -356,11 +356,9 @@ ModuleExport size_t RegisterJNXImage(void)
   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);
 }
index 412547cdf4b7c3eca1a2f8fc15a8b4b59cdceb2e..ffd5d1252ba83d4d84dbbc07d4f13336ab52969a 100644 (file)
@@ -542,12 +542,10 @@ ModuleExport size_t RegisterJP2Image(void)
 #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 @@ ModuleExport size_t RegisterJP2Image(void)
   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 @@ ModuleExport size_t RegisterJP2Image(void)
   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 @@ ModuleExport size_t RegisterJP2Image(void)
   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 @@ ModuleExport size_t RegisterJP2Image(void)
   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 @@ ModuleExport size_t RegisterJP2Image(void)
   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;
index ea86abd2fffb5dad015b835e7330c10a2615c5e9..cab17ad2b8e4a94fe19842571c7fb6d4958a43e5 100644 (file)
@@ -1513,20 +1513,19 @@ static Image *ReadJPEGImage(const ImageInfo *image_info,
 */
 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 @@ ModuleExport size_t RegisterJPEGImage(void)
   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 @@ ModuleExport size_t RegisterJPEGImage(void)
 #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 @@ ModuleExport size_t RegisterJPEGImage(void)
 #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 @@ ModuleExport size_t RegisterJPEGImage(void)
 #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 @@ ModuleExport size_t RegisterJPEGImage(void)
 #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);
 }
index 37b919da9bfea335971f818a02e074a49ea6dd0a..0b8db165a97016ce9d313766dd6212aeceb4f254 100644 (file)
@@ -109,11 +109,10 @@ ModuleExport size_t RegisterJSONImage(void)
   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);
 }
index 9d4fb6923faca894e69c23ee0a9a86f2a6f804b4..78f4fe851c5bf5bc4666bf5033f849fc80c23877 100644 (file)
@@ -279,12 +279,10 @@ ModuleExport size_t RegisterLABELImage(void)
   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);
 }
index df20cf5ee94cb8c1081440753d46bbc09811fac0..043a47f4ed71d19dca87682f18a31abba1fb0a49 100644 (file)
@@ -274,10 +274,8 @@ ModuleExport size_t RegisterMACImage(void)
   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);
 }
index e3e8fe6fec0c975b702c7b0fffdd32d5c4c1e7df..b7b6b64edb1e712cc45bf738e5fa3edd45a3541b 100644 (file)
@@ -13099,61 +13099,47 @@ ModuleExport size_t RegisterMAGICKImage(void)
   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);
 }
index cac5692b0826250e1be1fb80ed082e908367b182..d1809e8096d4ff3e1353379cb8e25fcca557aec1 100644 (file)
@@ -272,15 +272,13 @@ ModuleExport size_t RegisterMAPImage(void)
   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);
 }
index fafe68148727cbb64095f30ad6bd6872fada3469..0363007636bb97578592c4f0a98a50992c3958b4 100644 (file)
@@ -153,11 +153,9 @@ ModuleExport size_t RegisterMASKImage(void)
   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);
 }
index 913c82716b848719db6ac40b959dc27ef12ad786..6f729bda2c5018d61accb4a4178c1d3e9b97c8f8 100644 (file)
@@ -1110,13 +1110,11 @@ ModuleExport size_t RegisterMATImage(void)
   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);
 }
index 9a0a49837599d2f68b61d330cc24203cacfad656..1894dcf2dcd608d4096f21c6a1a22c9bc63ac14e 100644 (file)
@@ -93,11 +93,9 @@ ModuleExport size_t RegisterMATTEImage(void)
   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);
 }
index c5634ee9e8ef76c8ee56ce34620a96d4f0cccf44..b60564d1b076620326331a1fdb9b8cc6414e166b 100644 (file)
@@ -1391,113 +1391,90 @@ ModuleExport size_t RegisterMETAImage(void)
   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);
 }
index 3020aeeb02ecb287881a7227a6e826d853752039..2840f1197773f7fc0308bf5a470fd8ff6a419a53 100644 (file)
@@ -1664,15 +1664,13 @@ ModuleExport size_t RegisterMIFFImage(void)
   (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);
 }
index 919ae4d52404c9723cad2a1ff6aa23adf632ab9f..74ee20b9bd3a6894bf16fcf374490cbcc6aa58f2 100644 (file)
@@ -221,14 +221,12 @@ ModuleExport size_t RegisterMONOImage(void)
   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);
 }
index 733da24c9873f153ec58aee315c0cee164721b51..f555c6a32d932182ebd1df138ca30618e63a1f45 100644 (file)
@@ -989,17 +989,15 @@ ModuleExport size_t RegisterMPCImage(void)
   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);
 }
index f38fe2d8e813cf64c9ff1d5fc38772c8397703cd..0b736011fcb37fc931bab7299d7d52b081a75546 100644 (file)
@@ -240,76 +240,58 @@ ModuleExport size_t RegisterMPEGImage(void)
   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);
 }
index 9281dca173feee24cd14dff2525fcea514c766cc..f6ec3e118b6e411a45aa03e02cc1e4a5f835d09b 100644 (file)
@@ -132,23 +132,19 @@ ModuleExport size_t RegisterMPRImage(void)
   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);
 }
index 5606f4633e6ea8d92fe87f964c96bfd18bacd359..871c77f61081a962c10fcab5320ec512ce7a6a67 100644 (file)
@@ -7870,13 +7870,11 @@ ModuleExport size_t RegisterMSLImage(void)
 #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);
 }
index 3778de359cda31b0c6dc56afe6c20b83ff60c9f0..0e925b630d35ab8c43e8b922f70045fe2bcb3864 100644 (file)
@@ -261,11 +261,9 @@ ModuleExport size_t RegisterMTVImage(void)
   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);
 }
index facf49de11ea29c3fb29871adf162107b63a67c3..3ae33fd96106ff080e77d942ac298622361931c5 100644 (file)
@@ -246,14 +246,12 @@ ModuleExport size_t RegisterMVGImage(void)
   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);
 }
index 69c218e2f8adafb6316993691f3a149b12c513e4..0f271c986d2280c9eb34573897572329896d03cd 100644 (file)
@@ -179,13 +179,11 @@ ModuleExport size_t RegisterNULLImage(void)
   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);
 }
index 408bfe524e099e54cf0ef5db92e2f304b2afb722..ede66cba6dfcd54586b03cabe649ef797c5606e5 100644 (file)
@@ -238,12 +238,10 @@ ModuleExport size_t RegisterOTBImage(void)
   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);
 }
index 9b951b2f2fa53ec8e6a88dacae7ee2b5edf1aa61..e785f87c1dedd147e4f474b34ec8f907bd2cfa68 100644 (file)
@@ -604,12 +604,10 @@ ModuleExport size_t RegisterPALMImage(void)
   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);
 }
index 4314c7f0fc75f879dcb4f30227316233874f2afa..1ba0e08bbc91884c05c37d0ee49ce846155d85ea 100644 (file)
@@ -500,15 +500,13 @@ ModuleExport size_t RegisterPANGOImage(void)
   (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);
 }
index d9426da190653dd6425cb37a500b07cbfdfc9144..cad1be4ceadd0c834de6c55ab819a005156fe26a 100644 (file)
@@ -1023,11 +1023,9 @@ ModuleExport size_t RegisterPATTERNImage(void)
   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);
 }
index fe34c7a6f1d1a528dbb8052ed042c441eacafbcb..298b426f4bacf704ca832002d438fd2f925ed216 100644 (file)
@@ -869,22 +869,18 @@ ModuleExport size_t RegisterPCDImage(void)
   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);
 }
index 07bfe80bdf149874058c60728cd7952780c53d82..d978a4bd8eed52695e90fefdbfd8b0f6d5d8236d 100644 (file)
@@ -421,15 +421,13 @@ ModuleExport size_t RegisterPCLImage(void)
   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);
 }
index 8505d50c3082de583f5ea2d8f1856c5e96d43efe..76a8137bec71e39463304a398203a9fca95ede24 100644 (file)
@@ -707,22 +707,18 @@ ModuleExport size_t RegisterPCXImage(void)
   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);
 }
index cafb542061b593931bcdbf46e9ceaf8af9e92d51..d1dfaa46f840fd91f2f5d8fa117be845292ec536 100644 (file)
@@ -624,12 +624,10 @@ ModuleExport size_t RegisterPDBImage(void)
   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);
 }
index 5a0dae0e993ec40e92ae575cb5768058a2ecccc4..e94bc3273271522d3af3a4c133176946c4d54ca3 100644 (file)
@@ -866,45 +866,38 @@ ModuleExport size_t RegisterPDFImage(void)
   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);
 }
index cfce5c915cc61cecf6efd0c92fe439988b1c4bf7..38cea7c841457238cbb15c2061b4c86b666daef5 100644 (file)
@@ -697,11 +697,9 @@ ModuleExport size_t RegisterPESImage(void)
   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);
 }
index 0a221e2ada16293e471153ed1a0fe74d7e399fe2..bf7f0cd82665957aed087fb9f3fb8bffd8d76538 100644 (file)
@@ -1520,23 +1520,19 @@ ModuleExport size_t RegisterPICTImage(void)
   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);
 }
index 62085bfdf50e792b3ebb05f63c93aed3ea5c74c9..0673c6c996522546d5d1a9eed969b4ee4b854e74 100644 (file)
@@ -275,10 +275,8 @@ ModuleExport size_t RegisterPIXImage(void)
   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);
 }
index cd8b906d932e4b1ebed299ffad12e316c086ca60..77a8e02cadc495d5e010099ffcfd934623f605a4 100644 (file)
@@ -239,19 +239,15 @@ ModuleExport size_t RegisterPLASMAImage(void)
   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);
 }
index 701f915472d914c18b9b1567d16cf504799bbc32..6dd3a125d735ed21a75427fb4f228230be6cca23 100644 (file)
@@ -7378,7 +7378,7 @@ ModuleExport size_t RegisterPNGImage(void)
     }
 #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 @@ ModuleExport size_t RegisterPNGImage(void)
 #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 @@ ModuleExport size_t RegisterPNGImage(void)
 
   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 @@ ModuleExport size_t RegisterPNGImage(void)
   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 @@ ModuleExport size_t RegisterPNGImage(void)
 
   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 @@ ModuleExport size_t RegisterPNGImage(void)
 
   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 @@ ModuleExport size_t RegisterPNGImage(void)
 
   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 @@ ModuleExport size_t RegisterPNGImage(void)
 
   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,12 +7487,11 @@ ModuleExport size_t RegisterPNGImage(void)
 
   entry->magick=(IsImageFormatHandler *) IsPNG;
   entry->flags^=CoderAdjoinFlag;
-  entry->description=ConstantString("opaque or transparent 64-bit RGBA");
   entry->mime_type=ConstantString("image/png");
-  entry->module=ConstantString("PNG");
   (void) RegisterMagickInfo(entry);
 
-  entry=SetMagickInfo("PNG00");
+  entry=AcquireMagickInfo("PNG","PNG00",
+    "PNG inheriting bit-depth and color-type from original");
 
 #if defined(MAGICKCORE_PNG_DELEGATE)
   entry->decoder=(DecodeImageHandler *) ReadPNGImage;
@@ -7511,13 +7500,10 @@ ModuleExport size_t RegisterPNGImage(void)
 
   entry->magick=(IsImageFormatHandler *) IsPNG;
   entry->flags^=CoderAdjoinFlag;
-  entry->description=ConstantString(
-    "PNG inheriting bit-depth and color-type from original");
   entry->mime_type=ConstantString("image/png");
-  entry->module=ConstantString("PNG");
   (void) RegisterMagickInfo(entry);
 
-  entry=SetMagickInfo("JNG");
+  entry=AcquireMagickInfo("PNG","JNG","JPEG Network Graphics");
 
 #if defined(JNG_SUPPORTED)
 #if defined(MAGICKCORE_PNG_DELEGATE)
@@ -7528,9 +7514,7 @@ ModuleExport size_t RegisterPNGImage(void)
 
   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);
 
index 6a2a6f1da34245387e2d2bb476e32c74f1504e2e..d31bd475e23997166e90ec0d3dca3189dba376be 100644 (file)
@@ -1409,48 +1409,37 @@ ModuleExport size_t RegisterPNMImage(void)
   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);
 }
index 02ff75f9a58e4ff87822e9eaa843e6d3b0b7fb58..c9b65427a7db211babab970ba5ced941ceb52ced 100644 (file)
@@ -98,13 +98,11 @@ ModuleExport size_t RegisterPREVIEWImage(void)
   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);
 }
index 0e605e742e4e23acbb171f937b95174ba610a0c8..0fb50bf235b9815cbcfa7df53c981139b261e97f 100644 (file)
@@ -1034,61 +1034,51 @@ ModuleExport size_t RegisterPSImage(void)
   MagickInfo
     *entry;
 
-  entry=SetMagickInfo("EPI");
+  entry=AcquireMagickInfo("PS","EPI",
+    "Encapsulated PostScript Interchange format");
   entry->decoder=(DecodeImageHandler *) ReadPSImage;
   entry->encoder=(EncodeImageHandler *) WritePSImage;
   entry->magick=(IsImageFormatHandler *) IsPS;
   entry->flags^=CoderAdjoinFlag;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
-  entry->description=ConstantString(
-    "Encapsulated PostScript Interchange format");
   entry->mime_type=ConstantString("application/postscript");
-  entry->module=ConstantString("PS");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("EPS");
+  entry=AcquireMagickInfo("PS","EPS","Encapsulated PostScript");
   entry->decoder=(DecodeImageHandler *) ReadPSImage;
   entry->encoder=(EncodeImageHandler *) WritePSImage;
   entry->magick=(IsImageFormatHandler *) IsPS;
   entry->flags^=CoderAdjoinFlag;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
-  entry->description=ConstantString("Encapsulated PostScript");
   entry->mime_type=ConstantString("application/postscript");
-  entry->module=ConstantString("PS");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("EPSF");
+  entry=AcquireMagickInfo("PS","EPSF","Encapsulated PostScript");
   entry->decoder=(DecodeImageHandler *) ReadPSImage;
   entry->encoder=(EncodeImageHandler *) WritePSImage;
   entry->magick=(IsImageFormatHandler *) IsPS;
   entry->flags^=CoderAdjoinFlag;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
-  entry->description=ConstantString("Encapsulated PostScript");
   entry->mime_type=ConstantString("application/postscript");
-  entry->module=ConstantString("PS");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("EPSI");
+  entry=AcquireMagickInfo("PS","EPSI",
+    "Encapsulated PostScript Interchange format");
   entry->decoder=(DecodeImageHandler *) ReadPSImage;
   entry->encoder=(EncodeImageHandler *) WritePSImage;
   entry->magick=(IsImageFormatHandler *) IsPS;
   entry->flags^=CoderAdjoinFlag;
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
-  entry->description=ConstantString(
-    "Encapsulated PostScript Interchange format");
   entry->mime_type=ConstantString("application/postscript");
-  entry->module=ConstantString("PS");
   (void) RegisterMagickInfo(entry);
-  entry=SetMagickInfo("PS");
+  entry=AcquireMagickInfo("PS","PS","PostScript");
   entry->decoder=(DecodeImageHandler *) ReadPSImage;
   entry->encoder=(EncodeImageHandler *) WritePSImage;
   entry->magick=(IsImageFormatHandler *) IsPS;
   entry->mime_type=ConstantString("application/postscript");
-  entry->module=ConstantString("PS");
   entry->flags^=CoderBlobSupportFlag;
   entry->flags|=CoderSeekableStreamFlag;
-  entry->description=ConstantString("PostScript");
   (void) RegisterMagickInfo(entry);
   return(MagickImageCoderSignature);
 }
index 908e321ae7a04feea5eb03e818336c202160ac51..cbbde50c4742b1c041cd8e955c7fbc6310b380b0 100644 (file)
@@ -113,20 +113,16 @@ ModuleExport size_t RegisterPS2Image(void)
   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);
 }
index 58c81aebb8171c3f2e0507230fb06db67dcf46ec..cb11b4c405f6efa5af896116c824f21bb15a292d 100644 (file)
@@ -129,18 +129,14 @@ ModuleExport size_t RegisterPS3Image(void)
   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);
index 108599026a0d91c4e061bb9304847457a6e9599a..53f6c9e4300789b878e577f4f3070fde35f66018 100644 (file)
@@ -1880,21 +1880,17 @@ ModuleExport size_t RegisterPSDImage(void)
   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);
 }
index 357687d57db03612c1da2403688445248ae5cf72..23d18519e4da83aedeac5e17c4911327fb8dc842 100644 (file)
@@ -291,11 +291,9 @@ ModuleExport size_t RegisterPWPImage(void)
   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);
 }
index 52f0562f1299a961959f9e3c02e4bb2def18a024..fddac83396d8f0ec59a4632f048e752abc9b953b 100644 (file)
@@ -305,77 +305,59 @@ ModuleExport size_t RegisterRAWImage(void)
   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);
 }
index f9e3e655f52fbbd1c58ea4766d9f96a0e884cb9c..67ecdc06eb5ae5ec019c35bb0406e1e199c58e4c 100644 (file)
@@ -1012,29 +1012,26 @@ ModuleExport size_t RegisterRGBImage(void)
   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);
 }
index cdbd3d834a84020bcbf9d14619379a4991795d42..5a6131c71f22396f51863316a275effae572f056 100644 (file)
@@ -247,13 +247,11 @@ ModuleExport size_t RegisterRGFImage(void)
   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);
 }
index a1abc194fec329bd93eac897dbea617e41f0fedf..c80ff7aa03dee67da7dc0ed5152a962960bc0938 100644 (file)
@@ -423,12 +423,10 @@ ModuleExport size_t RegisterRLAImage(void)
   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);
 }
index f4ed8a6b62a2794a76b78b9acb914f6cf8042e56..3d7bb9098986ffeef4fecd3da4e08287d3baf126 100644 (file)
@@ -683,12 +683,10 @@ ModuleExport size_t RegisterRLEImage(void)
   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);
 }
index 32743da88c5bdd919e7398ba05051a144716a187..9b73ecf90ee6f2e14c1c7e8801c4ff0bf20084e4 100644 (file)
@@ -274,11 +274,9 @@ ModuleExport size_t RegisterSCRImage(void)
   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);
 }
index a2d9afc9c30324bafab6a64c377bda49ba948a64..e821f1ae4d83e668d5b75f07dbb55d12010a772e 100644 (file)
@@ -277,11 +277,9 @@ ModuleExport size_t RegisterSCREENSHOTImage(void)
   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);
 }
index 11a16df78f3eb87898520d27b4c44729bd976b25..69370772e190d3a369301fe2c8607afd0a6d21e6 100644 (file)
@@ -312,12 +312,10 @@ ModuleExport size_t RegisterSCTImage(void)
   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);
 }
index dbc8bffb0d8e1c777ba1f6585bc7fa4757813cab..ff7e8e2215f0d208fe517f5c6d1b48d1a651128f 100644 (file)
@@ -398,12 +398,10 @@ ModuleExport size_t RegisterSFWImage(void)
   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);
 }
index 0be78b15053828cb2a54ec22f8b2c60b440680d4..627f7524fb5937e6cacde746d373a6c2e18d9fb1 100644 (file)
@@ -743,12 +743,10 @@ ModuleExport size_t RegisterSGIImage(void)
   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);
index bfab580f19d845978f170669da351bb1836b8850..fcd5221267f9aa05e6d4aabdd3cf10c09ccf0794 100644 (file)
@@ -1105,21 +1105,17 @@ ModuleExport size_t RegisterSIXELImage(void)
   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);
 }
index 26c2aff0953d4b0f43d2d6c8bf46e618aa70b5fd..06c0e95e773fe31cb845e31923444640a8d0823f 100644 (file)
@@ -250,11 +250,9 @@ ModuleExport size_t RegisterSTEGANOImage(void)
   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);
 }
index 8d605da05422674580ff7689041844d877350202..91b59bc0ee54e30bdd5e259bd25989be6561f635 100644 (file)
@@ -634,18 +634,14 @@ ModuleExport size_t RegisterSUNImage(void)
   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);
 }
index 05f87f34b093b1e4b687d772cf95ee423de587d0..7db99cbe6b493a62bf545ae01cec51b07fce28eb 100644 (file)
@@ -3242,41 +3242,36 @@ ModuleExport size_t RegisterSVGImage(void)
   (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);
 }
index b09638dca3c30eceda95cc085eeee1ec0165c0ac..96c59ed400d3d65e1fbddf38785efcceeadcaec0 100644 (file)
@@ -570,33 +570,25 @@ ModuleExport size_t RegisterTGAImage(void)
   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);
 }
index 90eba4bc4be9f8079261142fa62ce2085d49b129..d54a675512669026752a937e716d6e96642f45f1 100644 (file)
@@ -92,10 +92,8 @@ ModuleExport size_t RegisterTHUMBNAILImage(void)
   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);
 }
index d502f564a8de25d6b681bcec5a7ee7cd31bb154e..a85eebe118d0214c320c59c4083381e9bccef538 100644 (file)
@@ -2152,7 +2152,7 @@ ModuleExport size_t RegisterTIFFImage(void)
   }
 #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 @@ ModuleExport size_t RegisterTIFFImage(void)
   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 @@ ModuleExport size_t RegisterTIFFImage(void)
   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 @@ ModuleExport size_t RegisterTIFFImage(void)
   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 @@ ModuleExport size_t RegisterTIFFImage(void)
   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 @@ ModuleExport size_t RegisterTIFFImage(void)
   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);
 }
index ad0d65b05879aae6e3d907525515654187125b15..03924e43211f0755ad25d99ec5f932b06cdc11f3 100644 (file)
@@ -167,13 +167,11 @@ ModuleExport size_t RegisterTILEImage(void)
   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);
 }
index 4f26bc27de81a2332cc481b4f0c5bb2aed4093db..1b51871d210cbaad335a3db32cc00b0c791fab8c 100644 (file)
@@ -448,10 +448,8 @@ ModuleExport size_t RegisterTIMImage(void)
   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);
 }
index 4a1f6eae8a73ead83b0a92e86deb6bf10fd7960c..559f6be0f7361c205aa8932449feb3eeea06825b 100644 (file)
@@ -328,71 +328,59 @@ ModuleExport size_t RegisterTTFImage(void)
   (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);
 }
index 6a6c6c8be00d8174659c9f403639458ae5e7ac7d..fa321a0920d9fa4998151644618d0ee84d5aa02c 100644 (file)
@@ -596,27 +596,21 @@ ModuleExport size_t RegisterTXTImage(void)
   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);
 }
index 555b531d37a6120c7cdc27c57108dd03af45e3d3..ad42fdfed8fc18b62722016ac95a42b3a9ed748f 100644 (file)
@@ -96,11 +96,9 @@ ModuleExport size_t RegisterUILImage(void)
   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);
 }
index 10b554d0bc27f63d8d8e76779d7e2d665efa8213..b8b241e789ba9223cd05196ea19aa6dfcfd03406 100644 (file)
@@ -293,39 +293,31 @@ ModuleExport size_t RegisterURLImage(void)
   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);
index 08b36605664837cebc4125db04f3867cbc6ed282..b31eb44a704e0bb275db18994d7bb600c080132f 100644 (file)
@@ -214,23 +214,19 @@ ModuleExport size_t RegisterUYVYImage(void)
   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);
 }
index a70b0c6016c9aff8358a741b8db665333c4e647e..876a42c3bc60f392a6799ec14790d81935107424 100644 (file)
@@ -355,13 +355,11 @@ ModuleExport size_t RegisterVICARImage(void)
   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);
 }
index a4172730b11f390e70bf9c4da2cfb7b6c79a41c4..68ee524b58b68ca93a8899a708d9b607610a8019 100644 (file)
@@ -243,12 +243,10 @@ ModuleExport size_t RegisterVIDImage(void)
   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);
 }
index f950bdeb1eff11eb2895ffa11059a4d5e4dd503b..3a4a8a85e891c20f4ba9ad3466605e4cd2a2fc93 100644 (file)
@@ -783,18 +783,14 @@ ModuleExport size_t RegisterVIFFImage(void)
   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);
 }
index 39d4dda988a1314cfe06be2d705f63ecdac2dac6..4267fa16a6a8aeb8c489ecd2148d873d868d472b 100644 (file)
@@ -545,13 +545,11 @@ ModuleExport size_t RegisterVIPSImage(void)
   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);
 }
index c9b7fc907c3ce568c40fe4c98989be8fa0e1b140..c76132fd1bce0fcbc8a720cdde9c69c7111ec6ed 100644 (file)
@@ -252,12 +252,10 @@ ModuleExport size_t RegisterWBMPImage(void)
   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);
 }
index d9b65222139abadac6196dc43e9624fec4408969..372b1096c8dcdca132eab046ed2fbfabf1ff35bd 100644 (file)
@@ -401,7 +401,7 @@ ModuleExport size_t RegisterWEBPImage(void)
     *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 @@ ModuleExport size_t RegisterWEBPImage(void)
     (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);
index 3df5101b07c45c82068c9ec483a752bb952dafc8..a0ad8aa9516c74a21ec840e549c8851ac15ec095 100644 (file)
@@ -2948,20 +2948,16 @@ ModuleExport size_t RegisterWMFImage(void)
   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);
 }
index b563288267ad328e760fe2ecd067eab3516d08d2..ef961f0ffbb8d60ce2c1bed239a78de5bcda4694 100644 (file)
@@ -1492,11 +1492,9 @@ ModuleExport size_t RegisterWPGImage(void)
   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);
index 279da1e7fe7f39a4cb8d8f6eb8dc48cff96f36fb..ab7fa981249ae1372fa32b978079b2c9bee176b9 100644 (file)
@@ -135,14 +135,12 @@ ModuleExport size_t RegisterXImage(void)
   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);
 }
index 3b3b314ddb430a2a0eeec0f88227908fb2436d16..c3c080039de7afdea1e8e9ac0d81b5f2650cc28c 100644 (file)
@@ -418,14 +418,12 @@ ModuleExport size_t RegisterXBMImage(void)
   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);
 }
index f5d84d795f8834738cde2adf5a7dac7348796893..ff845677077a4a3e41125030ea3814c2a8269895 100644 (file)
@@ -186,23 +186,19 @@ ModuleExport size_t RegisterXCImage(void)
   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);
 }
index 5ec3d721139e622969e08646332670b41d041fdb..3e3a331544edffab4b38b85e9355eab69dbe6559 100644 (file)
@@ -1447,11 +1447,9 @@ ModuleExport size_t RegisterXCFImage(void)
   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);
index 6d8229e19d2e238e3718db7723027d0b1d0f24dc..8c3bb1cca4f790320bd2cb1ca02bdbc27f180d4f 100644 (file)
@@ -497,28 +497,22 @@ ModuleExport size_t RegisterXPMImage(void)
   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);
 }
index 9a9752b9d8647c6a8c04418dc7e6d6b2cce66193..af6e89329d631116b81579611e6b7c8628af8f2c 100644 (file)
@@ -374,14 +374,12 @@ ModuleExport size_t RegisterXPSImage(void)
   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);
 }
index cf42ce35b1833ef584219dc2203ab03ede497572..54798259e51a09b1cfabab36d4fcdfd5fa0f4551 100644 (file)
@@ -256,46 +256,40 @@ ModuleExport size_t RegisterXTRNImage(void)
   MagickInfo
     *entry;
 
-  entry=SetMagickInfo("XTRNFILE");
+  entry=AcquireMagickInfo("XTRN","XTRNFILE","External transfer of a file");
 #if defined(_VISUALC_)
   entry->decoder=ReadXTRNImage;
   entry->encoder=WriteXTRNImage;
 #endif
   entry->flags^=CoderAdjoinFlag;
   entry->flags|=CoderStealthFlag;
-  entry->description=ConstantString("External transfer of a file");
-  entry->module=ConstantString("XTRN");
   RegisterMagickInfo(entry);
-  entry=SetMagickInfo("XTRNIMAGE");
+  entry=AcquireMagickInfo("XTRN","XTRNIMAGE",
+    "External transfer of a image in memory");
 #if defined(_VISUALC_)
   entry->decoder=ReadXTRNImage;
   entry->encoder=WriteXTRNImage;
 #endif
   entry->flags^=CoderAdjoinFlag;
   entry->flags|=CoderStealthFlag;
-  entry->description=ConstantString("External transfer of a image in memory");
-  entry->module=ConstantString("XTRN");
   RegisterMagickInfo(entry);
-  entry=SetMagickInfo("XTRNBLOB");
+  entry=AcquireMagickInfo("XTRN","XTRNBLOB",
+    "IExternal transfer of a blob in memory");
 #if defined(_VISUALC_)
   entry->decoder=ReadXTRNImage;
   entry->encoder=WriteXTRNImage;
 #endif
   entry->flags^=CoderAdjoinFlag;
   entry->flags|=CoderStealthFlag;
-  entry->description=ConstantString("IExternal transfer of a blob in memory");
-  entry->module=ConstantString("XTRN");
   RegisterMagickInfo(entry);
-  entry=SetMagickInfo("XTRNARRAY");
+  entry=AcquireMagickInfo("XTRN","XTRNARRAY",
+    "External transfer via a smart array interface");
 #if defined(_VISUALC_)
   entry->decoder=ReadXTRNImage;
   entry->encoder=WriteXTRNImage;
 #endif
   entry->flags^=CoderAdjoinFlag;
   entry->flags|=CoderStealthFlag;
-  entry->description=ConstantString(
-    "External transfer via a smart array interface");
-  entry->module=ConstantString("XTRN");
   RegisterMagickInfo(entry);
   return(MagickImageCoderSignature);
 }
index dba43a1dd721a85d13cbc24c49edec37e9bf53f8..d419932dce92efe05422fb4b3fc899f4f934a4e2 100644 (file)
@@ -598,15 +598,13 @@ ModuleExport size_t RegisterXWDImage(void)
   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);
 }
index 152f21ffcf405f308f6946bca719131f7cae0751..cf2f2eb6da3225e93a17535045445e30c550ee74 100644 (file)
@@ -923,21 +923,17 @@ ModuleExport size_t RegisterYCBCRImage(void)
   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);
 }
index 317e5a75bc069c54f475cf4ca4ecc23d9ce85964..f92d6d68689e853dcbaeee52ce57f530353112e0 100644 (file)
@@ -492,13 +492,11 @@ ModuleExport size_t RegisterYUVImage(void)
   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);
 }