% July 1992 %
% %
% %
-% Copyright 1999-2010 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
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
*/
static int CompareXPMColor(const void *target,const void *source)
-{
+{
const char
*p,
*q;
-
+
p=(const char *) target;
q=(const char *) source;
return(strcmp(p,q));
Image
*image;
- ssize_t
- j,
- y;
-
MagickBooleanType
active,
status;
*q,
*next;
- register IndexPacket
- *indexes;
-
register ssize_t
- i,
x;
- register PixelPacket
+ register Quantum
*r;
size_t
*xpm_colors;
ssize_t
- count;
+ count,
+ j,
+ y;
unsigned long
colors,
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.
*/
- i=0;
active=MagickFalse;
q=xpm_buffer;
while (*p != '\0')
*/
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.
*/
- i=1;
+ 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,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)
- indexes[x]=(IndexPacket) 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;
ImageInfo
*blob_info;
- ssize_t
- j,
- k,
- y;
-
MagickBooleanType
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
characters_per_pixel,
colors;
+ ssize_t
+ j,
+ k,
+ y;
+
/*
Open output image file.
*/
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)
- indexes[x]=(IndexPacket) picon->colors;
- q++;
+ if (GetPixelAlpha(image,q) == (Quantum) TransparentAlpha)
+ SetPixelIndex(picon,picon->colors,q);
+ q+=GetPixelChannels(picon);
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
break;
*/
(void) WriteBlobString(image,"/* XPM */\n");
GetPathComponent(picon->filename,BasePath,basename);
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"static char *%s[] = {\n",basename);
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"/* columns rows colors chars-per-pixel */\n");
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"\"%.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))
symbol[j]=Cixel[k];
}
symbol[j]='\0';
- (void) FormatMagickString(buffer,MaxTextExtent,"\"%s c %s\",\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"\"%s c %s\",\n",
symbol,name);
(void) WriteBlobString(image,buffer);
}
(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) 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) 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) FormatMagickString(buffer,MaxTextExtent,"\"%s\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
y == (ssize_t) (picon->rows-1) ? "" : ",");
(void) WriteBlobString(image,buffer);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
%
% 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
name[MaxTextExtent],
symbol[MaxTextExtent];
- ssize_t
- j,
- k,
- opacity,
- y;
-
MagickBooleanType
status;
- MagickPixelPacket
+ PixelInfo
pixel;
- register const IndexPacket
- *indexes;
-
- register const PixelPacket
+ register const Quantum
*p;
register ssize_t
size_t
characters_per_pixel;
+ ssize_t
+ j,
+ k,
+ opacity,
+ y;
+
/*
Open output image file.
*/
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;
}
GetPathComponent(image->filename,BasePath,basename);
if (isalnum((int) ((unsigned char) *basename)) == 0)
{
- (void) FormatMagickString(buffer,MaxTextExtent,"xpm_%s",basename);
+ (void) FormatLocaleString(buffer,MaxTextExtent,"xpm_%s",basename);
(void) CopyMagickString(basename,buffer,MaxTextExtent);
}
- for (i=0; basename[i] != '\0'; i++)
- if (isalpha((int) ((unsigned char) basename[i])) == 0)
+ if (isalpha((int) ((unsigned char) basename[0])) == 0)
+ basename[0]='_';
+ for (i=1; basename[i] != '\0'; i++)
+ if (isalnum((int) ((unsigned char) basename[i])) == 0)
basename[i]='_';
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"static char *%s[] = {\n",basename);
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"/* columns rows colors chars-per-pixel */\n");
- (void) FormatMagickString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MaxTextExtent,
"\"%.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);
/*
symbol[j]=Cixel[k];
}
symbol[j]='\0';
- (void) FormatMagickString(buffer,MaxTextExtent,"\"%s c %s\",\n",symbol,
+ (void) FormatLocaleString(buffer,MaxTextExtent,"\"%s c %s\",\n",symbol,
name);
(void) WriteBlobString(image,buffer);
}
(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) 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) 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) FormatMagickString(buffer,MaxTextExtent,"\"%s\n",
+ (void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
(y == (ssize_t) (image->rows-1) ? "" : ","));
(void) WriteBlobString(image,buffer);
if (image->previous == (Image *) NULL)
projects / imagemagick / blobdiff