% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
-% obtain a copy of the License at %
+% obtain a copy of the License at %
% %
% http://www.imagemagick.org/script/license.php %
% %
/*
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/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/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.
%
% The format of the FindColor method is:
%
-% int FindColor(PixelPacket *pixel)
+% int FindColor(const Image *image,PixelPacket *pixel)
%
% A description of each parameter follows:
%
% o pixel: a pointer to the PixelPacket to be matched.
%
*/
-static int FindColor(PixelPacket *pixel)
+static int FindColor(const Image *image,PixelPacket *packet)
{
- register long
+ register ssize_t
i;
for (i=0; i < 256; i++)
- if (ScaleQuantumToChar(pixel->red) == PalmPalette[i][0] &&
- ScaleQuantumToChar(pixel->green) == PalmPalette[i][1] &&
- ScaleQuantumToChar(pixel->blue) == 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);
}
%
*/
-static inline long MagickMax(const long x,const long y)
+static inline size_t MagickMax(const size_t x,const size_t y)
{
if (x > y)
return(x);
Image
*image;
- IndexPacket
- index;
-
- long
- y;
-
MagickBooleanType
status;
- MagickPixelPacket
+ MagickOffsetType
+ totalOffset,
+ seekNextDepth;
+
+ PixelInfo
transpix;
- register IndexPacket
- *indexes;
+ Quantum
+ index;
- register long
+ register ssize_t
i,
x;
- register PixelPacket
+ register Quantum
*q;
ssize_t
- count;
-
- unsigned char
- *lastrow,
- *one_row,
- *ptr;
+ count,
+ y;
- unsigned long
+ size_t
bytes_per_row,
flags,
bits_per_pixel,
redbits,
greenbits,
bluebits,
+ one,
pad,
size,
bit;
+ unsigned char
+ *lastrow,
+ *one_row,
+ *ptr;
+
unsigned short
color16;
- MagickOffsetType
- totalOffset,
- seekNextDepth;
-
/*
Open image file.
*/
image->rows=ReadBlobMSBShort(image);
if (EOFBlob(image) != MagickFalse)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
- /*
- Copied from coders/pnm.c. TODO other checks ...
- */
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");
bytes_per_row=ReadBlobMSBShort(image);
flags=ReadBlobMSBShort(image);
- bits_per_pixel=(unsigned long) ReadBlobByte(image);
+ bits_per_pixel=(size_t) ReadBlobByte(image);
if (bits_per_pixel > 16)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
- version=(unsigned long) ReadBlobByte(image);
- nextDepthOffset=(unsigned long) ReadBlobMSBShort(image);
- transparentIndex=(unsigned long) ReadBlobByte(image);
- compressionType=(unsigned long) ReadBlobByte(image);
+ version=(size_t) ReadBlobByte(image);
+ (void) version;
+ nextDepthOffset=(size_t) ReadBlobMSBShort(image);
+ transparentIndex=(size_t) ReadBlobByte(image);
+ compressionType=(size_t) ReadBlobByte(image);
pad=ReadBlobMSBShort(image);
+ (void) pad;
/*
Initialize image colormap.
*/
+ one=1;
if ((bits_per_pixel < 16) &&
- (AcquireImageColormap(image,1L << bits_per_pixel) == MagickFalse))
+ (AcquireImageColormap(image,one << bits_per_pixel) == MagickFalse))
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
- GetMagickPixelPacket(image,&transpix);
+ GetPixelInfo(image,&transpix);
if (bits_per_pixel == 16) /* Direct Color */
{
- redbits=(unsigned long) ReadBlobByte(image); /* # of bits of red */
- greenbits=(unsigned long) ReadBlobByte(image); /* # of bits of green */
- bluebits=(unsigned long) ReadBlobByte(image); /* # of bits of blue */
+ redbits=(size_t) ReadBlobByte(image); /* # of bits of red */
+ (void) redbits;
+ greenbits=(size_t) ReadBlobByte(image); /* # of bits of green */
+ (void) greenbits;
+ bluebits=(size_t) ReadBlobByte(image); /* # of bits of blue */
+ (void) bluebits;
ReadBlobByte(image); /* reserved by Palm */
ReadBlobByte(image); /* reserved by Palm */
transpix.red=(MagickRealType) (QuantumRange*ReadBlobByte(image)/31);
}
if (bits_per_pixel == 8)
{
- IndexPacket
+ Quantum
index;
if (flags & PALM_HAS_COLORMAP_FLAG)
{
count=(ssize_t) ReadBlobMSBShort(image);
- for (i=0; i < (long) count; i++)
+ for (i=0; i < (ssize_t) count; i++)
{
ReadBlobByte(image);
index=ConstrainColormapIndex(image,255-i);
}
else
{
- for (i=0; i < (long) (1L << bits_per_pixel); i++)
+ for (i=0; i < (ssize_t) (1L << bits_per_pixel); i++)
{
index=ConstrainColormapIndex(image,255-i);
image->colormap[(int) index].red=
}
if (flags & PALM_IS_COMPRESSED_FLAG)
size=ReadBlobMSBShort(image);
+ (void) size;
image->storage_class=DirectClass;
if (bits_per_pixel < 16)
{
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
mask=(1l << bits_per_pixel)-1;
- for (y = 0; y < (long) image->rows; y++)
+ for (y = 0; y < (ssize_t) image->rows; y++)
{
if ((flags & PALM_IS_COMPRESSED_FLAG) == 0)
{
{
/* TODO move out of loop! */
image->compression=RLECompression;
- for (i=0; i < (long) bytes_per_row; )
+ for (i=0; i < (ssize_t) bytes_per_row; )
{
count=(ssize_t) ReadBlobByte(image);
count=MagickMin(count,(ssize_t) bytes_per_row-i);
- byte=(unsigned long) ReadBlobByte(image);
+ byte=(size_t) ReadBlobByte(image);
(void) ResetMagickMemory(one_row+i,(int) byte,(size_t) count);
i+=count;
}
}
else
if (compressionType == PALM_COMPRESSION_SCANLINE)
- {
+ {
+ size_t
+ one;
+
/* TODO move out of loop! */
+ one=1;
image->compression=FaxCompression;
- for (i=0; i < (long) bytes_per_row; i+=8)
+ for (i=0; i < (ssize_t) bytes_per_row; i+=8)
{
count=(ssize_t) ReadBlobByte(image);
byte=1UL*MagickMin((ssize_t) bytes_per_row-i,8);
for (bit=0; bit < byte; bit++)
{
- if ((y == 0) || (count & (1 << (7 - bit))))
+ if ((y == 0) || (count & (one << (7 - bit))))
one_row[i+bit]=(unsigned char) ReadBlobByte(image);
else
one_row[i+bit]=lastrow[i+bit];
}
ptr=one_row;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (const Quantum *) NULL)
break;
- indexes=GetAuthenticIndexQueue(image);
if (bits_per_pixel == 16)
{
if (image->columns > (2*bytes_per_row))
ThrowReaderException(CorruptImageError,"CorruptImage");
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
color16=(*ptr++ << 8);
color16|=(*ptr++);
- q->red=(Quantum) ((QuantumRange*((color16 >> 11) & 0x1f))/0x1f);
- q->green=(Quantum) ((QuantumRange*((color16 >> 5) & 0x3f))/0x3f);
- q->blue=(Quantum) ((QuantumRange*((color16 >> 0) & 0x1f))/0x1f);
- q->opacity=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
{
bit=8-bits_per_pixel;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if ((size_t) (ptr-one_row) >= bytes_per_row)
ThrowReaderException(CorruptImageError,"CorruptImage");
- index=(IndexPacket) (mask-(((*ptr) & (mask << bit)) >> bit));
- indexes[x]=index;
- *q++=image->colormap[(long) index];
+ index=(Quantum) (mask-(((*ptr) & (mask << bit)) >> bit));
+ SetPixelIndex(image,index,q);
+ SetPixelPacket(image,image->colormap+(ssize_t) index,q);
if (bit)
bit-=bits_per_pixel;
else
ptr++;
bit=8-bits_per_pixel;
}
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
if (flags & PALM_HAS_TRANSPARENCY_FLAG)
{
if (bits_per_pixel != 16)
- SetMagickPixelPacket(image,image->colormap+(mask-transparentIndex),
- (const IndexPacket *) NULL,&transpix);
+ SetPixelInfoPacket(image,image->colormap+(mask-transparentIndex),
+ &transpix);
(void) TransparentPaintImage(image,&transpix,(Quantum)
- TransparentOpacity,MagickFalse);
+ TransparentAlpha,MagickFalse);
}
one_row=(unsigned char *) RelinquishMagickMemory(one_row);
if (compressionType == PALM_COMPRESSION_SCANLINE)
%
% The format of the RegisterPALMImage method is:
%
-% unsigned long RegisterPALMImage(void)
+% size_t RegisterPALMImage(void)
%
*/
-ModuleExport unsigned long RegisterPALMImage(void)
+ModuleExport size_t RegisterPALMImage(void)
{
MagickInfo
*entry;
QuantizeInfo
*quantize_info;
- register IndexPacket
- *indexes;
-
- register long
+ register ssize_t
x;
- register PixelPacket
+ register const Quantum
*p;
+ register Quantum
+ *q;
+
+ size_t
+ count,
+ bits_per_pixel,
+ bytes_per_row,
+ nextDepthOffset,
+ one;
+
unsigned char
bit,
byte,
unsigned int
transparentIndex;
- unsigned long
- count,
- bits_per_pixel,
- bytes_per_row,
- nextDepthOffset;
-
unsigned short
color16,
flags;
-
/*
Open output image file.
*/
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)
+ if (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,RGBColorspace);
count=GetNumberColors(image,NULL,&exception);
- for (bits_per_pixel=1; (1UL << bits_per_pixel) < count; bits_per_pixel*=2) ;
+ 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)
affinity_image=ConstituteImage(256,1,"RGB",CharPixel,&PalmPalette,
&exception);
- (void) TransformImageColorspace(affinity_image,affinity_image->colorspace);
+ (void) TransformImageColorspace(affinity_image,
+ affinity_image->colorspace);
(void) RemapImage(quantize_info,image,affinity_image);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetAuthenticPixels(image,0,y,image->columns,1,&exception);
- indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) image->columns; x++)
- indexes[x]=(IndexPacket) FindColor(&image->colormap[(long)
- indexes[x]]);
+ q=GetAuthenticPixels(image,0,y,image->columns,1,&exception);
+ for (x=0; x < (ssize_t) image->columns; 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*(unsigned long) p->red)/
- (unsigned long) QuantumRange) << 11) |
- (((63*(unsigned long) p->green)/(unsigned long) QuantumRange) << 5) |
- ((31*(unsigned long) p->blue)/(unsigned long) QuantumRange));
- if (p->opacity == (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=p->red;
- transpix.green=p->green;
- transpix.blue=p->blue;
- transpix.opacity=p->opacity;
+ 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) indexes[x];
+ color=(unsigned char) GetPixelIndex(image,p);
else
- color=(unsigned char) (indexes[x]*((1 << bits_per_pixel)-1)/
- MagickMax(1L*image->colors-1L,1L));
+ color=(unsigned char) (GetPixelIndex(image,p)*
+ ((one << bits_per_pixel)-1)/MagickMax(1*image->colors-1,1));
byte|=color << bit;
if (bit != 0)
- bit-=bits_per_pixel;
+ bit-=(unsigned char) bits_per_pixel;
else
{
*ptr++=byte;
byte=0x00;
bit=(unsigned char) (8-bits_per_pixel);
}
+ p+=GetPixelChannels(image);
}
if ((image->columns % (8/bits_per_pixel)) != 0)
*ptr++=byte;
if (image_info->compression == RLECompression)
{
x=0;
- while (x < (long) bytes_per_row)
+ while (x < (ssize_t) bytes_per_row)
{
byte=one_row[x];
count=1;
while ((one_row[++x] == byte) && (count < 255) &&
- (x < (long) bytes_per_row))
+ (x < (ssize_t) bytes_per_row))
count++;
(void) WriteBlobByte(image,(unsigned char) count);
(void) WriteBlobByte(image,(unsigned char) byte);
tmpbuf[8],
*tptr;
- for (x = 0; x < (long) bytes_per_row; x += 8)
+ for (x = 0; x < (ssize_t) bytes_per_row; x += 8)
{
tptr = tmpbuf;
for (bit=0, byte=0; bit < (unsigned char) MagickMin(8,(ssize_t) bytes_per_row-x); bit++)
{
if ((y == 0) || (lastrow[x + bit] != one_row[x + bit]))
{
- byte |= (1 << (7 - bit));
- *tptr++ = (char) one_row[x + bit];
- }
+ byte |= (1 << (7 - bit));
+ *tptr++ = (char) one_row[x + bit];
+ }
}
(void) WriteBlobByte(image, byte);
(void) WriteBlob(image,tptr-tmpbuf,(unsigned char *) tmpbuf);
}
/* write nextDepthOffset and return to end of image */
offset=SeekBlob(image,currentOffset+10,SEEK_SET);
- nextDepthOffset=(unsigned long) ((GetBlobSize(image)-currentOffset)/4);
+ nextDepthOffset=(size_t) ((GetBlobSize(image)-currentOffset)/4);
(void) WriteBlobMSBShort(image,(unsigned short) nextDepthOffset);
currentOffset=(MagickOffsetType) GetBlobSize(image);
offset=SeekBlob(image,currentOffset,SEEK_SET);
projects / imagemagick / blobdiff