graphics/imagemagick
graphics/imagemagick
1
0
Fork 0
mirror of https://github.com/imagemagick/imagemagick synced 2024-10-18 17:02:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Renamed SetMagickInfo to AcquireMagickInfo and made the module and description mandatory.

Browse source 
Changed RegisterMagickInfo to return a boolean instead of the supplied pointer.
This commit is contained in:
dirk 2015-04-06 18:59:17 +00:00
parent e848b9adec
commit 06b627a07f
131 changed files with 441 additions and 983 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Magick++/lib/Magick++/Include.h
View 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;

116
MagickCore/magick.c
View 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);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ 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);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ 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);
}
/*

4
MagickCore/magick.h
View 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),

2
MagickCore/methods.h
View 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)

4
coders/aai.c
View 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);
}

4
coders/art.c
View 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);
}

4
coders/avs.c
View 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);
}

14
coders/bgr.c
View 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);
}

12
coders/bmp.c
View 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);

12
coders/braille.c
View 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);
}

21
coders/cals.c
View 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);
}

4
coders/caption.c
View 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);
}

4
coders/cin.c
View 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);
}

4
coders/cip.c
View 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);
}

4
coders/clip.c
View 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);
}

4
coders/clipboard.c
View 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);
}

12
coders/cmyk.c
View 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);
}

4
coders/cut.c
View 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);
}

6
coders/dcm.c
View 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);
}

12
coders/dds.c
View 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);
}

4
coders/debug.c
View 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);
}

6
coders/dib.c
View 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);
}

4
coders/djvu.c
View 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);

161
coders/dng.c
View 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;
(void) RegisterMagickInfo(entry);
entry=AcquireMagickInfo("DNG","ARW","Sony Alpha Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
(void) RegisterMagickInfo(entry);
entry=AcquireMagickInfo("DNG","DNG","Digital Negative");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
(void) RegisterMagickInfo(entry);
entry=AcquireMagickInfo("DNG","CR2","Canon Digital Camera Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
(void) RegisterMagickInfo(entry);
entry=AcquireMagickInfo("DNG","CRW","Canon Digital Camera Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
(void) RegisterMagickInfo(entry);
entry=AcquireMagickInfo("DNG","DCR","Kodak Digital Camera Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
(void) RegisterMagickInfo(entry);
entry=AcquireMagickInfo("DNG","ERF","Epson RAW Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
(void) RegisterMagickInfo(entry);
entry=AcquireMagickInfo("DNG","IIQ","Phase One Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Hasselblad CFV/H3D39II");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("ARW");
entry=AcquireMagickInfo("DNG","KDC","Kodak Digital Camera Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Sony Alpha Raw Image Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("DNG");
entry=AcquireMagickInfo("DNG","K25","Kodak Digital Camera Raw Image Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Digital Negative");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("CR2");
entry=AcquireMagickInfo("DNG","MEF","Mamiya Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Canon Digital Camera Raw Image Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("CRW");
entry=AcquireMagickInfo("DNG","MRW","Sony (Minolta) Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Canon Digital Camera Raw Image Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("DCR");
entry=AcquireMagickInfo("DNG","NEF","Nikon Digital SLR Camera Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Kodak Digital Camera Raw Image File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("ERF");
entry=AcquireMagickInfo("DNG","NRW","Nikon Digital SLR Camera Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Epson RAW Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("IIQ");
entry=AcquireMagickInfo("DNG","ORF","Olympus Digital Camera Raw Image File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Phase One Raw Image Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("KDC");
entry=AcquireMagickInfo("DNG","PEF","Pentax Electronic File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Kodak Digital Camera Raw Image Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("K25");
entry=AcquireMagickInfo("DNG","RAF","Fuji CCD-RAW Graphic File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Kodak Digital Camera Raw Image Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("MEF");
entry=AcquireMagickInfo("DNG","RAW","Raw");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Mamiya Raw Image File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("MRW");
entry=AcquireMagickInfo("DNG","RMF","Raw Media Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Sony (Minolta) Raw Image File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("NEF");
entry=AcquireMagickInfo("DNG","RW2","Panasonic Lumix Raw Image");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Nikon Digital SLR Camera Raw Image File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("NRW");
entry=AcquireMagickInfo("DNG","SRF","Sony Raw Format");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Nikon Digital SLR Camera Raw Image File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("ORF");
entry=AcquireMagickInfo("DNG","SR2","Sony Raw Format 2");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Olympus Digital Camera Raw Image File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("PEF");
entry=AcquireMagickInfo("DNG","X3F","Sigma Camera RAW Picture File");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Pentax Electronic File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("RAF");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Fuji CCD-RAW Graphic File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("RAW");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Raw");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("RMF");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Raw Media Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("RW2");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Panasonic Lumix Raw Image");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("SRF");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Sony Raw Format");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("SR2");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Sony Raw Format 2");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("X3F");
entry->decoder=(DecodeImageHandler *) ReadDNGImage;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Sigma Camera RAW Picture File");
entry->module=ConstantString("DNG");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}

8
coders/dot.c
View 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();

4
coders/dps.c
View 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);
}

4
coders/dpx.c
View 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);
}

9
coders/emf.c
View 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);
}

28
coders/ept.c
View file

@ -279,37 +279,31 @@ ModuleExport size_t RegisterEPTImage(void)
MagickInfo
*entry;
entry=SetMagickInfo("EPT");
entry->decoder=(DecodeImageHandler *) ReadEPTImage;
entry->encoder=(EncodeImageHandler *) WriteEPTImage;
entry->magick=(IsImageFormatHandler *) IsEPT;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->description=ConstantString(
entry=AcquireMagickInfo("EPT","EPT",
"Encapsulated PostScript with TIFF preview");
entry->module=ConstantString("EPT");
entry->decoder=(DecodeImageHandler *) ReadEPTImage;
entry->encoder=(EncodeImageHandler *) WriteEPTImage;
entry->magick=(IsImageFormatHandler *) IsEPT;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("EPT2");
entry=AcquireMagickInfo("EPT","EPT2",
"Encapsulated PostScript Level II with TIFF preview");
entry->decoder=(DecodeImageHandler *) ReadEPTImage;
entry->encoder=(EncodeImageHandler *) WriteEPTImage;
entry->magick=(IsImageFormatHandler *) IsEPT;
entry->flags^=CoderAdjoinFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderBlobSupportFlag;
entry->description=ConstantString(
"Encapsulated PostScript Level II with TIFF preview");
entry->module=ConstantString("EPT");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("EPT3");
entry=AcquireMagickInfo("EPT","EPT3",
"Encapsulated PostScript Level III with TIFF preview");
entry->decoder=(DecodeImageHandler *) ReadEPTImage;
entry->encoder=(EncodeImageHandler *) WriteEPTImage;
entry->magick=(IsImageFormatHandler *) IsEPT;
entry->flags|=CoderSeekableStreamFlag;
entry->flags^=CoderBlobSupportFlag;
entry->description=ConstantString(
"Encapsulated PostScript Level III with TIFF preview");
entry->module=ConstantString("EPT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}

4
coders/exr.c
View 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);
}

8
coders/fax.c
View 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);
}

4
coders/fd.c
View 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);

8
coders/fits.c
View 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);
}

4
coders/fpx.c
View 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);
}

10
coders/gif.c
View 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);
}

12
coders/gradient.c
View 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);
}

4
coders/gray.c
View 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);
}

5
coders/hald.c
View 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);
}

4
coders/hdr.c
View 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);

4
coders/histogram.c
View 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);
}

4
coders/hrz.c
View 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);
}

18
coders/html.c
View 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);
}

12
coders/icon.c
View 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);
}

5
coders/info.c
View 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);
}

4
coders/inline.c
View 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);
}

4
coders/ipl.c
View 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);
}

12
coders/jbig.c
View 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);
}

4
coders/jnx.c
View 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);
}

24
coders/jp2.c
View 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;

25
coders/jpeg.c
View 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);
}

5
coders/json.c
View 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);
}

4
coders/label.c
View 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);
}

4
coders/mac.c
View 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);
}

28
coders/magick.c
View 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);
}

4
coders/map.c
View 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);
}

4
coders/mask.c
View 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);
}

4
coders/mat.c
View 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);
}

4
coders/matte.c
View 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);
}

49
coders/meta.c
View 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);
}

4
coders/miff.c
View 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);
}

4
coders/mono.c
View 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);
}

8
coders/mpc.c
View 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);
}

36
coders/mpeg.c
View 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);
}

8
coders/mpr.c
View 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);
}

4
coders/msl.c
View 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);
}

4
coders/mtv.c
View 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);
}

4
coders/mvg.c
View 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);
}

4
coders/null.c
View 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);
}

4
coders/otb.c
View 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);
}

4
coders/palm.c
View 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);
}

4
coders/pango.c
View 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);
}

4
coders/pattern.c
View 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);
}

8
coders/pcd.c
View 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);
}

4
coders/pcl.c
View 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);
}

8
coders/pcx.c
View 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);
}

4
coders/pdb.c
View 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);
}

17
coders/pdf.c
View 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);
}

4
coders/pes.c
View 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);
}

8
coders/pict.c
View 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);
}

4
coders/pix.c
View 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);
}

8
coders/plasma.c
View 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);
}

56
coders/png.c
View 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,27 +7487,23 @@ 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");
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPNGImage;
entry->encoder=(EncodeImageHandler *) WritePNGImage;
#endif
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
entry->description=ConstantString(
entry=AcquireMagickInfo("PNG","PNG00",
"PNG inheriting bit-depth and color-type from original");
#if defined(MAGICKCORE_PNG_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadPNGImage;
entry->encoder=(EncodeImageHandler *) WritePNGImage;
#endif
entry->magick=(IsImageFormatHandler *) IsPNG;
entry->flags^=CoderAdjoinFlag;
entry->mime_type=ConstantString("image/png");
entry->module=ConstantString("PNG");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("JNG");
entry=AcquireMagickInfo("PNG","JNG","JPEG Network Graphics");
#if defined(JNG_SUPPORTED)
#if defined(MAGICKCORE_PNG_DELEGATE)
@ -7528,9 +7514,7 @@ 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);

25
coders/pnm.c
View 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);
}

6
coders/preview.c
View 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);
}

36
coders/ps.c
View file

@ -1034,61 +1034,51 @@ ModuleExport size_t RegisterPSImage(void)
MagickInfo
*entry;
entry=SetMagickInfo("EPI");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->description=ConstantString(
entry=AcquireMagickInfo("PS","EPI",
"Encapsulated PostScript Interchange format");
entry->mime_type=ConstantString("application/postscript");
entry->module=ConstantString("PS");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("EPS");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->description=ConstantString("Encapsulated PostScript");
entry->mime_type=ConstantString("application/postscript");
entry->module=ConstantString("PS");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("EPSF");
entry=AcquireMagickInfo("PS","EPS","Encapsulated PostScript");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->description=ConstantString("Encapsulated PostScript");
entry->mime_type=ConstantString("application/postscript");
entry->module=ConstantString("PS");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("EPSI");
entry=AcquireMagickInfo("PS","EPSF","Encapsulated PostScript");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->description=ConstantString(
entry->mime_type=ConstantString("application/postscript");
(void) RegisterMagickInfo(entry);
entry=AcquireMagickInfo("PS","EPSI",
"Encapsulated PostScript Interchange format");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->flags^=CoderAdjoinFlag;
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->mime_type=ConstantString("application/postscript");
entry->module=ConstantString("PS");
(void) RegisterMagickInfo(entry);
entry=SetMagickInfo("PS");
entry=AcquireMagickInfo("PS","PS","PostScript");
entry->decoder=(DecodeImageHandler *) ReadPSImage;
entry->encoder=(EncodeImageHandler *) WritePSImage;
entry->magick=(IsImageFormatHandler *) IsPS;
entry->mime_type=ConstantString("application/postscript");
entry->module=ConstantString("PS");
entry->flags^=CoderBlobSupportFlag;
entry->flags|=CoderSeekableStreamFlag;
entry->description=ConstantString("PostScript");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}

8
coders/ps2.c
View 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);
}

8
coders/ps3.c
View 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);

8
coders/psd.c
View 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);
}

4
coders/pwp.c
View 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);
}

36
coders/raw.c
View 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);
}

15
coders/rgb.c
View 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);
}

6
coders/rgf.c
View 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);
}

4
coders/rla.c
View 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);
}

4
coders/rle.c
View 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);
}

4
coders/scr.c
View 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);
}

4
coders/screenshot.c
View 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);
}

4
coders/sct.c
View 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);
}

4
coders/sfw.c
View 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);
}

4
coders/sgi.c
View 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);

8
coders/sixel.c
View 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);
}

Some files were not shown because too many files have changed in this diff Show more