% July 1992 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 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 "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"
%
*/
-static inline long MagickAbsoluteValue(const long x)
+static inline ssize_t MagickAbsoluteValue(const ssize_t x)
{
if (x < 0)
return(-x);
id,
mask;
- long
+ ssize_t
y;
MagickBooleanType
register IndexPacket
*indexes;
- register long
+ register ssize_t
x;
register PixelPacket
*q;
- register long
+ register ssize_t
i;
register unsigned char
*pcx_pixels,
*scanline;
- unsigned long
+ size_t
+ one,
pcx_packets;
/*
page_table=(MagickOffsetType *) NULL;
if (LocaleCompare(image_info->magick,"DCX") == 0)
{
- unsigned long
+ size_t
magic;
/*
/*
Read PCX raster colormap.
*/
- image->columns=(unsigned long) MagickAbsoluteValue((long) pcx_info.right-
+ image->columns=(size_t) MagickAbsoluteValue((ssize_t) pcx_info.right-
pcx_info.left)+1UL;
- image->rows=(unsigned long) MagickAbsoluteValue((long) pcx_info.bottom-
+ image->rows=(size_t) MagickAbsoluteValue((ssize_t) pcx_info.bottom-
pcx_info.top)+1UL;
if ((image->columns == 0) || (image->rows == 0) ||
(pcx_info.bits_per_pixel == 0))
count=ReadBlob(image,3*image->colors,pcx_colormap);
pcx_info.reserved=(unsigned char) ReadBlobByte(image);
pcx_info.planes=(unsigned char) ReadBlobByte(image);
+ one=1;
if ((pcx_info.bits_per_pixel != 8) || (pcx_info.planes == 1))
if ((pcx_info.version == 3) || (pcx_info.version == 5) ||
((pcx_info.bits_per_pixel*pcx_info.planes) == 1))
- image->colors=(unsigned long) MagickMin(1UL << (1UL*
+ image->colors=(size_t) MagickMin(one << (1UL*
(pcx_info.bits_per_pixel*pcx_info.planes)),256UL);
if (AcquireImageColormap(image,image->colors) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if ((pcx_info.bits_per_pixel >= 8) && (pcx_info.planes != 1))
image->storage_class=DirectClass;
p=pcx_colormap;
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
image->colormap[i].red=ScaleCharToQuantum(*p++);
image->colormap[i].green=ScaleCharToQuantum(*p++);
/*
Read image data.
*/
- pcx_packets=(unsigned long) image->rows*pcx_info.bytes_per_line*
+ pcx_packets=(size_t) image->rows*pcx_info.bytes_per_line*
pcx_info.planes;
pcx_pixels=(unsigned char *) AcquireQuantumMemory(pcx_packets,
sizeof(*pcx_pixels));
pcx_info.colormap_signature=(unsigned char) ReadBlobByte(image);
count=ReadBlob(image,3*image->colors,pcx_colormap);
p=pcx_colormap;
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
image->colormap[i].red=ScaleCharToQuantum(*p++);
image->colormap[i].green=ScaleCharToQuantum(*p++);
/*
Convert PCX raster image to pixel packets.
*/
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
p=pcx_pixels+(y*pcx_info.bytes_per_line*pcx_info.planes);
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
for (i=0; i < pcx_info.planes; i++)
{
r=scanline+i;
- for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+ for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
{
switch (i)
{
else
if (pcx_info.planes > 1)
{
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
*r++=0;
for (i=0; i < pcx_info.planes; i++)
{
r=scanline;
- for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+ for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
{
bits=(*p++);
for (mask=0x80; mask != 0; mask>>=1)
{
case 1:
{
- register long
+ register ssize_t
bit;
- for (x=0; x < ((long) image->columns-7); x+=8)
+ for (x=0; x < ((ssize_t) image->columns-7); x+=8)
{
for (bit=7; bit >= 0; bit--)
*r++=(unsigned char) ((*p) & (0x01 << bit) ? 0x01 : 0x00);
}
if ((image->columns % 8) != 0)
{
- for (bit=7; bit >= (long) (8-(image->columns % 8)); bit--)
+ for (bit=7; bit >= (ssize_t) (8-(image->columns % 8)); bit--)
*r++=(unsigned char) ((*p) & (0x01 << bit) ? 0x01 : 0x00);
p++;
}
}
case 2:
{
- for (x=0; x < ((long) image->columns-3); x+=4)
+ for (x=0; x < ((ssize_t) image->columns-3); x+=4)
{
*r++=(*p >> 6) & 0x3;
*r++=(*p >> 4) & 0x3;
}
if ((image->columns % 4) != 0)
{
- for (i=3; i >= (long) (4-(image->columns % 4)); i--)
+ for (i=3; i >= (ssize_t) (4-(image->columns % 4)); i--)
*r++=(unsigned char) ((*p >> (i*2)) & 0x03);
p++;
}
}
case 4:
{
- for (x=0; x < ((long) image->columns-1); x+=2)
+ for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
*r++=(*p >> 4) & 0xf;
*r++=(*p) & 0xf;
Transfer image scanline.
*/
r=scanline;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if (image->storage_class == PseudoClass)
indexes[x]=(IndexPacket) (*r++);
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;
}
%
% The format of the RegisterPCXImage method is:
%
-% unsigned long RegisterPCXImage(void)
+% size_t RegisterPCXImage(void)
%
*/
-ModuleExport unsigned long RegisterPCXImage(void)
+ModuleExport size_t RegisterPCXImage(void)
{
MagickInfo
*entry;
register const unsigned char
*q;
- register long
+ register ssize_t
i,
x;
previous;
q=pixels;
- for (i=0; i < (long) pcx_info->planes; i++)
+ for (i=0; i < (ssize_t) pcx_info->planes; i++)
{
- previous=(*q++);
- count=1;
- for (x=0; x < (long) (pcx_info->bytes_per_line-1); x++)
- {
- packet=(*q++);
- if ((packet == previous) && (count < 63))
- {
- count++;
- continue;
- }
- if ((count > 1) || ((previous & 0xc0) == 0xc0))
+ if (pcx_info->encoding == 0)
+ {
+ for (x=0; x < (ssize_t) pcx_info->bytes_per_line; x++)
+ (void) WriteBlobByte(image,(unsigned char) (*q++));
+ }
+ else
+ {
+ previous=(*q++);
+ count=1;
+ for (x=0; x < (ssize_t) (pcx_info->bytes_per_line-1); x++)
{
- count|=0xc0;
- (void) WriteBlobByte(image,(unsigned char) count);
+ packet=(*q++);
+ if ((packet == previous) && (count < 63))
+ {
+ count++;
+ continue;
+ }
+ if ((count > 1) || ((previous & 0xc0) == 0xc0))
+ {
+ count|=0xc0;
+ (void) WriteBlobByte(image,(unsigned char) count);
+ }
+ (void) WriteBlobByte(image,previous);
+ previous=packet;
+ count=1;
}
- (void) WriteBlobByte(image,previous);
- previous=packet;
- count=1;
- }
- if ((count > 1) || ((previous & 0xc0) == 0xc0))
- {
- count|=0xc0;
- (void) WriteBlobByte(image,(unsigned char) count);
+ if ((count > 1) || ((previous & 0xc0) == 0xc0))
+ {
+ count|=0xc0;
+ (void) WriteBlobByte(image,(unsigned char) count);
+ }
+ (void) WriteBlobByte(image,previous);
}
- (void) WriteBlobByte(image,previous);
}
return (MagickTrue);
}
static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
{
- long
+ ssize_t
y;
MagickBooleanType
register const PixelPacket
*p;
- register long
+ register ssize_t
i,
x;
*/
pcx_info.identifier=0x0a;
pcx_info.version=5;
- pcx_info.encoding=1;
+ pcx_info.encoding=image_info->compression == NoCompression ? 0 : 1;
pcx_info.bits_per_pixel=8;
if ((image->storage_class == PseudoClass) &&
(IsMonochromeImage(image,&image->exception) != MagickFalse))
if (image->matte != MagickFalse)
pcx_info.planes++;
}
- pcx_info.bytes_per_line=(unsigned short) (((unsigned long) image->columns*
+ pcx_info.bytes_per_line=(unsigned short) (((size_t) image->columns*
pcx_info.bits_per_pixel+7)/8);
pcx_info.palette_info=1;
pcx_info.colormap_signature=0x0c;
(void) memset(pcx_colormap,0,3*256*sizeof(*pcx_colormap));
q=pcx_colormap;
if ((image->storage_class == PseudoClass) && (image->colors <= 256))
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
*q++=ScaleQuantumToChar(image->colormap[i].red);
*q++=ScaleQuantumToChar(image->colormap[i].green);
for (i=0; i < 58; i++)
(void) WriteBlobByte(image,'\0');
length=(size_t) pcx_info.bytes_per_line;
- pcx_pixels=(unsigned char *) AcquireQuantumMemory(length,
- pcx_info.planes*sizeof(*pcx_pixels));
+ pcx_pixels=(unsigned char *) AcquireQuantumMemory(length,pcx_info.planes*
+ sizeof(*pcx_pixels));
if (pcx_pixels == (unsigned char *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
q=pcx_pixels;
/*
Convert DirectClass image to PCX raster pixels.
*/
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
pixels=GetVirtualPixels(image,0,y,image->columns,1,
&image->exception);
{
case 0:
{
- for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+ for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
{
*q++=ScaleQuantumToChar(GetRedPixelComponent(p));
p++;
}
case 1:
{
- for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+ for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
{
*q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
p++;
}
case 2:
{
- for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+ for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
{
*q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
case 3:
default:
{
- for (x=(long) pcx_info.bytes_per_line; x != 0; x--)
+ for (x=(ssize_t) pcx_info.bytes_per_line; x != 0; x--)
{
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
+ *q++=ScaleQuantumToChar((Quantum)
+ (GetAlphaPixelComponent(p)));
p++;
}
break;
break;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
else
{
if (pcx_info.bits_per_pixel > 1)
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetVirtualIndexQueue(image);
q=pcx_pixels;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
*q++=(unsigned char) indexes[x];
if (PCXWritePixels(&pcx_info,pcx_pixels,image) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
polarity=(IndexPacket) (
PixelIntensityToQuantum(&image->colormap[0]) <
PixelIntensityToQuantum(&image->colormap[1]) ? 1 : 0);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,
&image->exception);
bit=0;
byte=0;
q=pcx_pixels;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
byte<<=1;
if (indexes[x] == polarity)
break;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
+ y,image->rows);
if (status == MagickFalse)
break;
}
}
pcx_pixels=(unsigned char *) RelinquishMagickMemory(pcx_pixels);
pcx_colormap=(unsigned char *) RelinquishMagickMemory(pcx_colormap);
+ if (page_table == (MagickOffsetType *) NULL)
+ break;
+ if (scene >= 1023)
+ break;
if (GetNextImageInList(image) == (Image *) NULL)
break;
image=SyncNextImageInList(image);
GetImageListLength(image));
if (status == MagickFalse)
break;
- if (scene >= 1023)
- break;
} while (image_info->adjoin != MagickFalse);
if (page_table != (MagickOffsetType *) NULL)
{
if (offset < 0)
ThrowWriterException(CorruptImageError,"ImproperImageHeader");
(void) WriteBlobLSBLong(image,0x3ADE68B1L);
- for (i=0; i <= (long) scene; i++)
- (void) WriteBlobLSBLong(image,(unsigned long) page_table[i]);
+ for (i=0; i <= (ssize_t) scene; i++)
+ (void) WriteBlobLSBLong(image,(unsigned int) page_table[i]);
page_table=(MagickOffsetType *) RelinquishMagickMemory(page_table);
}
if (status == MagickFalse)
projects / imagemagick / blobdiff