% July 1992 %
% %
% %
-% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/colormap.h"
#include "MagickCore/colormap-private.h"
#include "MagickCore/colorspace.h"
+#include "MagickCore/colorspace-private.h"
#include "MagickCore/constitute.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-private.h"
unsigned char
quantum;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
p=PushCharPixel(p,&quantum);
pixel->alpha=ScaleCharToQuantum(quantum);
unsigned short
quantum;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
p=PushShortPixel(MSBEndian,p,&quantum);
pixel->alpha=(Quantum) (quantum >> (image->depth-
unsigned int
quantum;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
p=PushLongPixel(MSBEndian,p,&quantum);
pixel->alpha=(Quantum) (quantum >> (image->depth-
p=PushCharPixel(p,&quantum);
pixel->red=ScaleCharToQuantum(quantum);
- p=PushCharPixel(p,&quantum);
- pixel->green=ScaleCharToQuantum(quantum);
- p=PushCharPixel(p,&quantum);
- pixel->blue=ScaleCharToQuantum(quantum);
+ pixel->green=pixel->red;
+ pixel->blue=pixel->red;
+ if (IsGrayColorspace(image->colorspace) == MagickFalse)
+ {
+ p=PushCharPixel(p,&quantum);
+ pixel->green=ScaleCharToQuantum(quantum);
+ p=PushCharPixel(p,&quantum);
+ pixel->blue=ScaleCharToQuantum(quantum);
+ }
if (image->colorspace == CMYKColorspace)
{
p=PushCharPixel(p,&quantum);
pixel->black=ScaleCharToQuantum(quantum);
}
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
p=PushCharPixel(p,&quantum);
pixel->alpha=ScaleCharToQuantum(quantum);
p=PushShortPixel(MSBEndian,p,&quantum);
pixel->red=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
- p=PushShortPixel(MSBEndian,p,&quantum);
- pixel->green=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
- p=PushShortPixel(MSBEndian,p,&quantum);
- pixel->blue=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
+ pixel->green=pixel->red;
+ pixel->blue=pixel->red;
+ if (IsGrayColorspace(image->colorspace) == MagickFalse)
+ {
+ p=PushShortPixel(MSBEndian,p,&quantum);
+ pixel->green=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
+ p=PushShortPixel(MSBEndian,p,&quantum);
+ pixel->blue=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
+ }
if (image->colorspace == CMYKColorspace)
{
p=PushShortPixel(MSBEndian,p,&quantum);
pixel->black=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
}
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
p=PushShortPixel(MSBEndian,p,&quantum);
pixel->alpha=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
p=PushLongPixel(MSBEndian,p,&quantum);
pixel->red=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
- p=PushLongPixel(MSBEndian,p,&quantum);
- pixel->green=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
- p=PushLongPixel(MSBEndian,p,&quantum);
- pixel->blue=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
+ pixel->green=pixel->red;
+ pixel->blue=pixel->red;
+ if (IsGrayColorspace(image->colorspace) == MagickFalse)
+ {
+ p=PushLongPixel(MSBEndian,p,&quantum);
+ pixel->green=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
+ p=PushLongPixel(MSBEndian,p,&quantum);
+ pixel->blue=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
+ }
if (image->colorspace == CMYKColorspace)
{
p=PushLongPixel(MSBEndian,p,&quantum);
pixel->black=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
}
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
p=PushLongPixel(MSBEndian,p,&quantum);
pixel->alpha=quantum >> (image->depth-MAGICKCORE_QUANTUM_DEPTH);
int
c;
+ LinkedListInfo
+ *profiles;
+
#if defined(MAGICKCORE_LZMA_DELEGATE)
lzma_stream
initialize_lzma = LZMA_STREAM_INIT,
allocator;
#endif
- LinkedListInfo
- *profiles;
-
MagickBooleanType
status;
*id='\0';
(void) ResetMagickMemory(keyword,0,sizeof(keyword));
version=0.0;
+ (void) version;
do
{
/*
for (p=comment; comment != (char *) NULL; p++)
{
c=ReadBlobByte(image);
- if ((c == EOF) || (c == (int) '}'))
- break;
+ if (c == (int) '\\')
+ c=ReadBlobByte(image);
+ else
+ if ((c == EOF) || (c == (int) '}'))
+ break;
if ((size_t) (p-comment+1) >= length)
{
*p='\0';
"MemoryAllocationFailed");
*p++=(char) c;
c=ReadBlobByte(image);
+ if (c == '\\')
+ {
+ c=ReadBlobByte(image);
+ if (c == (int) '}')
+ {
+ *p++=(char) c;
+ c=ReadBlobByte(image);
+ }
+ }
if (*options != '{')
if (isspace((int) ((unsigned char) c)) != 0)
break;
- }
- }
+ } }
*p='\0';
if (*options == '{')
- (void) CopyMagickString(options,options+1,MaxTextExtent);
+ (void) CopyMagickString(options,options+1,strlen(options));
/*
Assign a value to the specified keyword.
*/
switch (*keyword)
{
+ case 'a':
+ case 'A':
+ {
+ if (LocaleCompare(keyword,"alpha-trait") == 0)
+ {
+ ssize_t
+ alpha_trait;
+
+ alpha_trait=ParseCommandOption(MagickPixelTraitOptions,
+ MagickFalse,options);
+ if (alpha_trait < 0)
+ break;
+ image->alpha_trait=(PixelTrait) alpha_trait;
+ break;
+ }
+ (void) SetImageProperty(image,keyword,options,exception);
+ break;
+ }
case 'b':
case 'B':
{
MagickFalse,options);
if (colorspace < 0)
break;
- image->colorspace=(ColorspaceType) colorspace;
+ (void) SetImageColorspace(image,(ColorspaceType) colorspace, exception);
break;
}
if (LocaleCompare(keyword,"compression") == 0)
options);
if (matte < 0)
break;
- image->matte=(MagickBooleanType) matte;
+ image->alpha_trait=matte == 0 ? UndefinedPixelTrait :
+ BlendPixelTrait;
break;
}
if (LocaleCompare(keyword,"matte-color") == 0)
case 'o':
case 'O':
{
- if (LocaleCompare(keyword,"opaque") == 0)
- {
- ssize_t
- matte;
-
- matte=ParseCommandOption(MagickBooleanOptions,MagickFalse,
- options);
- if (matte < 0)
- break;
- image->matte=(MagickBooleanType) matte;
- break;
- }
if (LocaleCompare(keyword,"orientation") == 0)
{
ssize_t
{
flags=ParseGeometry(options,&geometry_info);
image->chromaticity.white_point.x=geometry_info.rho;
- image->chromaticity.white_point.y=geometry_info.rho;
- if ((flags & SigmaValue) != 0)
+ image->chromaticity.white_point.y=geometry_info.sigma;
+ if ((flags & SigmaValue) == 0)
image->chromaticity.white_point.y=
image->chromaticity.white_point.x;
break;
packet_size=(size_t) (quantum_info->depth/8);
if (image->storage_class == DirectClass)
packet_size=(size_t) (3*quantum_info->depth/8);
- if ((image->type == BilevelType) || (image->type == GrayscaleType) ||
- (image->type == GrayscaleMatteType))
+ if (IsGrayColorspace(image->colorspace) != MagickFalse)
packet_size=quantum_info->depth/8;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
packet_size+=quantum_info->depth/8;
if (image->colorspace == CMYKColorspace)
packet_size+=quantum_info->depth/8;
Read image pixels.
*/
quantum_type=RGBQuantum;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
quantum_type=RGBAQuantum;
if (image->colorspace == CMYKColorspace)
{
quantum_type=CMYKQuantum;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
quantum_type=CMYKAQuantum;
}
+ if (IsGrayColorspace(image->colorspace) != MagickFalse)
+ {
+ quantum_type=GrayQuantum;
+ if (image->alpha_trait == BlendPixelTrait)
+ quantum_type=GrayAlphaQuantum;
+ }
if (image->storage_class == PseudoClass)
{
quantum_type=IndexQuantum;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
quantum_type=IndexAlphaQuantum;
}
- if ((image->type == BilevelType) || (image->type == GrayscaleType) ||
- (image->type == GrayscaleMatteType))
- {
- quantum_type=GrayQuantum;
- if (image->matte != MagickFalse)
- quantum_type=GrayAlphaQuantum;
- }
status=MagickTrue;
switch (image->compression)
{
{
bzip_info.next_in=(char *) compress_pixels;
length=(size_t) BZipMaxExtent(packet_size*image->columns);
- if (version != 0)
+ if (version != 0.0)
length=(size_t) ReadBlobMSBLong(image);
bzip_info.avail_in=(unsigned int) ReadBlob(image,length,
(unsigned char *) bzip_info.next_in);
{
zip_info.next_in=compress_pixels;
length=(size_t) ZipMaxExtent(packet_size*image->columns);
- if (version != 0)
+ if (version != 0.0)
length=(size_t) ReadBlobMSBLong(image);
zip_info.avail_in=(unsigned int) ReadBlob(image,length,
zip_info.next_in);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,ClampToQuantum(pixel.black),q);
}
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
SetPixelAlpha(image,ClampToQuantum(pixel.alpha),q);
q+=GetPixelChannels(image);
}
int
code;
- if (version == 0)
+ if (version == 0.0)
{
MagickOffsetType
offset;
int
code;
- if (version == 0)
+ if (version == 0.0)
{
MagickOffsetType
offset;
unsigned int
value;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
value=ScaleQuantumToLong(ClampToQuantum(pixel->alpha));
pixels=PopLongPixel(MSBEndian,value,pixels);
unsigned short
value;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
value=ScaleQuantumToShort(ClampToQuantum(pixel->alpha));
pixels=PopShortPixel(MSBEndian,value,pixels);
unsigned char
value;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
value=(unsigned char) ScaleQuantumToChar(ClampToQuantum(
pixel->alpha));
value=ScaleQuantumToLong(ClampToQuantum(pixel->red));
pixels=PopLongPixel(MSBEndian,value,pixels);
- value=ScaleQuantumToLong(ClampToQuantum(pixel->green));
- pixels=PopLongPixel(MSBEndian,value,pixels);
- value=ScaleQuantumToLong(ClampToQuantum(pixel->blue));
- pixels=PopLongPixel(MSBEndian,value,pixels);
+ if (IsGrayColorspace(image->colorspace) == MagickFalse)
+ {
+ value=ScaleQuantumToLong(ClampToQuantum(pixel->green));
+ pixels=PopLongPixel(MSBEndian,value,pixels);
+ value=ScaleQuantumToLong(ClampToQuantum(pixel->blue));
+ pixels=PopLongPixel(MSBEndian,value,pixels);
+ }
if (image->colorspace == CMYKColorspace)
{
value=ScaleQuantumToLong(ClampToQuantum(pixel->black));
pixels=PopLongPixel(MSBEndian,value,pixels);
}
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
value=ScaleQuantumToLong(ClampToQuantum(pixel->alpha));
pixels=PopLongPixel(MSBEndian,value,pixels);
value=ScaleQuantumToShort(ClampToQuantum(pixel->red));
pixels=PopShortPixel(MSBEndian,value,pixels);
- value=ScaleQuantumToShort(ClampToQuantum(pixel->green));
- pixels=PopShortPixel(MSBEndian,value,pixels);
- value=ScaleQuantumToShort(ClampToQuantum(pixel->blue));
- pixels=PopShortPixel(MSBEndian,value,pixels);
+ if (IsGrayColorspace(image->colorspace) == MagickFalse)
+ {
+ value=ScaleQuantumToShort(ClampToQuantum(pixel->green));
+ pixels=PopShortPixel(MSBEndian,value,pixels);
+ value=ScaleQuantumToShort(ClampToQuantum(pixel->blue));
+ pixels=PopShortPixel(MSBEndian,value,pixels);
+ }
if (image->colorspace == CMYKColorspace)
{
value=ScaleQuantumToShort(ClampToQuantum(pixel->black));
pixels=PopShortPixel(MSBEndian,value,pixels);
}
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
value=ScaleQuantumToShort(ClampToQuantum(pixel->alpha));
pixels=PopShortPixel(MSBEndian,value,pixels);
value=(unsigned char) ScaleQuantumToChar(ClampToQuantum(pixel->red));
pixels=PopCharPixel(value,pixels);
- value=(unsigned char) ScaleQuantumToChar(ClampToQuantum(pixel->green));
- pixels=PopCharPixel(value,pixels);
- value=(unsigned char) ScaleQuantumToChar(ClampToQuantum(pixel->blue));
- pixels=PopCharPixel(value,pixels);
+ if (IsGrayColorspace(image->colorspace) == MagickFalse)
+ {
+ value=(unsigned char) ScaleQuantumToChar(ClampToQuantum(
+ pixel->green));
+ pixels=PopCharPixel(value,pixels);
+ value=(unsigned char) ScaleQuantumToChar(ClampToQuantum(pixel->blue));
+ pixels=PopCharPixel(value,pixels);
+ }
if (image->colorspace == CMYKColorspace)
{
value=(unsigned char) ScaleQuantumToChar(ClampToQuantum(
pixel->black));
pixels=PopCharPixel(value,pixels);
}
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
{
value=(unsigned char) ScaleQuantumToChar(ClampToQuantum(
pixel->alpha));
(image->colors > (size_t) (GetQuantumRange(image->depth)+1)))
(void) SetImageStorageClass(image,DirectClass,exception);
if (IsImageGray(image,exception) != MagickFalse)
- {
- (void) SetImageStorageClass(image,DirectClass,exception);
- (void) SetImageColorspace(image,GRAYColorspace,exception);
- }
+ (void) SetImageColorspace(image,GRAYColorspace,exception);
compression=image->compression;
if (image_info->compression != UndefinedCompression)
compression=image_info->compression;
packet_size=(size_t) (quantum_info->depth/8);
if (image->storage_class == DirectClass)
packet_size=(size_t) (3*quantum_info->depth/8);
- if (IsImageGray(image,exception) != MagickFalse)
+ if (IsGrayColorspace(image->colorspace) != MagickFalse)
packet_size=(size_t) (quantum_info->depth/8);
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
packet_size+=quantum_info->depth/8;
if (image->colorspace == CMYKColorspace)
packet_size+=quantum_info->depth/8;
*/
(void) WriteBlobString(image,"id=ImageMagick version=1.0\n");
(void) FormatLocaleString(buffer,MaxTextExtent,
- "class=%s colors=%.20g matte=%s\n",CommandOptionToMnemonic(
+ "class=%s colors=%.20g alpha-trait=%s\n",CommandOptionToMnemonic(
MagickClassOptions,image->storage_class),(double) image->colors,
- CommandOptionToMnemonic(MagickBooleanOptions,(ssize_t) image->matte));
+ CommandOptionToMnemonic(MagickPixelTraitOptions,(ssize_t)
+ image->alpha_trait));
(void) WriteBlobString(image,buffer);
(void) FormatLocaleString(buffer,MaxTextExtent,"columns=%.20g rows=%.20g "
"depth=%.20g\n",(double) image->columns,(double) image->rows,(double)
value=GetImageProperty(image,property,exception);
if (value != (const char *) NULL)
{
- for (i=0; i < (ssize_t) strlen(value); i++)
+ size_t
+ length;
+
+ length=strlen(value);
+ for (i=0; i < (ssize_t) length; i++)
if (isspace((int) ((unsigned char) value[i])) != 0)
break;
- if (i <= (ssize_t) strlen(value))
- (void) WriteBlobByte(image,'{');
- (void) WriteBlob(image,strlen(value),(const unsigned char *) value);
- if (i <= (ssize_t) strlen(value))
- (void) WriteBlobByte(image,'}');
+ if (i == (ssize_t) length)
+ (void) WriteBlob(image,length,(const unsigned char *) value);
+ else
+ {
+ (void) WriteBlobByte(image,'{');
+ if (strchr(value,'}') == (char *) NULL)
+ (void) WriteBlob(image,length,(const unsigned char *) value);
+ else
+ for (i=0; i < (ssize_t) length; i++)
+ {
+ if (value[i] == (int) '}')
+ (void) WriteBlobByte(image,'\\');
+ (void) WriteBlobByte(image,value[i]);
+ }
+ (void) WriteBlobByte(image,'}');
+ }
}
(void) WriteBlobByte(image,'\n');
property=GetNextImageProperty(image);