length--;
if ((image->storage_class == PseudoClass) ||
(image->colorspace == CMYKColorspace))
- indexes[x]=index;
+ SetIndexPixelComponent(indexes+x,index);
*q++=pixel;
}
break;
}
pixel=(*p);
if (indexes != (IndexPacket *) NULL)
- index=indexes[x];
+ index=GetIndexPixelComponent(indexes+x);
p++;
}
q=PopRunlengthPacket(image,q,length,pixel,index);
Image
*image;
- ssize_t
- y;
-
MagickBooleanType
status;
register IndexPacket
*indexes;
- register ssize_t
- x;
-
register PixelPacket
*q;
+ register ssize_t
+ x;
+
size_t
bit,
byte;
+ ssize_t
+ y;
+
/*
Open image file.
*/
if (bit == 0)
byte=(size_t) ReadBlobByte(image);
if (image_info->endian == LSBEndian)
- indexes[x]=(IndexPacket) (((byte & 0x01) != 0) ? 0x00 : 0x01);
+ SetIndexPixelComponent(indexes+x,((byte & 0x01) != 0) ? 0x00 : 0x01);
else
- indexes[x]=(IndexPacket) (((byte & 0x01) != 0) ? 0x01 : 0x00);
+ SetIndexPixelComponent(indexes+x,((byte & 0x01) != 0) ? 0x01 : 0x00);
bit++;
if (bit == 8)
bit=0;
static MagickBooleanType WriteMONOImage(const ImageInfo *image_info,
Image *image)
{
- ssize_t
- y;
-
MagickBooleanType
status;
bit,
byte;
+ ssize_t
+ y;
+
/*
Open output image file.
*/
if (bit != 0)
(void) WriteBlobByte(image,(unsigned char) (byte >> (8-bit)));
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
i;
size_t
- length;
+ depth,
+ length,
+ quantum_depth;
ssize_t
count;
StringInfo
*profile;
- size_t
- depth,
- quantum_depth;
-
/*
Open image file.
*/
}
if (LocaleCompare(keyword,"maximum-error") == 0)
{
- image->error.normalized_maximum_error=StringToDouble(options);
+ image->error.normalized_maximum_error=
+ StringToDouble(options);
break;
}
if (LocaleCompare(keyword,"mean-error") == 0)
image->iterations,(double) image->delay,(double)
image->ticks_per_second);
else
- (void) FormatMagickString(buffer,MaxTextExtent,
- "scene=%.20g iterations=%.20g delay=%.20g ticks-per-second=%.20g\n",
+ (void) FormatMagickString(buffer,MaxTextExtent,"scene=%.20g "
+ "iterations=%.20g delay=%.20g ticks-per-second=%.20g\n",
(double) image->scene,(double) image->iterations,(double)
image->delay,(double) image->ticks_per_second);
(void) WriteBlobString(image,buffer);
if (image->rendering_intent != UndefinedIntent)
{
(void) FormatMagickString(buffer,MaxTextExtent,
- "rendering-intent=%s\n",
- CommandOptionToMnemonic(MagickIntentOptions,image->rendering_intent));
+ "rendering-intent=%s\n",CommandOptionToMnemonic(MagickIntentOptions,
+ image->rendering_intent));
(void) WriteBlobString(image,buffer);
}
if (image->gamma != 0.0)
i;
size_t
- length;
+ count,
+ length,
+ scene;
unsigned char
*blob;
- size_t
- count,
- scene;
-
/*
Open output image file.
*/
Image
*image;
- ssize_t
- y;
-
MagickBooleanType
status;
*p;
ssize_t
- count;
+ count,
+ y;
unsigned char
*pixels;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% WriteMTVImage() writes an image to a file in red, green, and blue
-% MTV rasterfile format.
+% WriteMTVImage() writes an image to a file in red, green, and blue MTV
+% rasterfile format.
%
% The format of the WriteMTVImage method is:
%
char
buffer[MaxTextExtent];
- ssize_t
- y;
-
MagickBooleanType
status;
register unsigned char
*q;
+ ssize_t
+ y;
+
unsigned char
*pixels;
Image
*image;
- ssize_t
- y;
-
MagickPixelPacket
background;
register PixelPacket
*q;
+ ssize_t
+ y;
+
/*
Initialize Image structure.
*/
int
byte;
- ssize_t
- y;
-
MagickBooleanType
status;
register PixelPacket
*q;
+ ssize_t
+ y;
+
unsigned char
bit,
info,
if (byte == EOF)
ThrowReaderException(CorruptImageError,"CorruptImage");
}
- indexes[x]=(IndexPacket) ((byte & (0x01 << (7-bit))) ? 0x00 : 0x01);
+ SetIndexPixelComponent(indexes+x,(byte & (0x01 << (7-bit))) ?
+ 0x00 : 0x01);
bit++;
if (bit == 8)
bit=0;
#define SetBit(a,i,set) \
a=(unsigned char) ((set) ? (a) | (1L << (i)) : (a) & ~(1L << (i)))
- ssize_t
- y;
-
MagickBooleanType
status;
register ssize_t
x;
+ ssize_t
+ y;
+
unsigned char
bit,
byte,
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
% 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 %
% %
IndexPacket
index;
- ssize_t
- y;
-
MagickBooleanType
status;
*q;
ssize_t
- count;
-
- unsigned char
- *lastrow,
- *one_row,
- *ptr;
+ count,
+ y;
size_t
bytes_per_row,
size,
bit;
+ unsigned char
+ *lastrow,
+ *one_row,
+ *ptr;
+
unsigned short
color16;
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);
{
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);
+ 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++;
}
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[(ssize_t) index];
+ 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);
if (bit)
bit-=bits_per_pixel;
else
ptr++;
bit=8-bits_per_pixel;
}
+ q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
register PixelPacket
*p;
+ size_t
+ count,
+ bits_per_pixel,
+ bytes_per_row,
+ nextDepthOffset,
+ one;
+
unsigned char
bit,
byte,
unsigned int
transparentIndex;
- size_t
- count,
- bits_per_pixel,
- bytes_per_row,
- nextDepthOffset,
- one;
-
unsigned short
color16,
flags;
-
/*
Open output image file.
*/
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 < (ssize_t) image->rows; y++)
{
p=GetAuthenticPixels(image,0,y,image->columns,1,&exception);
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- indexes[x]=(IndexPacket) FindColor(&image->colormap[(ssize_t)
- indexes[x]]);
+ SetIndexPixelComponent(indexes+x,FindColor(&image->colormap[
+ (ssize_t) GetIndexPixelComponent(indexes+x)]));
}
affinity_image=DestroyImage(affinity_image);
}
for (x=0; x < (int) image->columns; x++)
{
if (bits_per_pixel >= 8)
- color=(unsigned char) indexes[x];
+ color=(unsigned char) GetIndexPixelComponent(indexes+x);
else
- color=(unsigned char) (indexes[x]*((one << bits_per_pixel)-1)/
- MagickMax(1*image->colors-1,1));
+ color=(unsigned char) (GetIndexPixelComponent(indexes+x)*
+ ((one << bits_per_pixel)-1)/MagickMax(1*image->colors-1,1));
byte|=color << bit;
if (bit != 0)
bit-=(unsigned char) bits_per_pixel;
{
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);
key;
} PCDTable;
- ssize_t
- quantum;
-
PCDTable
*pcd_table[3];
*p,
*q;
- size_t
- length;
-
- ssize_t
- count;
-
- unsigned char
- *buffer;
-
size_t
bits,
+ length,
plane,
pcd_length[3],
row,
sum;
+ ssize_t
+ count,
+ quantum;
+
+ unsigned char
+ *buffer;
+
/*
Initialize Huffman tables.
*/
p--;
q-=2;
*q=(*p);
- *(q+1)=(unsigned char) ((((size_t) *p)+
- ((size_t) *(p+1))+1) >> 1);
+ *(q+1)=(unsigned char) ((((size_t) *p)+((size_t) *(p+1))+1) >> 1);
}
}
for (y=0; y < (ssize_t) (height-1); y++)
p+=2;
r+=2;
}
- *q++=(unsigned char) ((((size_t) *p++)+
- ((size_t) *r++)+1) >> 1);
- *q++=(unsigned char) ((((size_t) *p++)+
- ((size_t) *r++)+1) >> 1);
+ *q++=(unsigned char) ((((size_t) *p++)+((size_t) *r++)+1) >> 1);
+ *q++=(unsigned char) ((((size_t) *p++)+((size_t) *r++)+1) >> 1);
}
p=pixels+(2*height-2)*scaled_width;
q=pixels+(2*height-1)*scaled_width;
Image
*image;
- ssize_t
- x;
-
MagickBooleanType
status;
*c2,
*yy;
+ size_t
+ height,
+ number_images,
+ rotate,
+ scene,
+ width;
+
ssize_t
- count;
+ count,
+ x;
unsigned char
*chroma1,
unsigned int
overview;
- size_t
- height,
- number_images,
- rotate,
- scene,
- width;
-
/*
Open image file.
*/
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=ScaleCharToQuantum(*yy++);
- q->green=ScaleCharToQuantum(*c1++);
- q->blue=ScaleCharToQuantum(*c2++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*yy++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*c1++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*c2++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=ScaleCharToQuantum(*yy++);
- q->green=ScaleCharToQuantum(*c1++);
- q->blue=ScaleCharToQuantum(*c2++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*yy++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*c1++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*c2++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
*downsample_image,
*tile_image;
- ssize_t
- y;
-
MagickBooleanType
status;
i,
x;
+ ssize_t
+ y;
+
/*
Scale image to tile size.
*/
break;
for (x=0; x < (ssize_t) downsample_image->columns; x++)
{
- (void) WriteBlobByte(image,ScaleQuantumToChar(q->green));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetGreenPixelComponent(q)));
q++;
}
q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,
break;
for (x=0; x < (ssize_t) downsample_image->columns; x++)
{
- (void) WriteBlobByte(image,ScaleQuantumToChar(q->blue));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetBluePixelComponent(q)));
q++;
}
status=SetImageProgress(image,SaveImageTag,y,tile_image->rows);
SegmentInfo
bounds;
- ssize_t
- count;
-
size_t
height,
width;
+ ssize_t
+ count;
+
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
int
count;
- ssize_t
- j;
-
register ssize_t
x;
register unsigned char
*q;
+ ssize_t
+ j;
+
unsigned char
packbits[128];
const char
*option;
- ssize_t
- y;
-
MagickBooleanType
status;
register const IndexPacket
*indexes;
- register const PixelPacket
- *p;
-
- register ssize_t
- i,
- x;
-
- register unsigned char
- *q;
-
- size_t
- length,
+ register const PixelPacket *p; register ssize_t i, x; register unsigned char *q; size_t density, length,
+ one,
packets;
+ ssize_t
+ y;
+
unsigned char
bits_per_pixel,
*compress_pixels,
*pixels,
*previous_pixels;
- size_t
- density,
- one;
-
/*
Open output image file.
*/
ScaleQuantumToChar(image->colormap[i].blue),(double) i);
(void) WriteBlobString(image,buffer);
}
- one=1;
- for ( ; i < (ssize_t) (one << bits_per_pixel); i++)
+ for (one=1; i < (ssize_t) (one << bits_per_pixel); i++)
{
(void) FormatMagickString(buffer,MaxTextExtent,"\033*v%.20gI",
(double) i);
}
case RLECompression:
{
- packets=PCLPackbitsCompressImage(length,pixels,
- compress_pixels);
+ packets=PCLPackbitsCompressImage(length,pixels,compress_pixels);
(void) FormatMagickString(buffer,MaxTextExtent,"\033*b%.20gW",
(double) packets);
(void) WriteBlobString(image,buffer);
id,
mask;
- ssize_t
- y;
-
MagickBooleanType
status;
*p,
*r;
+ size_t
+ one,
+ pcx_packets;
+
ssize_t
- count;
+ count,
+ y;
unsigned char
packet,
*pcx_pixels,
*scanline;
- size_t
- one,
- pcx_packets;
-
/*
Open image file.
*/
for (x=0; x < (ssize_t) image->columns; x++)
{
if (image->storage_class == PseudoClass)
- indexes[x]=(IndexPacket) (*r++);
+ SetIndexPixelComponent(indexes+x,*r++);
else
{
- q->red=ScaleCharToQuantum(*r++);
- q->green=ScaleCharToQuantum(*r++);
- q->blue=ScaleCharToQuantum(*r++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*r++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*r++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*r++));
if (image->matte != MagickFalse)
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(*r++));
+ SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(*r++));
}
q++;
}
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
{
- ssize_t
- y;
-
MagickBooleanType
status;
size_t
length;
+ ssize_t
+ y;
+
unsigned char
*pcx_colormap,
*pcx_pixels;
for (x=0; x < (ssize_t) image->columns; x++)
{
byte<<=1;
- if (indexes[x] == polarity)
+ if (GetIndexPixelComponent(indexes+x) == polarity)
byte|=0x01;
bit++;
if (bit == 8)
IndexPacket
index;
- ssize_t
- img_offset, /* TS */
- comment_offset = 0,
- y;
-
MagickBooleanType
status;
register unsigned char
*p;
- ssize_t
- count;
-
- unsigned char
- *pixels;
-
size_t
bits_per_pixel,
num_pad_bytes, /* TS */
one,
packets;
+ ssize_t
+ count,
+ img_offset, /* TS */
+ comment_offset = 0,
+ y;
+
+ unsigned char
+ *pixels;
+
/*
Open image file.
*/
count=ReadBlob(image,3,(unsigned char *) tag);
if (count != 3 || memcmp(tag,"\x6f\x80\x00",3) != 0)
ThrowReaderException(CorruptImageError,"CorruptImage");
-
if (pdb_info.number_records > 1)
{
comment_offset=(int) ReadBlobMSBLong(image);
if (count != 3 || memcmp(tag,"\x6f\x80\x01",3) != 0)
ThrowReaderException(CorruptImageError,"CorruptImage");
}
-
num_pad_bytes = (size_t) (img_offset - TellBlob( image ));
while (num_pad_bytes--) ReadBlobByte( image );
/*
{
index=(IndexPacket) (*p & (0x80 >> bit) ? 0x00 : 0x01);
SetIndexPixelComponent(indexes+x+bit,index);
- *q++=image->colormap[(ssize_t) index];
}
p++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
+ (void) SyncImage(image);
break;
}
case 2:
for (x=0; x < (ssize_t) image->columns; x+=4)
{
index=ConstrainColormapIndex(image,3UL-((*p >> 6) & 0x03));
- indexes[x]=index;
- *q++=image->colormap[(ssize_t) index];
+ SetIndexPixelComponent(indexes+x,index);
index=ConstrainColormapIndex(image,3UL-((*p >> 4) & 0x03));
- indexes[x+1]=index;
- *q++=image->colormap[(ssize_t) index];
+ SetIndexPixelComponent(indexes+x+1,index);
index=ConstrainColormapIndex(image,3UL-((*p >> 2) & 0x03));
- indexes[x+2]=index;
- *q++=image->colormap[(ssize_t) index];
+ SetIndexPixelComponent(indexes+x+2,index);
index=ConstrainColormapIndex(image,3UL-((*p) & 0x03));
- indexes[x+3]=index;
- *q++=image->colormap[(ssize_t) index];
+ SetIndexPixelComponent(indexes+x+3,index);
p++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
+ (void) SyncImage(image);
break;
}
case 4:
for (x=0; x < (ssize_t) image->columns; x+=2)
{
index=ConstrainColormapIndex(image,15UL-((*p >> 4) & 0x0f));
- indexes[x]=index;
- *q++=image->colormap[(ssize_t) index];
+ SetIndexPixelComponent(indexes+x,index);
index=ConstrainColormapIndex(image,15UL-((*p) & 0x0f));
- indexes[x+1]=index;
- *q++=image->colormap[(ssize_t) index];
+ SetIndexPixelComponent(indexes+x+1,index);
p++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
+ (void) SyncImage(image);
break;
}
default:
int
bits;
- ssize_t
- y;
-
MagickBooleanType
status;
*q;
size_t
- packet_size;
+ bits_per_pixel,
+ literal,
+ packets,
+ packet_size,
+ repeat;
+
+ ssize_t
+ y;
unsigned char
*buffer,
*runlength,
*scanline;
- size_t
- bits_per_pixel,
- literal,
- packets,
- repeat;
-
/*
Open output image file.
*/
bounds,
hires_bounds;
- ssize_t
- count;
-
size_t
scene,
spotcolor;
+ ssize_t
+ count;
+
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
register ssize_t
i;
- static char
- buffer[MaxTextExtent];
-
size_t
escapes;
+ static char
+ buffer[MaxTextExtent];
+
escapes=0;
p=buffer;
for (i=0; i < (ssize_t) MagickMin(strlen(text),(MaxTextExtent-escapes-1)); i++)
GeometryInfo
geometry_info;
- ssize_t
- count,
- y;
-
Image
*next,
*tile_image;
x;
size_t
- length;
+ info_id,
+ length,
+ object,
+ pages_id,
+ root_id,
+ text_size,
+ version;
+
+ ssize_t
+ count,
+ y;
struct tm
local_time;
unsigned char
*pixels;
- size_t
- info_id,
- object,
- pages_id,
- root_id,
- text_size,
- version;
-
/*
Open output image file.
*/
*q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
*q++=ScaleQuantumToChar(GetBluePixelComponent(p));
if (image->colorspace == CMYKColorspace)
- *q++=ScaleQuantumToChar(indexes[x]);
+ *q++=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x));
p++;
}
if (image->previous == (Image *) NULL)
Ascii85Encode(image,ScaleQuantumToChar(
GetBluePixelComponent(p)));
if (image->colorspace == CMYKColorspace)
- Ascii85Encode(image,ScaleQuantumToChar(indexes[x]));
+ Ascii85Encode(image,ScaleQuantumToChar(
+ GetIndexPixelComponent(indexes+x)));
p++;
}
if (image->previous == (Image *) NULL)
break;
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- Ascii85Encode(image,(unsigned char) indexes[x]);
+ Ascii85Encode(image,(unsigned char)
+ GetIndexPixelComponent(indexes+x));
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,
*q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
*q++=ScaleQuantumToChar(GetBluePixelComponent(p));
if (image->colorspace == CMYKColorspace)
- *q++=ScaleQuantumToChar(indexes[x]);
+ *q++=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x));
p++;
}
}
Ascii85Encode(image,ScaleQuantumToChar(
GetBluePixelComponent(p)));
if (image->colorspace == CMYKColorspace)
- Ascii85Encode(image,ScaleQuantumToChar(indexes[x]));
+ Ascii85Encode(image,ScaleQuantumToChar(
+ GetIndexPixelComponent(indexes+x)));
p++;
}
}
break;
indexes=GetVirtualIndexQueue(tile_image);
for (x=0; x < (ssize_t) tile_image->columns; x++)
- Ascii85Encode(image,(unsigned char) indexes[x]);
+ Ascii85Encode(image,(unsigned char)
+ GetIndexPixelComponent(indexes+x));
}
Ascii85Flush(image);
break;
register ssize_t
i;
+ size_t
+ number_blocks,
+ number_colors,
+ number_stitches;
+
ssize_t
count,
offset;
magick[4],
version[4];
- size_t
- number_blocks,
- number_colors,
- number_stitches;
-
/*
Open image file.
*/
static unsigned char *DecodeImage(Image *blob,Image *image,
size_t bytes_per_line,const unsigned int bits_per_pixel,size_t *extent)
{
- ssize_t
- j,
- y;
-
MagickSizeType
number_pixels;
*q;
size_t
+ bytes_per_pixel,
length,
- row_bytes;
+ row_bytes,
+ scanline_length,
+ width;
ssize_t
- count;
+ count,
+ j,
+ y;
unsigned char
*pixels,
*scanline;
- size_t
- bytes_per_pixel,
- scanline_length,
- width;
-
/*
Determine pixel buffer size.
*/
#define MaxCount 128
#define MaxPackbitsRunlength 128
- ssize_t
- count,
- repeat_count,
- runlength;
-
register const unsigned char
*p;
size_t
length;
+ ssize_t
+ count,
+ repeat_count,
+ runlength;
+
unsigned char
index;
c,
code;
- ssize_t
- flags,
- j,
- version,
- y;
-
MagickBooleanType
jpeg,
status;
length;
ssize_t
- count;
+ count,
+ flags,
+ j,
+ version,
+ y;
StringInfo
*profile;
if (tile_image->storage_class == PseudoClass)
{
index=ConstrainColormapIndex(tile_image,*p);
- indexes[x]=index;
- q->red=tile_image->colormap[(ssize_t) index].red;
- q->green=tile_image->colormap[(ssize_t) index].green;
- q->blue=tile_image->colormap[(ssize_t) index].blue;
+ SetIndexPixelComponent(indexes+x,index);
+ SetRedPixelComponent(q,
+ tile_image->colormap[(ssize_t) index].red);
+ SetGreenPixelComponent(q,
+ tile_image->colormap[(ssize_t) index].green);
+ SetBluePixelComponent(q,
+ tile_image->colormap[(ssize_t) index].blue);
}
else
{
{
i=(*p++);
j=(*p);
- q->red=ScaleCharToQuantum((unsigned char)
- ((i & 0x7c) << 1));
- q->green=ScaleCharToQuantum((unsigned char)
- (((i & 0x03) << 6) | ((j & 0xe0) >> 2)));
- q->blue=ScaleCharToQuantum((unsigned char)
- ((j & 0x1f) << 3));
+ SetRedPixelComponent(q,ScaleCharToQuantum(
+ (unsigned char) ((i & 0x7c) << 1)));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(
+ (unsigned char) (((i & 0x03) << 6) |
+ ((j & 0xe0) >> 2))));
+ SetBluePixelComponent(q,ScaleCharToQuantum(
+ (unsigned char) ((j & 0x1f) << 3)));
}
else
if (tile_image->matte == MagickFalse)
ThrowReaderException(CorruptImageError,
"NotEnoughPixelData");
SetRedPixelComponent(q,ScaleCharToQuantum(*p));
- q->green=ScaleCharToQuantum(
- *(p+tile_image->columns));
- q->blue=ScaleCharToQuantum(
- *(p+2*tile_image->columns));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(
+ *(p+tile_image->columns)));
+ SetBluePixelComponent(q,ScaleCharToQuantum(
+ *(p+2*tile_image->columns)));
}
else
{
if (p > (pixels+extent+3*image->columns))
ThrowReaderException(CorruptImageError,
"NotEnoughPixelData");
- q->opacity=(Quantum) (QuantumRange-
- ScaleCharToQuantum(*p));
- q->red=ScaleCharToQuantum(*(p+tile_image->columns));
- q->green=(Quantum) ScaleCharToQuantum(
- *(p+2*tile_image->columns));
- q->blue=ScaleCharToQuantum(
- *(p+3*tile_image->columns));
+ SetOpacityPixelComponent(q,(Quantum) (QuantumRange-
+ ScaleCharToQuantum(*p)));
+ SetRedPixelComponent(q,ScaleCharToQuantum(
+ *(p+tile_image->columns)));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(
+ *(p+2*tile_image->columns)));
+ SetBluePixelComponent(q,ScaleCharToQuantum(
+ *(p+3*tile_image->columns)));
}
}
p++;
x_resolution,
y_resolution;
- ssize_t
- y;
-
MagickBooleanType
status;
x;
size_t
- count;
+ bytes_per_line,
+ count,
+ storage_class;
+
+ ssize_t
+ y;
unsigned char
*buffer,
*packed_scanline,
*scanline;
- size_t
- bytes_per_line,
- storage_class;
unsigned short
base_address,
break;
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- scanline[x]=(unsigned char) indexes[x];
+ scanline[x]=(unsigned char) GetIndexPixelComponent(indexes+x);
count+=EncodeImage(image,scanline,(size_t) (row_bytes & 0x7FFF),
packed_scanline);
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
{
(void) ResetMagickMemory(scanline,0,row_bytes);
for (y=0; y < (ssize_t) image->rows; y++)
- count+=EncodeImage(image,scanline,(size_t)
- (row_bytes & 0x7FFF),packed_scanline);
+ count+=EncodeImage(image,scanline,(size_t) (row_bytes & 0x7FFF),
+ packed_scanline);
}
else
{
IndexPacket
index;
- ssize_t
- y;
-
MagickBooleanType
status;
register PixelPacket
*q;
- size_t
- length;
-
size_t
bits_per_pixel,
height,
+ length,
width;
+ ssize_t
+ y;
+
/*
Open image file.
*/
}
}
if (image->storage_class == PseudoClass)
- indexes[x]=index;
- q->blue=blue;
- q->green=green;
- q->red=red;
+ SetIndexPixelComponent(indexes+x,index);
+ SetBluePixelComponent(q,blue);
+ SetGreenPixelComponent(q,green);
+ SetRedPixelComponent(q,red);
length--;
q++;
}
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
ImageInfo
*read_info;
- ssize_t
- y;
-
MagickBooleanType
status;
depth,
max_depth;
+ ssize_t
+ y;
+
/*
Recursively apply plasma to the image.
*/
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->opacity=(Quantum) (QuantumRange/2);
+ SetOpacityPixelComponent(q,QuantumRange/2);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
*p;
size_t
- extent;
-
- size_t
+ extent,
value;
/*
Image
*image;
- ssize_t
- row,
- y;
-
MagickBooleanType
status;
i;
size_t
+ depth,
extent,
+ max_value,
packet_size;
ssize_t
- count;
-
- size_t
- depth,
- max_value;
+ count,
+ row,
+ y;
/*
Open image file.
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=(Quantum) (PNMInteger(image,2) == 0 ? QuantumRange : 0);
+ SetRedPixelComponent(q,PNMInteger(image,2) == 0 ? QuantumRange : 0);
SetGreenPixelComponent(q,GetRedPixelComponent(q));
SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
for (x=0; x < (ssize_t) image->columns; x++)
{
intensity=PNMInteger(image,10);
- q->red=(Quantum) intensity;
+ SetRedPixelComponent(q,intensity);
if (scale != (Quantum *) NULL)
- q->red=scale[ConstrainPixel(image,(ssize_t) intensity,max_value)];
+ SetRedPixelComponent(q,scale[ConstrainPixel(image,(ssize_t)
+ intensity,max_value)]);
SetGreenPixelComponent(q,GetRedPixelComponent(q));
SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
pixel.blue=(MagickRealType) scale[ConstrainPixel(image,(ssize_t)
pixel.blue,max_value)];
}
- q->red=(Quantum) pixel.red;
- q->green=(Quantum) pixel.green;
- q->blue=(Quantum) pixel.blue;
+ SetRedPixelComponent(q,pixel.red);
+ SetGreenPixelComponent(q,pixel.green);
+ SetBluePixelComponent(q,pixel.blue);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
extent=GetQuantumExtent(image,quantum_info,quantum_type);
for (y=0; y < (ssize_t) image->rows; y++)
{
- ssize_t
- offset;
-
MagickBooleanType
sync;
*restrict q;
ssize_t
- count;
+ count,
+ offset;
size_t
length;
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (y=0; y < (ssize_t) image->rows; y++)
{
- ssize_t
- offset;
-
MagickBooleanType
sync;
*restrict q;
ssize_t
- count;
+ count,
+ offset;
unsigned char
*pixels;
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (y=0; y < (ssize_t) image->rows; y++)
{
- ssize_t
- offset;
-
MagickBooleanType
sync;
*restrict q;
ssize_t
- count;
+ count,
+ offset;
unsigned char
*pixels;
for (x=0; x < (ssize_t) image->columns; x++)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(MSBEndian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(MSBEndian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
- q->opacity=OpaqueOpacity;
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
}
for (x=0; x < (ssize_t) image->columns; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushCharPixel(p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
- q->opacity=OpaqueOpacity;
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
}
for (x=0; x < (ssize_t) image->columns; x++)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushShortPixel(MSBEndian,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushShortPixel(MSBEndian,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
- q->opacity=OpaqueOpacity;
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
}
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (y=0; y < (ssize_t) image->rows; y++)
{
- ssize_t
- offset;
-
MagickBooleanType
sync;
*restrict q;
ssize_t
- count;
+ count,
+ offset;
unsigned char
*pixels;
p=PushCharPixel(p,&pixel);
SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushCharPixel(p,&pixel);
- indexes[x]=ScaleAnyToQuantum(pixel,range);
+ SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,
+ range));
SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
{
p=PushShortPixel(MSBEndian,p,&pixel);
SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushShortPixel(MSBEndian,p,&pixel);
- indexes[x]=ScaleAnyToQuantum(pixel,range);
+ SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,
+ range));
SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
{
extent=GetQuantumExtent(image,quantum_info,quantum_type);
for (y=0; y < (ssize_t) image->rows; y++)
{
- ssize_t
- offset;
-
MagickBooleanType
sync;
*restrict q;
ssize_t
- count;
+ count,
+ offset;
size_t
length;
IndexPacket
index;
- ssize_t
- y;
-
MagickBooleanType
status;
packet_size;
ssize_t
- count;
+ count,
+ y;
/*
Open output image file.
q=PopCharPixel((unsigned char) pixel,q);
if (image->matte != MagickFalse)
{
- pixel=(unsigned char) ScaleQuantumToAny(GetOpacityPixelComponent(p),
- range);
+ pixel=(unsigned char) ScaleQuantumToAny(
+ GetOpacityPixelComponent(p),range);
q=PopCharPixel((unsigned char) pixel,q);
}
p++;
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
if (image->matte != MagickFalse)
{
- pixel=(unsigned char) ScaleQuantumToAny(GetOpacityPixelComponent(p),
- range);
+ pixel=(unsigned char) ScaleQuantumToAny(
+ GetOpacityPixelComponent(p),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
}
p++;
q=PopCharPixel((unsigned char) pixel,q);
pixel=ScaleQuantumToAny(GetBluePixelComponent(p),range);
q=PopCharPixel((unsigned char) pixel,q);
- pixel=ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range);
+ pixel=ScaleQuantumToAny(
+ GetIndexPixelComponent(indexes+x),range);
q=PopCharPixel((unsigned char) pixel,q);
if (image->matte != MagickFalse)
{
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
pixel=ScaleQuantumToAny(GetBluePixelComponent(p),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- pixel=ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range);
+ pixel=ScaleQuantumToAny(
+ GetIndexPixelComponent(indexes+x),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
if (image->matte != MagickFalse)
{
projects / imagemagick / commitdiff