/*
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/colormap.h"
-#include "magick/colormap-private.h"
-#include "magick/color-private.h"
-#include "magick/colorspace.h"
-#include "magick/constitute.h"
-#include "magick/exception.h"
-#include "magick/histogram.h"
-#include "magick/image.h"
-#include "magick/list.h"
-#include "magick/magick.h"
-#include "magick/memory_.h"
-#include "magick/monitor.h"
-#include "magick/monitor-private.h"
-#include "magick/paint.h"
-#include "magick/pixel-private.h"
-#include "magick/property.h"
-#include "magick/quantize.h"
-#include "magick/quantum-private.h"
-#include "magick/static.h"
-#include "magick/string_.h"
-#include "magick/module.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/colormap.h"
+#include "MagickCore/colormap-private.h"
+#include "MagickCore/color-private.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/colorspace-private.h"
+#include "MagickCore/constitute.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/histogram.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/paint.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/property.h"
+#include "MagickCore/quantize.h"
+#include "MagickCore/quantum-private.h"
+#include "MagickCore/static.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/module.h"
+#include "MagickCore/utility.h"
\f
/*
Define declarations.
Forward declarations.
*/
static MagickBooleanType
- WritePALMImage(const ImageInfo *,Image *);
+ WritePALMImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FindColor() returns the index of the matching entry from PalmPalette for a
-% given PixelPacket.
+% given PixelInfo.
%
% The format of the FindColor method is:
%
-% int FindColor(PixelPacket *pixel)
+% int FindColor(const Image *image,PixelInfo *pixel)
%
% A description of each parameter follows:
%
% o int: the index of the matching color or -1 if not found/
%
-% o pixel: a pointer to the PixelPacket to be matched.
+% o pixel: a pointer to the PixelInfo to be matched.
%
*/
-static int FindColor(PixelPacket *pixel)
+static int FindColor(const Image *image,PixelInfo *packet)
{
register ssize_t
i;
for (i=0; i < 256; i++)
- if (ScaleQuantumToChar(GetRedPixelComponent(pixel) == PalmPalette[i][0] &&
- ScaleQuantumToChar(GetGreenPixelComponent(pixel) == PalmPalette[i][1] &&
- ScaleQuantumToChar(GetBluePixelComponent(pixel) == PalmPalette[i][2])
+ if (ScaleQuantumToChar(packet->red) == PalmPalette[i][0] &&
+ ScaleQuantumToChar(packet->green) == PalmPalette[i][1] &&
+ ScaleQuantumToChar(packet->blue) == PalmPalette[i][2])
return(i);
return(-1);
}
Image
*image;
- IndexPacket
- index;
-
MagickBooleanType
status;
totalOffset,
seekNextDepth;
- MagickPixelPacket
+ PixelInfo
transpix;
- register IndexPacket
- *indexes;
+ Quantum
+ index;
register ssize_t
i,
x;
- register PixelPacket
+ register Quantum
*q;
ssize_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)
{
*/
one=1;
if ((bits_per_pixel < 16) &&
- (AcquireImageColormap(image,one << bits_per_pixel) == MagickFalse))
+ (AcquireImageColormap(image,one << bits_per_pixel,exception) == MagickFalse))
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
- GetMagickPixelPacket(image,&transpix);
+ GetPixelInfo(image,&transpix);
if (bits_per_pixel == 16) /* Direct Color */
{
redbits=(size_t) ReadBlobByte(image); /* # of bits of red */
}
if (bits_per_pixel == 8)
{
- IndexPacket
+ Quantum
index;
if (flags & PALM_HAS_COLORMAP_FLAG)
for (i=0; i < (ssize_t) count; i++)
{
ReadBlobByte(image);
- index=ConstrainColormapIndex(image,255-i);
+ index=ConstrainColormapIndex(image,255-i,exception);
image->colormap[(int) index].red=
ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
image->colormap[(int) index].green=
{
for (i=0; i < (ssize_t) (1L << bits_per_pixel); i++)
{
- index=ConstrainColormapIndex(image,255-i);
+ index=ConstrainColormapIndex(image,255-i,exception);
image->colormap[(int) index].red=
ScaleCharToQuantum(PalmPalette[i][0]);
image->colormap[(int) index].green=
}
ptr=one_row;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
- indexes=GetAuthenticIndexQueue(image);
if (bits_per_pixel == 16)
{
if (image->columns > (2*bytes_per_row))
{
color16=(*ptr++ << 8);
color16|=(*ptr++);
- SetRedPixelComponent(q,(QuantumRange*((color16 >> 11) & 0x1f))/
- 0x1f);
- SetGreenPixelComponent(q,(QuantumRange*((color16 >> 5) & 0x3f))/
- 0x3f);
- SetBluePixelComponent(q,(QuantumRange*((color16 >> 0) & 0x1f))/
- 0x1f);
- SetOpacityPixelComponent(q,OpaqueOpacity);
- q++;
+ SetPixelRed(image,(QuantumRange*((color16 >> 11) & 0x1f))/0x1f,q);
+ SetPixelGreen(image,(QuantumRange*((color16 >> 5) & 0x3f))/0x3f,q);
+ SetPixelBlue(image,(QuantumRange*((color16 >> 0) & 0x1f))/0x1f,q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
}
}
else
{
if ((size_t) (ptr-one_row) >= bytes_per_row)
ThrowReaderException(CorruptImageError,"CorruptImage");
- index=(IndexPacket) (mask-(((*ptr) & (mask << bit)) >> bit));
- SetIndexPixelComponent(indexes+x,index);
- SetRedPixelComponent(q,image->colormap[(ssize_t) index].red);
- SetGreenPixelComponent(q,image->colormap[(ssize_t) index].green);
- SetBluePixelComponent(q,image->colormap[(ssize_t) index].blue);
+ index=(Quantum) (mask-(((*ptr) & (mask << bit)) >> bit));
+ SetPixelIndex(image,index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
if (bit)
bit-=bits_per_pixel;
else
ptr++;
bit=8-bits_per_pixel;
}
- q++;
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (flags & PALM_HAS_TRANSPARENCY_FLAG)
{
if (bits_per_pixel != 16)
- SetMagickPixelPacket(image,image->colormap+(mask-transparentIndex),
- (const IndexPacket *) NULL,&transpix);
- (void) TransparentPaintImage(image,&transpix,(Quantum)
- TransparentOpacity,MagickFalse);
+ transpix=image->colormap[mask-transparentIndex];
+ (void) TransparentPaintImage(image,&transpix,(Quantum) TransparentAlpha,
+ MagickFalse,exception);
}
one_row=(unsigned char *) RelinquishMagickMemory(one_row);
if (compressionType == PALM_COMPRESSION_SCANLINE)
- lastrow=(unsigned char *) RelinquishMagickMemory(lastrow);
+ lastrow=(unsigned char *) RelinquishMagickMemory(lastrow);
/*
Proceed to next image. Copied from coders/pnm.c
*/
/*
Allocate next image structure. Copied from coders/pnm.c
*/
- AcquireNextImage(image_info,image);
+ AcquireNextImage(image_info,image,exception);
if (GetNextImageInList(image) == (Image *) NULL)
{
(void) DestroyImageList(image);
% The format of the WritePALMImage method is:
%
% MagickBooleanType WritePALMImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: A pointer to a Image structure.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
int
y;
- ExceptionInfo
- exception;
-
MagickBooleanType
status;
MagickSizeType
cc;
- PixelPacket
+ PixelInfo
transpix;
QuantizeInfo
*quantize_info;
- register IndexPacket
- *indexes;
-
register ssize_t
x;
- register PixelPacket
+ register const Quantum
*p;
+ register Quantum
+ *q;
+
size_t
count,
bits_per_pixel,
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&exception);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
- GetExceptionInfo(&exception);
quantize_info=AcquireQuantizeInfo(image_info);
flags=0;
currentOffset=0;
transpix.red=0;
transpix.green=0;
transpix.blue=0;
- transpix.opacity=0;
+ transpix.alpha=0;
one=1;
version=0;
scene=0;
do
{
- if (image->colorspace != RGBColorspace)
- (void) TransformImageColorspace(image,RGBColorspace);
- count=GetNumberColors(image,NULL,&exception);
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ count=GetNumberColors(image,NULL,exception);
for (bits_per_pixel=1; (one << bits_per_pixel) < count; bits_per_pixel*=2) ;
if (image_info->depth > 100)
bits_per_pixel=image_info->depth-100;
if (bits_per_pixel < 16)
- (void) TransformImageColorspace(image,image->colorspace);
+ (void) TransformImageColorspace(image,image->colorspace,exception);
if (bits_per_pixel < 8)
{
- (void) TransformImageColorspace(image,GRAYColorspace);
- (void) SetImageType(image,PaletteType);
- (void) SortColormapByIntensity(image);
+ (void) TransformImageColorspace(image,GRAYColorspace,exception);
+ (void) SetImageType(image,PaletteType,exception);
+ (void) SortColormapByIntensity(image,exception);
}
if ((image->storage_class == PseudoClass) && (image->colors > 256))
- (void) SetImageStorageClass(image,DirectClass);
+ (void) SetImageStorageClass(image,DirectClass,exception);
if (image->storage_class == PseudoClass)
flags|=PALM_HAS_COLORMAP_FLAG;
else
{
if (flags & PALM_HAS_COLORMAP_FLAG) /* Write out colormap */
{
- quantize_info->dither=IsPaletteImage(image,&image->exception);
+ quantize_info->dither_method=IsPaletteImage(image,exception)
+ == MagickFalse ? RiemersmaDitherMethod : NoDitherMethod;
quantize_info->number_colors=image->colors;
- (void) QuantizeImage(quantize_info,image);
+ (void) QuantizeImage(quantize_info,image,exception);
(void) WriteBlobMSBShort(image,(unsigned short) image->colors);
for (count = 0; count < image->colors; count++)
{
*affinity_image;
affinity_image=ConstituteImage(256,1,"RGB",CharPixel,&PalmPalette,
- &exception);
+ exception);
(void) TransformImageColorspace(affinity_image,
- affinity_image->colorspace);
- (void) RemapImage(quantize_info,image,affinity_image);
+ affinity_image->colorspace,exception);
+ (void) RemapImage(quantize_info,image,affinity_image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetAuthenticPixels(image,0,y,image->columns,1,&exception);
- indexes=GetAuthenticIndexQueue(image);
+ q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
for (x=0; x < (ssize_t) image->columns; x++)
- SetIndexPixelComponent(indexes+x,FindColor(&image->colormap[
- (ssize_t) GetIndexPixelComponent(indexes+x)]));
+ {
+ SetPixelIndex(image,FindColor(image,&image->colormap[(ssize_t)
+ GetPixelIndex(image,q)]),q);
+ q+=GetPixelChannels(image);
+ }
}
affinity_image=DestroyImage(affinity_image);
}
{
ptr=one_row;
(void) ResetMagickMemory(ptr,0,bytes_per_row);
- p=GetAuthenticPixels(image,0,y,image->columns,1,&exception);
- if (p == (PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetAuthenticIndexQueue(image);
if (bits_per_pixel == 16)
{
for (x=0; x < (int) image->columns; x++)
{
- color16=(unsigned short) ((((31*(size_t) GetRedPixelComponent(p))/
- (size_t) QuantumRange) << 11) |
- (((63*(size_t) GetGreenPixelComponent(p))/(size_t) QuantumRange) << 5) |
- ((31*(size_t) GetBluePixelComponent(p))/(size_t) QuantumRange));
- if (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity)
+ color16=(unsigned short) ((((31*(size_t) GetPixelRed(image,p))/
+ (size_t) QuantumRange) << 11) | (((63*(size_t)
+ GetPixelGreen(image,p))/(size_t) QuantumRange) << 5) |
+ ((31*(size_t) GetPixelBlue(image,p))/(size_t) QuantumRange));
+ if (GetPixelAlpha(image,p) == (Quantum) TransparentAlpha)
{
- transpix.red=GetRedPixelComponent(p);
- transpix.green=GetGreenPixelComponent(p);
- transpix.blue=GetBluePixelComponent(p);
- transpix.opacity=GetOpacityPixelComponent(p);
+ transpix.red=GetPixelRed(image,p);
+ transpix.green=GetPixelGreen(image,p);
+ transpix.blue=GetPixelBlue(image,p);
+ transpix.alpha=GetPixelAlpha(image,p);
flags|=PALM_HAS_TRANSPARENCY_FLAG;
}
*ptr++=(unsigned char) ((color16 >> 8) & 0xff);
*ptr++=(unsigned char) (color16 & 0xff);
- p++;
+ p+=GetPixelChannels(image);
}
}
else
for (x=0; x < (int) image->columns; x++)
{
if (bits_per_pixel >= 8)
- color=(unsigned char) GetIndexPixelComponent(indexes+x);
+ color=(unsigned char) GetPixelIndex(image,p);
else
- color=(unsigned char) (GetIndexPixelComponent(indexes+x)*
+ color=(unsigned char) (GetPixelIndex(image,p)*
((one << bits_per_pixel)-1)/MagickMax(1*image->colors-1,1));
byte|=color << bit;
if (bit != 0)
byte=0x00;
bit=(unsigned char) (8-bits_per_pixel);
}
+ p+=GetPixelChannels(image);
}
if ((image->columns % (8/bits_per_pixel)) != 0)
*ptr++=byte;
} while (image_info->adjoin != MagickFalse);
quantize_info=DestroyQuantizeInfo(quantize_info);
(void) CloseBlob(image);
- (void) DestroyExceptionInfo(&exception);
return(MagickTrue);
}
projects / imagemagick / blobdiff