% July 1992 %
% %
% %
-% Copyright 1999-2011 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 declarations.
*/
-#include "magick/studio.h"
-#include "magick/blob.h"
-#include "magick/blob-private.h"
-#include "magick/cache.h"
-#include "magick/color.h"
-#include "magick/color-private.h"
-#include "magick/colormap.h"
-#include "magick/colorspace.h"
-#include "magick/exception.h"
-#include "magick/exception-private.h"
-#include "magick/geometry.h"
-#include "magick/image.h"
-#include "magick/image-private.h"
-#include "magick/list.h"
-#include "magick/magick.h"
-#include "magick/memory_.h"
-#include "magick/monitor.h"
-#include "magick/monitor-private.h"
-#include "magick/pixel-private.h"
-#include "magick/quantize.h"
-#include "magick/quantum-private.h"
-#include "magick/resize.h"
-#include "magick/resource_.h"
-#include "magick/splay-tree.h"
-#include "magick/static.h"
-#include "magick/string_.h"
-#include "magick/module.h"
-#include "magick/threshold.h"
-#include "magick/utility.h"
+#include "MagickCore/studio.h"
+#include "MagickCore/attribute.h"
+#include "MagickCore/blob.h"
+#include "MagickCore/blob-private.h"
+#include "MagickCore/cache.h"
+#include "MagickCore/color.h"
+#include "MagickCore/color-private.h"
+#include "MagickCore/colormap.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/colorspace-private.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/exception-private.h"
+#include "MagickCore/geometry.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-private.h"
+#include "MagickCore/list.h"
+#include "MagickCore/magick.h"
+#include "MagickCore/memory_.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/monitor-private.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/quantize.h"
+#include "MagickCore/quantum-private.h"
+#include "MagickCore/resize.h"
+#include "MagickCore/resource_.h"
+#include "MagickCore/splay-tree.h"
+#include "MagickCore/static.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/module.h"
+#include "MagickCore/threshold.h"
+#include "MagickCore/utility.h"
\f
/*
Forward declarations.
*/
static MagickBooleanType
- WritePICONImage(const ImageInfo *,Image *),
- WriteXPMImage(const ImageInfo *,Image *);
+ WritePICONImage(const ImageInfo *,Image *,ExceptionInfo *),
+ WriteXPMImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
*q,
*next;
- register IndexPacket
- *indexes;
-
register ssize_t
x;
- register PixelPacket
+ register Quantum
*r;
size_t
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- image=AcquireImage(image_info);
+ image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
if ((count != 4) || (width > 10) || (image->columns == 0) ||
(image->rows == 0) || (image->colors == 0))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
- image->depth=16;
/*
Remove unquoted characters.
*/
*/
xpm_colors=NewSplayTree(CompareXPMColor,RelinquishMagickMemory,
(void *(*)(void *)) NULL);
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Read image colormap.
*/
+ image->depth=1;
next=NextXPMLine(xpm_buffer);
for (j=0; (j < (ssize_t) image->colors) && (next != (char*) NULL); j++)
{
if (LocaleCompare(target,"none") == 0)
{
image->storage_class=DirectClass;
- image->matte=MagickTrue;
+ image->alpha_trait=BlendPixelTrait;
}
- status=QueryColorCompliance(target,AllCompliance,&image->colormap[j],
+ status=QueryColorCompliance(target,XPMCompliance,&image->colormap[j],
exception);
if (status == MagickFalse)
break;
+ if (image->depth < image->colormap[j].depth)
+ image->depth=image->colormap[j].depth;
}
if (j < (ssize_t) image->colors)
ThrowReaderException(CorruptImageError,"CorruptImage");
if (p == (char *) NULL)
break;
r=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (r == (PixelPacket *) NULL)
+ if (r == (Quantum *) NULL)
break;
- indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
(void) CopyXPMColor(key,p,(size_t) width);
j=(ssize_t) GetValueFromSplayTree(xpm_colors,key);
if (image->storage_class == PseudoClass)
- SetIndexPixelComponent(indexes+x,j);
- *r=image->colormap[j];
- r++;
+ SetPixelIndex(image,j,r);
+ SetPixelInfoPixel(image,image->colormap+j,r);
p+=width;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
% The format of the WritePICONImage method is:
%
% MagickBooleanType WritePICONImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WritePICONImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
#define ColormapExtent 155
#define GraymapExtent 95
name[MaxTextExtent],
symbol[MaxTextExtent];
- ExceptionInfo
- *exception;
-
Image
*affinity_image,
*picon;
status,
transparent;
- MagickPixelPacket
+ PixelInfo
pixel;
QuantizeInfo
RectangleInfo
geometry;
- register const IndexPacket
- *indexes;
-
- register const PixelPacket
+ register const Quantum
*p;
register ssize_t
i,
x;
- register PixelPacket
+ register Quantum
*q;
size_t
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
- if (image->colorspace != RGBColorspace)
- (void) TransformImageColorspace(image,RGBColorspace);
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
SetGeometry(image,&geometry);
(void) ParseMetaGeometry(PiconGeometry,&geometry.x,&geometry.y,
&geometry.width,&geometry.height);
- picon=ResizeImage(image,geometry.width,geometry.height,TriangleFilter,1.0,
- &image->exception);
+ picon=ResizeImage(image,geometry.width,geometry.height,TriangleFilter,
+ exception);
blob_info=CloneImageInfo(image_info);
(void) AcquireUniqueFilename(blob_info->filename);
if ((image_info->type != TrueColorType) &&
- (IsGrayImage(image,&image->exception) != MagickFalse))
- affinity_image=BlobToImage(blob_info,Graymap,GraymapExtent,
- &image->exception);
+ (IsImageGray(image,exception) != MagickFalse))
+ affinity_image=BlobToImage(blob_info,Graymap,GraymapExtent,exception);
else
- affinity_image=BlobToImage(blob_info,Colormap,ColormapExtent,
- &image->exception);
+ affinity_image=BlobToImage(blob_info,Colormap,ColormapExtent,exception);
(void) RelinquishUniqueFileResource(blob_info->filename);
blob_info=DestroyImageInfo(blob_info);
if ((picon == (Image *) NULL) || (affinity_image == (Image *) NULL))
return(MagickFalse);
quantize_info=AcquireQuantizeInfo(image_info);
- status=RemapImage(quantize_info,picon,affinity_image);
+ status=RemapImage(quantize_info,picon,affinity_image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
affinity_image=DestroyImage(affinity_image);
transparent=MagickFalse;
- exception=(&image->exception);
if (picon->storage_class == PseudoClass)
{
- (void) CompressImageColormap(picon);
- if (picon->matte != MagickFalse)
+ (void) CompressImageColormap(picon,exception);
+ if (picon->alpha_trait == BlendPixelTrait)
transparent=MagickTrue;
}
else
/*
Convert DirectClass to PseudoClass picon.
*/
- if (picon->matte != MagickFalse)
+ if (picon->alpha_trait == BlendPixelTrait)
{
/*
Map all the transparent pixels.
for (y=0; y < (ssize_t) picon->rows; y++)
{
q=GetAuthenticPixels(picon,0,y,picon->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) picon->columns; x++)
{
- if (q->opacity == (Quantum) TransparentOpacity)
+ if (GetPixelAlpha(image,q) == (Quantum) TransparentAlpha)
transparent=MagickTrue;
else
- SetOpacityPixelComponent(q,OpaqueOpacity);
- q++;
+ SetPixelAlpha(picon,OpaqueAlpha,q);
+ q+=GetPixelChannels(picon);
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
break;
}
}
- (void) SetImageType(picon,PaletteType);
+ (void) SetImageType(picon,PaletteType,exception);
}
colors=picon->colors;
if (transparent != MagickFalse)
{
- register IndexPacket
- *indexes;
-
colors++;
- picon->colormap=(PixelPacket *) ResizeQuantumMemory((void **)
+ picon->colormap=(PixelInfo *) ResizeQuantumMemory((void **)
picon->colormap,(size_t) colors,sizeof(*picon->colormap));
- if (picon->colormap == (PixelPacket *) NULL)
+ if (picon->colormap == (PixelInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationError");
for (y=0; y < (ssize_t) picon->rows; y++)
{
q=GetAuthenticPixels(picon,0,y,picon->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
- indexes=GetAuthenticIndexQueue(picon);
for (x=0; x < (ssize_t) picon->columns; x++)
{
- if (q->opacity == (Quantum) TransparentOpacity)
- SetIndexPixelComponent(indexes+x,picon->colors);
- q++;
+ if (GetPixelAlpha(image,q) == (Quantum) TransparentAlpha)
+ SetPixelIndex(picon,picon->colors,q);
+ q+=GetPixelChannels(picon);
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
break;
"\"%.20g %.20g %.20g %.20g\",\n",(double) picon->columns,(double)
picon->rows,(double) colors,(double) characters_per_pixel);
(void) WriteBlobString(image,buffer);
- GetMagickPixelPacket(image,&pixel);
+ GetPixelInfo(image,&pixel);
for (i=0; i < (ssize_t) colors; i++)
{
/*
Define XPM color.
*/
- SetMagickPixelPacket(image,picon->colormap+i,(IndexPacket *) NULL,&pixel);
- pixel.colorspace=RGBColorspace;
+ pixel=picon->colormap[i];
+ pixel.colorspace=sRGBColorspace;
pixel.depth=8;
- pixel.opacity=(MagickRealType) OpaqueOpacity;
- (void) QueryMagickColorname(image,&pixel,XPMCompliance,name,
- &image->exception);
+ pixel.alpha=(double) OpaqueAlpha;
+ (void) QueryColorname(image,&pixel,XPMCompliance,name,exception);
if (transparent != MagickFalse)
{
if (i == (ssize_t) (colors-1))
(void) WriteBlobString(image,"/* pixels */\n");
for (y=0; y < (ssize_t) picon->rows; y++)
{
- p=GetVirtualPixels(picon,0,y,picon->columns,1,&picon->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(picon,0,y,picon->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetVirtualIndexQueue(picon);
(void) WriteBlobString(image,"\"");
for (x=0; x < (ssize_t) picon->columns; x++)
{
- k=((ssize_t) GetIndexPixelComponent(indexes+x) % MaxCixels);
+ k=((ssize_t) GetPixelIndex(picon,p) % MaxCixels);
symbol[0]=Cixel[k];
for (j=1; j < (ssize_t) characters_per_pixel; j++)
{
- k=(((int) GetIndexPixelComponent(indexes+x)-k)/MaxCixels) % MaxCixels;
+ k=(((int) GetPixelIndex(picon,p)-k)/MaxCixels) % MaxCixels;
symbol[j]=Cixel[k];
}
symbol[j]='\0';
(void) CopyMagickString(buffer,symbol,MaxTextExtent);
(void) WriteBlobString(image,buffer);
+ p+=GetPixelChannels(image);
}
(void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
y == (ssize_t) (picon->rows-1) ? "" : ",");
%
% The format of the WriteXPMImage method is:
%
-% MagickBooleanType WriteXPMImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteXPMImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteXPMImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteXPMImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
#define MaxCixels 92
MagickBooleanType
status;
- MagickPixelPacket
+ PixelInfo
pixel;
- register const IndexPacket
- *indexes;
-
- register const PixelPacket
+ register const Quantum
*p;
register ssize_t
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
- if (image->colorspace != RGBColorspace)
- (void) TransformImageColorspace(image,RGBColorspace);
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
opacity=(-1);
- if (image->matte == MagickFalse)
+ if (image->alpha_trait != BlendPixelTrait)
{
if ((image->storage_class == DirectClass) || (image->colors > 256))
- (void) SetImageType(image,PaletteType);
+ (void) SetImageType(image,PaletteType,exception);
}
else
{
- MagickRealType
+ double
alpha,
beta;
Identify transparent colormap index.
*/
if ((image->storage_class == DirectClass) || (image->colors > 256))
- (void) SetImageType(image,PaletteBilevelMatteType);
+ (void) SetImageType(image,PaletteBilevelMatteType,exception);
for (i=0; i < (ssize_t) image->colors; i++)
- if (image->colormap[i].opacity != OpaqueOpacity)
+ if (image->colormap[i].alpha != OpaqueAlpha)
{
if (opacity < 0)
{
opacity=i;
continue;
}
- alpha=(Quantum) TransparentOpacity-(MagickRealType)
- image->colormap[i].opacity;
- beta=(Quantum) TransparentOpacity-(MagickRealType)
- image->colormap[opacity].opacity;
+ alpha=(double) TransparentAlpha-(double)
+ image->colormap[i].alpha;
+ beta=(double) TransparentAlpha-(double)
+ image->colormap[opacity].alpha;
if (alpha < beta)
opacity=i;
}
if (opacity == -1)
{
- (void) SetImageType(image,PaletteBilevelMatteType);
+ (void) SetImageType(image,PaletteBilevelMatteType,exception);
for (i=0; i < (ssize_t) image->colors; i++)
- if (image->colormap[i].opacity != OpaqueOpacity)
+ if (image->colormap[i].alpha != OpaqueAlpha)
{
if (opacity < 0)
{
opacity=i;
continue;
}
- alpha=(Quantum) TransparentOpacity-(MagickRealType)
- image->colormap[i].opacity;
- beta=(Quantum) TransparentOpacity-(MagickRealType)
- image->colormap[opacity].opacity;
+ alpha=(Quantum) TransparentAlpha-(double)
+ image->colormap[i].alpha;
+ beta=(Quantum) TransparentAlpha-(double)
+ image->colormap[opacity].alpha;
if (alpha < beta)
opacity=i;
}
"\"%.20g %.20g %.20g %.20g \",\n",(double) image->columns,(double)
image->rows,(double) image->colors,(double) characters_per_pixel);
(void) WriteBlobString(image,buffer);
- GetMagickPixelPacket(image,&pixel);
+ GetPixelInfo(image,&pixel);
for (i=0; i < (ssize_t) image->colors; i++)
{
/*
Define XPM color.
*/
- SetMagickPixelPacket(image,image->colormap+i,(IndexPacket *) NULL,&pixel);
- pixel.colorspace=RGBColorspace;
+ pixel=image->colormap[i];
+ pixel.colorspace=sRGBColorspace;
pixel.depth=8;
- pixel.opacity=(MagickRealType) OpaqueOpacity;
- (void) QueryMagickColorname(image,&pixel,XPMCompliance,name,
- &image->exception);
+ pixel.alpha=(double) OpaqueAlpha;
+ (void) QueryColorname(image,&pixel,XPMCompliance,name,exception);
if (i == opacity)
(void) CopyMagickString(name,"None",MaxTextExtent);
/*
(void) WriteBlobString(image,"/* pixels */\n");
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetVirtualIndexQueue(image);
(void) WriteBlobString(image,"\"");
for (x=0; x < (ssize_t) image->columns; x++)
{
- k=((ssize_t) GetIndexPixelComponent(indexes+x) % MaxCixels);
+ k=((ssize_t) GetPixelIndex(image,p) % MaxCixels);
symbol[0]=Cixel[k];
for (j=1; j < (ssize_t) characters_per_pixel; j++)
{
- k=(((int) GetIndexPixelComponent(indexes+x)-k)/MaxCixels) % MaxCixels;
+ k=(((int) GetPixelIndex(image,p)-k)/MaxCixels) % MaxCixels;
symbol[j]=Cixel[k];
}
symbol[j]='\0';
(void) CopyMagickString(buffer,symbol,MaxTextExtent);
(void) WriteBlobString(image,buffer);
+ p+=GetPixelChannels(image);
}
(void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
(y == (ssize_t) (image->rows-1) ? "" : ","));