#if defined(__MINGW32__)
# define XMD_H 1 /* Avoid conflicting typedef for INT32 */
typedef unsigned char boolean;
+#define HAVE_BOOLEAN
#endif
#undef HAVE_STDLIB_H
#include "jpeglib.h"
*canvas_image,
*image;
- ssize_t
- y;
-
MagickBooleanType
status;
length;
ssize_t
- count;
+ count,
+ y;
unsigned char
*pixels;
register const PixelPacket
*restrict p;
- register ssize_t
- x;
-
register PixelPacket
*restrict q;
+ register ssize_t
+ x;
+
if (count != (ssize_t) length)
{
ThrowFileException(exception,CorruptImageError,
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
*/
static MagickBooleanType WriteRAWImage(const ImageInfo *image_info,Image *image)
{
- ssize_t
- y;
-
MagickOffsetType
scene;
register const PixelPacket
*p;
- ssize_t
- count;
-
size_t
length;
+ ssize_t
+ count,
+ y;
+
unsigned char
*pixels;
register ssize_t
i;
+ size_t
+ length;
+
ssize_t
count,
y;
- size_t
- length;
-
unsigned char
*pixels;
QuantumType
quantum_type;
+ size_t
+ length;
+
ssize_t
count,
y;
- size_t
- length;
-
unsigned char
*pixels;
length,
runlength;
- ssize_t
- y;
-
- ssize_t
- *scanlines;
-
MagickBooleanType
status;
*q;
ssize_t
- count;
+ count,
+ *scanlines,
+ y;
RLAInfo
rla_info;
{
case 0:
{
- q->red=ScaleCharToQuantum(byte);
+ SetRedPixelComponent(q,ScaleCharToQuantum(byte));
break;
}
case 1:
{
- q->green=ScaleCharToQuantum(byte);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(byte));
break;
}
case 2:
{
- q->blue=ScaleCharToQuantum(byte);
+ SetBluePixelComponent(q,ScaleCharToQuantum(byte));
break;
}
case 3:
default:
{
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(byte));
+ SetOpacityPixelComponent(q,QuantumRange-
+ ScaleCharToQuantum(byte));
break;
}
}
{
case 0:
{
- q->red=ScaleCharToQuantum(byte);
+ SetRedPixelComponent(q,ScaleCharToQuantum(byte));
break;
}
case 1:
{
- q->green=ScaleCharToQuantum(byte);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(byte));
break;
}
case 2:
{
- q->blue=ScaleCharToQuantum(byte);
+ SetBluePixelComponent(q,ScaleCharToQuantum(byte));
break;
}
case 3:
default:
{
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(byte));
+ SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(byte));
break;
}
}
}
}
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
operand,
status;
- ssize_t
- y;
-
MagickStatusType
flags;
register unsigned char
*p;
+ size_t
+ bits_per_pixel,
+ map_length,
+ number_colormaps,
+ number_planes,
+ one;
+
ssize_t
- count;
+ count,
+ y;
unsigned char
background_color[256],
plane,
*rle_pixels;
- size_t
- bits_per_pixel,
- map_length,
- number_colormaps,
- number_planes,
- one;
-
/*
Open image file.
*/
for (i=0; i < (ssize_t) operand; i++)
{
pixel=(unsigned char) ReadBlobByte(image);
- if ((y < (ssize_t) image->rows) && ((x+i) < (ssize_t) image->columns))
+ if ((y < (ssize_t) image->rows) &&
+ ((x+i) < (ssize_t) image->columns))
*p=pixel;
p+=number_planes;
}
x*number_planes+plane;
for (i=0; i < (ssize_t) operand; i++)
{
- if ((y < (ssize_t) image->rows) && ((x+i) < (ssize_t) image->columns))
+ if ((y < (ssize_t) image->rows) &&
+ ((x+i) < (ssize_t) image->columns))
*p=pixel;
p+=number_planes;
}
SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
if (image->matte != MagickFalse)
- SetOpacityPixelComponent(q,(QuantumRange-ScaleCharToQuantum(*p++)));
+ SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- indexes[x]=(IndexPacket) (*p++);
+ SetIndexPixelComponent(indexes+x,*p++);
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+ y,image->rows);
if (status == MagickFalse)
break;
}
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=image->colormap[*p++].red;
- q->green=image->colormap[*p++].green;
- q->blue=image->colormap[*p++].blue;
- SetOpacityPixelComponent(q,(QuantumRange-ScaleCharToQuantum(*p++)));
+ SetRedPixelComponenet(q,image->colormap[*p++].red);
+ SetGreenPixelComponenet(q,image->colormap[*p++].green);
+ SetBluePixelComponenet(q,image->colormap[*p++].blue);
+ SetOpacityPixelComponent(q,QuantumRange-
+ ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+ y,image->rows);
if (status == MagickFalse)
break;
}
if(binar[z])
{
- q->red=ScaleCharToQuantum(colour_palette[3*ink]);
- q->green=ScaleCharToQuantum(colour_palette[1+(3*ink)]);
- q->blue=ScaleCharToQuantum(colour_palette[2+(3*ink)]);
+ SetRedPixelComponent(q,ScaleCharToQuantum(
+ colour_palette[3*ink]));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(
+ colour_palette[1+(3*ink)]));
+ SetBluePixelComponent(q,ScaleCharToQuantum(
+ colour_palette[2+(3*ink)]));
} else {
- q->red=ScaleCharToQuantum(colour_palette[3*paper]);
- q->green=ScaleCharToQuantum(colour_palette[1+(3*paper)]);
- q->blue=ScaleCharToQuantum(colour_palette[2+(3*paper)]);
+ SetRedPixelComponent(q,ScaleCharToQuantum(
+ colour_palette[3*paper]));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(
+ colour_palette[1+(3*paper)]));
+ SetBluePixelComponent(q,ScaleCharToQuantum(
+ colour_palette[2+(3*paper)]));
}
pix++;
Image
*image;
- ssize_t
- y;
-
MagickBooleanType
status;
*q;
ssize_t
- count;
+ count,
+ y;
unsigned char
buffer[768];
{
case 0:
{
- q->red=pixel;
- q->green=pixel;
- q->blue=pixel;
+ SetRedPixelComponent(q,pixel);
+ SetGreenPixelComponent(q,pixel);
+ SetBluePixelComponent(q,pixel);
break;
}
case 1:
{
- q->green=pixel;
+ SetGreenPixelComponent(q,pixel);
break;
}
case 2:
{
- q->blue=pixel; break;
+ SetBluePixelComponent(q,pixel);
break;
}
case 3:
{
if (image->colorspace == CMYKColorspace)
- indexes[x]=(IndexPacket) pixel;
+ SetBlackPixelComponent(indexes+x,pixel);
break;
}
}
(void) ReadBlobByte(image); /* pad */
}
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
*p,
*q;
- ssize_t
- count;
-
size_t
pixel;
+ ssize_t
+ count;
+
p=packets;
q=pixels;
if (bytes_per_pixel == 2)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=ScaleShortToQuantum((unsigned short)
- ((*(p+0) << 8) | (*(p+1))));
- q->green=ScaleShortToQuantum((unsigned short)
- ((*(p+2) << 8) | (*(p+3))));
- q->blue=ScaleShortToQuantum((unsigned short)
- ((*(p+4) << 8) | (*(p+5))));
+ SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ ((*(p+0) << 8) | (*(p+1)))));
+ SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ ((*(p+2) << 8) | (*(p+3)))));
+ SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+ ((*(p+4) << 8) | (*(p+5)))));
SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(
+ SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(
(unsigned short) ((*(p+6) << 8) | (*(p+7)))));
p+=8;
q++;
q->blue=ScaleCharToQuantum(*(p+2));
SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(*(p+3)));
+ SetOpacityPixelComponent(q,QuantumRange-
+ ScaleCharToQuantum(*(p+3)));
p+=4;
q++;
}
{
quantum=(*p << 8);
quantum|=(*(p+1));
- indexes[x]=(IndexPacket) quantum;
+ SetIndexPixelComponent(indexes+x,quantum);
p+=8;
q++;
}
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
- indexes[x]=(IndexPacket) (*p);
+ SetIndexPixelComponent(indexes+x,*p);
p+=4;
q++;
}
const char
*value;
- ssize_t
- y,
- z;
-
MagickBooleanType
status;
register unsigned char
*q;
+ ssize_t
+ y,
+ z;
+
unsigned char
*iris_pixels,
*packets;
*q++=ScaleQuantumToChar(GetRedPixelComponent(p));
*q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
*q++=ScaleQuantumToChar(GetBluePixelComponent(p));
- *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
+ *q++=ScaleQuantumToChar(GetAlphaPixelComponent(p));
p++;
}
else
*q++=ScaleQuantumToShort(GetRedPixelComponent(p));
*q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
*q++=ScaleQuantumToShort(GetBluePixelComponent(p));
- *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
+ *q++=ScaleQuantumToShort(GetAlphaPixelComponent(p));
p++;
}
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
}
default:
{
- ssize_t
- offset,
- *offsets;
-
size_t
length,
- number_packets;
-
- size_t
+ number_packets,
*runlength;
+ ssize_t
+ offset,
+ *offsets;
+
/*
Convert SGI uncompressed pixels.
*/
{
#define GetBit(alpha,i) MagickMin((((size_t) (alpha) >> (size_t) \
(i)) & 0x01),16)
-#define SetBit(alpha,i,set) (alpha)=(IndexPacket) ((set) != 0 ? \
- (size_t) (alpha) | (one << (size_t) (i)) : (size_t) \
- (alpha) & ~(one << (size_t) (i)))
+#define SetBit(indexes,i,set) SetIndexPixelComponent(indexes,((set) != 0 ? \
+ (size_t) GetIndexPixelComponent(indexes) | (one << (size_t) (i)) : (size_t) \
+ GetIndexPixelComponent(indexes) & ~(one << (size_t) (i))))
Image
*image,
{
case 0:
{
- SetBit(*indexes,i,GetBit(pixel.red,j));
+ SetBit(indexes,i,GetBit(pixel.red,j));
break;
}
case 1:
{
- SetBit(*indexes,i,GetBit(pixel.green,j));
+ SetBit(indexes,i,GetBit(pixel.green,j));
break;
}
case 2:
{
- SetBit(*indexes,i,GetBit(pixel.blue,j));
+ SetBit(indexes,i,GetBit(pixel.blue,j));
break;
}
}
const size_t length,unsigned char *pixels,size_t maxpixels)
{
register const unsigned char
- *p, *l;
+ *l,
+ *p;
register unsigned char
*q;
int
bit;
- ssize_t
- y;
-
MagickBooleanType
status;
length;
ssize_t
- count;
+ count,
+ y;
SUNInfo
sun_info;
for (x=0; x < ((ssize_t) image->columns-7); x+=8)
{
for (bit=7; bit >= 0; bit--)
- indexes[x+7-bit]=(IndexPacket) ((*p) & (0x01 << bit) ? 0x00 : 0x01);
+ SetIndexPixelComponent(indexes+x+7-bit,((*p) & (0x01 << bit) ?
+ 0x00 : 0x01));
p++;
}
if ((image->columns % 8) != 0)
{
for (bit=7; bit >= (ssize_t) (8-(image->columns % 8)); bit--)
- indexes[x+7-bit]=(IndexPacket)
- ((*p) & (0x01 << bit) ? 0x00 : 0x01);
+ SetIndexPixelComponent(indexes+x+7-bit,(*p) & (0x01 << bit) ?
+ 0x00 : 0x01);
p++;
}
if ((((image->columns/8)+(image->columns % 8 ? 1 : 0)) % 2) != 0)
break;
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- indexes[x]=(IndexPacket) (*p++);
+ SetIndexPixelComponent(indexes+x,*p++);
if ((image->columns % 2) != 0)
p++;
if (SyncAuthenticPixels(image,exception) == MagickFalse)
for (x=0; x < (ssize_t) image->columns; x++)
{
if (image->matte != MagickFalse)
- SetOpacityPixelComponent(q,(QuantumRange-ScaleCharToQuantum(*p++)));
+ SetOpacityPixelComponent(q,(QuantumRange-
+ ScaleCharToQuantum(*p++)));
if (sun_info.type == RT_STANDARD)
{
SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
}
if (image->colors != 0)
{
- q->red=image->colormap[(ssize_t) q->red].red;
- q->green=image->colormap[(ssize_t) q->green].green;
- q->blue=image->colormap[(ssize_t) q->blue].blue;
+ SetRedPixelComponent(q,image->colormap[(ssize_t)
+ q->red].red);
+ SetGreenPixelComponent(q,image->colormap[(ssize_t)
+ q->green].green);
+ SetBluePixelComponent(q,image->colormap[(ssize_t)
+ q->blue].blue);
}
q++;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
if (image->matte != MagickFalse)
- *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
+ *q++=ScaleQuantumToChar(GetAlphaPixelComponent(p));
*q++=ScaleQuantumToChar(GetRedPixelComponent(p));
*q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
*q++=ScaleQuantumToChar(GetBluePixelComponent(p));
Dump colormap to file.
*/
for (i=0; i < (ssize_t) image->colors; i++)
- (void) WriteBlobByte(image,
- ScaleQuantumToChar(image->colormap[i].red));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(
+ image->colormap[i].red));
for (i=0; i < (ssize_t) image->colors; i++)
- (void) WriteBlobByte(image,
- ScaleQuantumToChar(image->colormap[i].green));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(
+ image->colormap[i].green));
for (i=0; i < (ssize_t) image->colors; i++)
- (void) WriteBlobByte(image,
- ScaleQuantumToChar(image->colormap[i].blue));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(
+ image->colormap[i].blue));
/*
Convert PseudoClass packet to SUN colormapped pixel.
*/
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
- (void) WriteBlobByte(image,(unsigned char) indexes[x]);
+ (void) WriteBlobByte(image,(unsigned char)
+ GetIndexPixelComponent(indexes+x));
p++;
}
if (image->columns & 0x01)
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
IndexPacket
index;
- ssize_t
- y;
-
MagickBooleanType
status;
register IndexPacket
*indexes;
+ register PixelPacket
+ *q;
+
register ssize_t
i,
x;
- register PixelPacket
- *q;
+ size_t
+ base,
+ flag,
+ offset,
+ real,
+ skip;
ssize_t
- count;
+ count,
+ y;
TGAInfo
tga_info;
k,
runlength;
- size_t
- base,
- flag,
- offset,
- real,
- skip;
-
/*
Open image file.
*/
if (status == MagickFalse)
ThrowReaderException(CorruptImageError,"UnableToReadImageData");
if (image->storage_class == PseudoClass)
- indexes[x]=index;
+ SetIndexPixelComponent(indexes+x,index);
SetRedPixelComponent(q,pixel.red);
SetGreenPixelComponent(q,pixel.green);
SetBluePixelComponent(q,pixel.blue);
const char
*value;
- ssize_t
- y;
-
MagickBooleanType
status;
*q;
ssize_t
- count;
+ count,
+ y;
TargaInfo
targa_info;
*q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
*q++=ScaleQuantumToChar(GetRedPixelComponent(p));
if (image->matte != MagickFalse)
- *q++=(unsigned char) ScaleQuantumToChar((Quantum)
- (GetAlphaPixelComponent(p)));
+ *q++=(unsigned char) ScaleQuantumToChar(
+ GetAlphaPixelComponent(p));
if (image->colorspace == CMYKColorspace)
*q++=ScaleQuantumToChar(indexes[x]);
}
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
register ssize_t
i;
- ssize_t
- offset;
-
size_t
length;
+ ssize_t
+ offset;
+
unsigned char
magick[MaxTextExtent];
Image
*image;
- ssize_t
- y;
-
MagickBooleanType
associated_alpha,
debug,
size_t
length,
+ lsb_first,
pad;
+ ssize_t
+ y;
+
TIFF
*tiff;
unsigned char
*pixels;
- size_t
- lsb_first;
-
/*
Open image.
*/
p=(unsigned char *) (((uint32 *) pixels)+image->columns*i);
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=ScaleCharToQuantum((unsigned char) (TIFFGetR(*p)));
- q->green=ScaleCharToQuantum((unsigned char) (TIFFGetG(*p)));
- q->blue=ScaleCharToQuantum((unsigned char) (TIFFGetB(*p)));
+ SetRedPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ (TIFFGetR(*p))));
+ SetGreenPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ (TIFFGetG(*p))));
+ SetBluePixelComponent(q,ScaleCharToQuantum((unsigned char)
+ (TIFFGetB(*p))));
if (image->matte != MagickFalse)
- q->opacity=ScaleCharToQuantum((unsigned char) (TIFFGetA(*p)));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ (TIFFGetA(*p))));
p++;
q++;
}
if (image->matte != MagickFalse)
for (column=columns_remaining; column > 0; column--)
{
- q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
- q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
- q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(
+ SetRedPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetR(*p)));
+ SetGreenPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetG(*p)));
+ SetBluePixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetB(*p)));
+ SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(
(unsigned char) TIFFGetA(*p)));
q++;
p++;
else
for (column=columns_remaining; column > 0; column--)
{
- q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
- q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
- q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
+ SetRedPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetR(*p)));
+ SetGreenPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetG(*p)));
+ SetBluePixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetB(*p)));
q++;
p++;
}
q+=image->columns-1;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
- q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
- q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
+ SetRedPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetR(*p)));
+ SetBluePixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetG(*p)));
+ SetGreenPixelComponent(q,ScaleCharToQuantum((unsigned char)
+ TIFFGetB(*p)));
if (image->matte != MagickFalse)
- q->opacity=(Quantum) (QuantumRange-
- ScaleCharToQuantum((unsigned char) TIFFGetA(*p)));
+ SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(
+ (unsigned char) TIFFGetA(*p)));
p--;
q--;
}
int32
status;
- ssize_t
- bytes_per_pixel,
- j,
- k,
- l;
-
register ssize_t
i;
number_tiles,
tile_width;
+ ssize_t
+ bytes_per_pixel,
+ j,
+ k,
+ l;
+
if (TIFFIsTiled(tiff) == 0)
return(TIFFWriteScanline(tiff,tiff_info->scanline,(uint32) row,sample));
/*
(void) CopyMagickMemory(tiff_info->scanlines+i,(char *) tiff_info->scanline,
(size_t) TIFFScanlineSize(tiff));
if (((size_t) (row % tiff_info->tile_geometry.height) !=
- (tiff_info->tile_geometry.height-1)) && (row != (ssize_t) (image->rows-1)))
+ (tiff_info->tile_geometry.height-1)) &&
+ (row != (ssize_t) (image->rows-1)))
return(0);
/*
Write tile to TIFF image.
EndianType
endian_type;
- ssize_t
- y;
-
MagickBooleanType
debug,
status;
length,
lsb_first;
+ ssize_t
+ y;
+
TIFF
*tiff;
bits_per_pixel,
has_clut;
- ssize_t
- y;
-
MagickBooleanType
status;
register unsigned char
*p;
+ size_t
+ bytes_per_line,
+ height,
+ image_size,
+ pixel_mode,
+ width;
+
ssize_t
- count;
+ count,
+ y;
unsigned char
*tim_data,
unsigned short
word;
- size_t
- bytes_per_line,
- height,
- image_size,
- pixel_mode,
- width;
-
/*
Open image file.
*/
p=tim_pixels+y*bytes_per_line;
for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
- indexes[x]=(IndexPacket) ((*p) & 0x0f);
- indexes[x+1]=(IndexPacket) ((*p >> 4) & 0x0f);
+ SetIndexPixelComponent(indexes+x,(*p) & 0x0f);
+ SetIndexPixelComponent(indexes+x+1,(*p >> 4) & 0x0f);
p++;
}
if ((image->columns % 2) != 0)
{
- indexes[x]=(IndexPacket) ((*p >> 4) & 0x0f);
+ SetIndexPixelComponent(indexes+x,(*p >> 4) & 0x0f);
p++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
indexes=GetAuthenticIndexQueue(image);
p=tim_pixels+y*bytes_per_line;
for (x=0; x < (ssize_t) image->columns; x++)
- indexes[x]=(*p++);
+ SetIndexPixelComponent(indexes+x,*p++);
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
word=(*p++);
word|=(*p++ << 8);
- q->blue=ScaleCharToQuantum(ScaleColor5to8((1UL*word >> 10) & 0x1f));
- q->green=ScaleCharToQuantum(ScaleColor5to8((1UL*word >> 5) & 0x1f));
- q->red=ScaleCharToQuantum(ScaleColor5to8(1UL*word & 0x1f));
+ SetBluePixelComponent(q,ScaleCharToQuantum(ScaleColor5to8(
+ (1UL*word >> 10) & 0x1f)));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(ScaleColor5to8(
+ (1UL*word >> 5) & 0x1f)));
+ SetRedPixelComponent(q,ScaleCharToQuantum(ScaleColor5to8(
+ (1UL*word >> 0) & 0x1f)));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
Image
*image;
- ssize_t
- y;
-
MagickBooleanType
status;
register PixelPacket
*q;
+ ssize_t
+ y;
+
/*
Open image file.
*/
Image
*texture;
- ssize_t
- offset;
-
MagickBooleanType
status;
RectangleInfo
page;
+ ssize_t
+ offset;
+
TypeMetric
metrics;
/*
Initialize Image structure.
*/
- image->columns=(size_t) floor((((double) page.width*
- image->x_resolution)/delta.x)+0.5);
- image->rows=(size_t) floor((((double) page.height*
- image->y_resolution)/delta.y)+0.5);
+ image->columns=(size_t) floor((((double) page.width*image->x_resolution)/
+ delta.x)+0.5);
+ image->rows=(size_t) floor((((double) page.height*image->y_resolution)/
+ delta.y)+0.5);
image->page.x=0;
image->page.y=0;
texture=(Image *) NULL;
q=GetAuthenticPixels(image,x_offset,y_offset,1,1,exception);
if (q == (PixelPacket *) NULL)
continue;
- q->red=ScaleAnyToQuantum(pixel.red,range);
- q->green=ScaleAnyToQuantum(pixel.green,range);
- q->blue=ScaleAnyToQuantum(pixel.blue,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel.red,range));
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel.green,range));
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel.blue,range));
if (image->colorspace == CMYKColorspace)
{
indexes=GetAuthenticIndexQueue(image);
- *indexes=ScaleAnyToQuantum(pixel.index,range);
+ SetIndexPixelComponent(indexes,ScaleAnyToQuantum(pixel.index,
+ range));
}
if (image->matte != MagickFalse)
- q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel.opacity,
- range));
+ SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(
+ pixel.opacity,range));
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
colorspace[MaxTextExtent],
tuple[MaxTextExtent];
- ssize_t
- y;
-
MagickBooleanType
status;
register ssize_t
x;
+ ssize_t
+ y;
+
/*
Open output image file.
*/
int
j;
- ssize_t
- k,
- y;
-
MagickBooleanType
status,
transparent;
i,
x;
- static const char
- Cixel[MaxCixels+1] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjk"
- "lzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";
-
size_t
characters_per_pixel,
colors;
+ ssize_t
+ k,
+ y;
+
+ static const char
+ Cixel[MaxCixels+1] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjk"
+ "lzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";
+
/*
Open output image file.
*/
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- matte_image[i]=(unsigned char)
- (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ? 1 : 0);
+ matte_image[i]=(unsigned char) (GetOpacityPixelComponent(p) ==
+ (Quantum) TransparentOpacity ? 1 : 0);
if (matte_image[i] != 0)
transparent=MagickTrue;
i++;
for (x=0; x < (ssize_t) image->columns; x++)
{
if (matte_image[i] != 0)
- indexes[x]=(IndexPacket) image->colors;
+ SetIndexPixelComponent(indexes+x,image->colors);
p++;
}
}
symbol[0]=Cixel[k];
for (j=1; j < (int) characters_per_pixel; j++)
{
- k=(((int) indexes[x]-k)/MaxCixels) % MaxCixels;
+ k=(((int) GetIndexPixelComponent(indexes+x)-k)/MaxCixels) % MaxCixels;
symbol[j]=Cixel[k];
}
symbol[j]='\0';
(y == (ssize_t) (image->rows-1) ? ");" : ","));
(void) WriteBlobString(image,buffer);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
Image
*image;
- ssize_t
- y;
-
MagickBooleanType
status;
register PixelPacket
*q;
+ ssize_t
+ y;
+
unsigned char
u,
v,
y1=(unsigned char) ReadBlobByte(image);
v=(unsigned char) ReadBlobByte(image);
y2=(unsigned char) ReadBlobByte(image);
- q->red=ScaleCharToQuantum(y1);
- q->green=ScaleCharToQuantum(u);
- q->blue=ScaleCharToQuantum(v);
+ SetRedPixelComponent(q,ScaleCharToQuantum(y1));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(u));
+ SetBluePixelComponent(q,ScaleCharToQuantum(v));
q++;
- q->red=ScaleCharToQuantum(y2);
- q->green=ScaleCharToQuantum(u);
- q->blue=ScaleCharToQuantum(v);
+ SetRedPixelComponent(q,ScaleCharToQuantum(y2));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(u));
+ SetBluePixelComponent(q,ScaleCharToQuantum(v));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
Image
*uyvy_image;
- ssize_t
- y;
-
MagickBooleanType
full,
status;
register ssize_t
x;
+ ssize_t
+ y;
+
/*
Open output image file.
*/
(void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.green));
(void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.red));
(void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.blue));
- (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(
+ GetRedPixelComponent(p)));
}
pixel.red=(double) GetRedPixelComponent(p);
pixel.green=(double) GetGreenPixelComponent(p);
p++;
}
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
int
c;
- ssize_t
- y;
-
MagickBooleanType
status,
value_expected;
length;
ssize_t
- count;
+ count,
+ y;
unsigned char
*pixels;
register const PixelPacket
*p;
- ssize_t
- count;
-
size_t
length;
+ ssize_t
+ count;
+
unsigned char
*pixels;
int
bit;
- ssize_t
- y;
-
MagickBooleanType
status;
register unsigned char
*p;
- ssize_t
- count;
-
- unsigned char
- buffer[7],
- *viff_pixels;
-
size_t
bytes_per_pixel,
lsb_first,
max_packets,
quantum;
+ ssize_t
+ count,
+ y;
+
+ unsigned char
+ buffer[7],
+ *viff_pixels;
+
ViffInfo
viff_info;
(void) ReadBlobByte(image);
image->columns=viff_info.rows;
image->rows=viff_info.columns;
- image->depth=viff_info.x_bits_per_pixel <= 8 ? 8UL : MAGICKCORE_QUANTUM_DEPTH;
+ image->depth=viff_info.x_bits_per_pixel <= 8 ? 8UL :
+ MAGICKCORE_QUANTUM_DEPTH;
/*
Verify that we can read this VIFF image.
*/
{
quantum=(size_t) indexes[x+bit];
quantum|=0x01;
- indexes[x+bit]=(IndexPacket) quantum;
+ SetIndexPixelComponent(indexes+x+bit,quantum);
}
p++;
}
{
quantum=(size_t) indexes[x+bit];
quantum|=0x01;
- indexes[x+bit]=(IndexPacket) quantum;
+ SetIndexPixelComponent(indexes+x+bit,quantum);
}
p++;
}
break;
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- indexes[x]=(IndexPacket) (*p++);
+ SetIndexPixelComponent(indexes+x,*p++);
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
for (x=0; x < (ssize_t) image->columns; x++)
{
SetRedPixelComponent(q,ScaleCharToQuantum(*p));
- q->green=ScaleCharToQuantum(*(p+number_pixels));
- q->blue=ScaleCharToQuantum(*(p+2*number_pixels));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*(p+number_pixels)));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*(p+2*number_pixels)));
if (image->colors != 0)
{
- q->red=image->colormap[(ssize_t) q->red].red;
- q->green=image->colormap[(ssize_t) q->green].green;
- q->blue=image->colormap[(ssize_t) q->blue].blue;
+ SetRedPixelComponent(q,image->colormap[(ssize_t)
+ q->red].red);
+ SetGreenPixelComponent(q,image->colormap[(ssize_t)
+ q->green].green);
+ SetBluePixelComponent(q,image->colormap[(ssize_t)
+ q->blue].blue);
}
- q->opacity=(Quantum) (image->matte ? QuantumRange-
- ScaleCharToQuantum(*(p+number_pixels*3)) : OpaqueOpacity);
+ SetOpacityPixelComponent(q,image->matte != MagickFalse ?
+ QuantumRange-ScaleCharToQuantum(*(p+number_pixels*3)) :
+ OpaqueOpacity);
p++;
q++;
}
const char
*value;
- ssize_t
- y;
-
MagickBooleanType
status;
register unsigned char
*q;
+ ssize_t
+ y;
+
unsigned char
buffer[8],
*viff_pixels;
*viff_info.comment='\0';
value=GetImageProperty(image,"comment");
if (value != (const char *) NULL)
- (void) CopyMagickString(viff_info.comment,value,MagickMin(strlen(value),511)+1);
+ (void) CopyMagickString(viff_info.comment,value,MagickMin(strlen(value),
+ 511)+1);
viff_info.rows=image->columns;
viff_info.columns=image->rows;
viff_info.subrows=0;
int
byte;
- ssize_t
- y;
-
MagickBooleanType
status;
register PixelPacket
*q;
+ ssize_t
+ y;
+
unsigned char
bit;
if (byte == EOF)
ThrowReaderException(CorruptImageError,"CorruptImage");
}
- indexes[x]=(IndexPacket) ((byte & (0x01 << (7-bit))) ? 1 : 0);
+ SetIndexPixelComponent(indexes+x,(byte & (0x01 << (7-bit))) ? 1 : 0);
bit++;
if (bit == 8)
bit=0;
static MagickBooleanType WriteWBMPImage(const ImageInfo *image_info,
Image *image)
{
- ssize_t
- y;
-
MagickBooleanType
status;
register ssize_t
x;
+ ssize_t
+ y;
+
unsigned char
bit,
byte;
if (bit != 0)
(void) WriteBlobByte(image,byte);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=ScaleQuantumToChar(GetBluePixelComponent(p));
if (image->matte != MagickFalse)
*q++=ScaleQuantumToChar((Quantum) (QuantumRange-
- (image->matte != MagickFalse ? GetOpacityPixelComponent(p) : OpaqueOpacity)));
+ (image->matte != MagickFalse ? GetOpacityPixelComponent(p) :
+ OpaqueOpacity)));
p++;
}
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
Image
*image;
- ssize_t
- y;
-
MagickBooleanType
status;
short int
hex_digits[256];
- size_t
- length;
-
- unsigned char
- *data;
-
size_t
bit,
byte,
bytes_per_line,
+ length,
padding,
value,
version;
+ ssize_t
+ y;
+
+ unsigned char
+ *data;
+
unsigned long
height,
width;
{
if (bit == 0)
byte=(size_t) (*p++);
- indexes[x]=(IndexPacket) ((byte & 0x01) != 0 ? 0x01 : 0x00);
+ SetIndexPixelComponent(indexes+x,(byte & 0x01) != 0 ? 0x01 : 0x00);
bit++;
byte>>=1;
if (bit == 8)
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
basename[MaxTextExtent],
buffer[MaxTextExtent];
- ssize_t
- y;
-
MagickBooleanType
status;
register ssize_t
x;
- ssize_t
- count;
-
size_t
bit,
byte;
+ ssize_t
+ count,
+ y;
+
/*
Open output image file.
*/
byte=0;
};
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
MagickPixelPacket
color;
- ssize_t
- y;
-
PixelPacket
pixel;
register PixelPacket
*q;
+ ssize_t
+ y;
+
/*
Initialize Image structure.
*/
{
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- indexes[x]=index;
+ SetIndexPixelComponetn(indexes+x,index);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
for (x=0; x < (ssize_t) tile_image->columns; x++)
{
- q->red=ScaleCharToQuantum(*graydata);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*graydata));
SetGreenPixelComponent(q,GetRedPixelComponent(q));
SetBluePixelComponent(q,GetRedPixelComponent(q));
- q->opacity=ScaleCharToQuantum((unsigned char) (255-
- inLayerInfo->opacity));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(
+ (unsigned char) (255-inLayerInfo->opacity)));
graydata++;
q++;
}
{
for (x=0; x < (ssize_t) tile_image->columns; x++)
{
- q->red=ScaleCharToQuantum(xcfdata->red);
- q->green=ScaleCharToQuantum(xcfdata->green);
- q->blue=ScaleCharToQuantum(xcfdata->blue);
- q->opacity=(Quantum) (xcfdata->opacity == 0U ? TransparentOpacity :
- ScaleCharToQuantum((unsigned char) (255-inLayerInfo->opacity)));
+ SetRedPixelComponent(q,ScaleCharToQuantum(xcfdata->red));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(xcfdata->green));
+ SetBluePixelComponent(q,ScaleCharToQuantum(xcfdata->blue));
+ SetOpacityPixelComponent(q,xcfdata->opacity == 0U ?
+ TransparentOpacity : ScaleCharToQuantum((unsigned char) (255-
+ inLayerInfo->opacity)));
xcfdata++;
q++;
}
ExceptionInfo
*exception;
- ssize_t
- i,
- j;
-
MagickOffsetType
size;
register PixelPacket
*q;
- ssize_t
- bytes_per_pixel,
- count;
-
size_t
length;
+ ssize_t
+ bytes_per_pixel,
+ count,
+ i,
+ j;
+
unsigned char
data,
pixel,
{
case 0:
{
- q->red=ScaleCharToQuantum(data);
+ SetRedPixelComponent(q,ScaleCharToQuantum(data));
if (inDocInfo->image_type == GIMP_GRAY)
{
- q->green=ScaleCharToQuantum(data);
- q->blue=ScaleCharToQuantum(data);
- q->opacity=ScaleCharToQuantum((unsigned char) (255-
- inLayerInfo->opacity));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(data));
+ SetBluePixelComponent(q,ScaleCharToQuantum(data));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(
+ (unsigned char) (255-inLayerInfo->opacity)));
}
else
{
- q->green= q->red;
- q->blue= q->red;
- q->opacity=ScaleCharToQuantum((unsigned char) (255-
- inLayerInfo->opacity));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(
+ (unsigned char) (255-inLayerInfo->opacity)));
}
break;
}
case 1:
{
- q->green=ScaleCharToQuantum(data);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(data));
break;
}
case 2:
{
- q->blue=ScaleCharToQuantum(data);
+ SetBluePixelComponent(q,ScaleCharToQuantum(data));
break;
}
case 3:
{
- q->opacity=(Quantum) (data == 0 ? TransparentOpacity :
+ SetOpacityPixelComponent(q,data == 0 ? TransparentOpacity :
ScaleCharToQuantum((unsigned char) (255-
inLayerInfo->opacity)));
break;
{
case 0:
{
- q->red=ScaleCharToQuantum(data);
+ SetReadPixelComponent(q,ScaleCharToQuantum(data));
if (inDocInfo->image_type == GIMP_GRAY)
{
- q->green=ScaleCharToQuantum(data);
- q->blue=ScaleCharToQuantum(data);
- q->opacity=ScaleCharToQuantum((unsigned char) (255-
- inLayerInfo->opacity));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(data));
+ SetBluePixelComponent(q,ScaleCharToQuantum(data));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(
+ (unsigned char) (255-inLayerInfo->opacity)));
}
else
{
SetGreenPixelComponent(q,GetRedPixelComponent(q));
SetBluePixelComponent(q,GetRedPixelComponent(q));
- q->opacity=ScaleCharToQuantum((unsigned char) (255-
- inLayerInfo->opacity));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(
+ (unsigned char) (255-inLayerInfo->opacity)));
}
break;
}
case 1:
{
- q->green=ScaleCharToQuantum(data);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(data));
break;
}
case 2:
{
- q->blue=ScaleCharToQuantum(data);
+ SetBluePixelComponent(q,ScaleCharToQuantum(data));
break;
}
case 3:
{
- q->opacity=(Quantum) (data == 0 ? TransparentOpacity :
+ SetOpacityPixelComponent(q,data == 0 ? TransparentOpacity :
ScaleCharToQuantum((unsigned char) (255-
inLayerInfo->opacity)));
break;
i;
size_t
+ image_type,
length;
ssize_t
count;
- size_t
- image_type;
-
XCFDocInfo
doc_info;
Image
*image;
- ssize_t
- j,
- y;
-
MagickBooleanType
active,
status;
*xpm_colors;
ssize_t
- count;
+ count,
+ j,
+ y;
unsigned long
colors,
(void) CopyXPMColor(key,p,(size_t) width);
j=(ssize_t) GetValueFromSplayTree(xpm_colors,key);
if (image->storage_class == PseudoClass)
- indexes[x]=(IndexPacket) j;
+ SetIndexPixelComponent(indexes+x,j);
*r=image->colormap[j];
r++;
p+=width;
ImageInfo
*blob_info;
- ssize_t
- j,
- k,
- y;
-
MagickBooleanType
status,
transparent;
characters_per_pixel,
colors;
+ ssize_t
+ j,
+ k,
+ y;
+
/*
Open output image file.
*/
for (x=0; x < (ssize_t) picon->columns; x++)
{
if (q->opacity == (Quantum) TransparentOpacity)
- indexes[x]=(IndexPacket) picon->colors;
+ SetIndexPixelComponent(indexes+x,picon->colors);
q++;
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
(void) WriteBlobString(image,"\"");
for (x=0; x < (ssize_t) picon->columns; x++)
{
- k=((ssize_t) indexes[x] % MaxCixels);
+ k=((ssize_t) GetIndexPixelComponent(indexes+x) % MaxCixels);
symbol[0]=Cixel[k];
for (j=1; j < (ssize_t) characters_per_pixel; j++)
{
- k=(((int) indexes[x]-k)/MaxCixels) % MaxCixels;
+ k=(((int) GetIndexPixelComponent(indexes+x)-k)/MaxCixels) % MaxCixels;
symbol[j]=Cixel[k];
}
symbol[j]='\0';
name[MaxTextExtent],
symbol[MaxTextExtent];
- ssize_t
- j,
- k,
- opacity,
- y;
-
MagickBooleanType
status;
size_t
characters_per_pixel;
+ ssize_t
+ j,
+ k,
+ opacity,
+ y;
+
/*
Open output image file.
*/
(void) WriteBlobString(image,"\"");
for (x=0; x < (ssize_t) image->columns; x++)
{
- k=((ssize_t) indexes[x] % MaxCixels);
+ k=((ssize_t) GetIndexPixelComponent(indexes+x) % MaxCixels);
symbol[0]=Cixel[k];
for (j=1; j < (ssize_t) characters_per_pixel; j++)
{
- k=(((int) indexes[x]-k)/MaxCixels) % MaxCixels;
+ k=(((int) GetIndexPixelComponent(indexes+x)-k)/MaxCixels) % MaxCixels;
symbol[j]=Cixel[k];
}
symbol[j]='\0';
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
x_status;
- ssize_t
- y;
-
MagickBooleanType
authentic_colormap;
pixel;
size_t
- length;
+ length,
+ lsb_first;
ssize_t
- count;
-
- size_t
- lsb_first;
+ count,
+ y;
XColor
*colors;
{
pixel=XGetPixel(ximage,(int) x,(int) y);
index=(IndexPacket) ((pixel >> red_shift) & red_mask);
- q->red=ScaleShortToQuantum(colors[(ssize_t) index].red);
+ SetRedPixelComponent(q,ScaleShortToQuantum(colors[(ssize_t)
+ index].red));
index=(IndexPacket) ((pixel >> green_shift) & green_mask);
- q->green=ScaleShortToQuantum(colors[(ssize_t) index].green);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(colors[(ssize_t)
+ index].green));
index=(IndexPacket) ((pixel >> blue_shift) & blue_mask);
- q->blue=ScaleShortToQuantum(colors[(ssize_t) index].blue);
+ SetBluePixelComponent(q,ScaleShortToQuantum(colors[(ssize_t)
+ index].blue));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
pixel=XGetPixel(ximage,(int) x,(int) y);
color=(pixel >> red_shift) & red_mask;
color=(color*65535UL)/red_mask;
- q->red=ScaleShortToQuantum((unsigned short) color);
+ SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ color));
color=(pixel >> green_shift) & green_mask;
color=(color*65535UL)/green_mask;
- q->green=ScaleShortToQuantum((unsigned short) color);
+ SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ color));
color=(pixel >> blue_shift) & blue_mask;
color=(color*65535UL)/blue_mask;
- q->blue=ScaleShortToQuantum((unsigned short) color);
+ SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+ color));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
{
index=ConstrainColormapIndex(image,XGetPixel(ximage,(int) x,
(int) y));
- 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 (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
const char
*value;
- ssize_t
- y;
-
MagickBooleanType
status;
register unsigned char
*q;
- size_t
- length;
-
- unsigned char
- *pixels;
-
size_t
bits_per_pixel,
bytes_per_line,
+ length,
lsb_first,
scanline_pad;
+ ssize_t
+ y;
+
+ unsigned char
+ *pixels;
+
XWDFileHeader
xwd_info;
*q++='\0';
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
*canvas_image,
*image;
- ssize_t
- y;
-
MagickBooleanType
status;
register PixelPacket
*q;
- ssize_t
- count;
-
size_t
length;
+ ssize_t
+ count,
+ y;
+
unsigned char
*pixels;
static MagickBooleanType WriteYCBCRImage(const ImageInfo *image_info,
Image *image)
{
- ssize_t
- y;
-
MagickBooleanType
status;
register const PixelPacket
*p;
- ssize_t
- count;
-
size_t
length;
+ ssize_t
+ count,
+ y;
+
unsigned char
*pixels;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,quantum_type,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- RedQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,RedQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- GreenQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,GreenQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- BlueQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,BlueQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- RedQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,RedQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- GreenQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,GreenQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- BlueQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,BlueQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- RedQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,RedQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- GreenQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,GreenQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- BlueQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,BlueQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
InterlaceType
interlace;
- ssize_t
- horizontal_factor,
- vertical_factor,
- y;
-
MagickBooleanType
status;
*p;
ssize_t
- quantum;
-
- ssize_t
- count;
+ count,
+ horizontal_factor,
+ quantum,
+ vertical_factor,
+ y;
unsigned char
*scanline;
q->red=ScaleShortToQuantum(((*p) << 8) | *(p+1));
p+=2;
}
- q->green=(Quantum) 0;
- q->blue=(Quantum) 0;
+ SetGreenPixelComponent(q,0);
+ SetBluePixelComponent(q,0);
q++;
- q->green=0;
- q->blue=0;
+ SetGreenPixelComponent(q,0);
+ SetBluePixelComponent(q,0);
if (quantum == 1)
chroma_pixels->blue=ScaleCharToQuantum(*p++);
else
SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
else
{
- q->red=ScaleShortToQuantum(((*p) << 8) | *(p+1));
+ SetRedPixelComponent(q,ScaleShortToQuantum(((*p) << 8) |
+ *(p+1)));
p+=2;
}
chroma_pixels++;
SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
else
{
- q->red=ScaleShortToQuantum(((*p) << 8) | *(p+1));
+ SetRedPixelComponent(q,ScaleShortToQuantum(((*p) << 8) |
+ *(p+1)));
p+=2;
}
- q->green=0;
- q->blue=0;
+ SetGreenPixelComponent(q,0);
+ SetBluePixelComponent(q,0);
q++;
}
}
break;
for (x=0; x < (ssize_t) chroma_image->columns; x++)
{
- q->red=(Quantum) 0;
+ SetRedPixelComponent(q,0);
if (quantum == 1)
SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
else
{
- q->green=ScaleShortToQuantum(((*p) << 8) | *(p+1));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(((*p) << 8) |
+ *(p+1)));
p+=2;
}
- q->blue=(Quantum) 0;
+ SetBluePixelComponent(q,0);
q++;
}
if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
else
{
- q->blue=ScaleShortToQuantum(((*p) << 8) | *(p+1));
+ SetBluePixelComponent(q,ScaleShortToQuantum(((*p) << 8) |
+ *(p+1)));
p+=2;
}
q++;
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->green=chroma_pixels->green;
- q->blue=chroma_pixels->blue;
+ SetGreenPixelComponent(q,chroma_pixels->green);
+ SetBluePixelComponent(q,chroma_pixels->blue);
chroma_pixels++;
q++;
}
InterlaceType
interlace;
- ssize_t
- horizontal_factor,
- vertical_factor,
- y;
-
MagickBooleanType
status;
quantum,
width;
+ ssize_t
+ horizontal_factor,
+ vertical_factor,
+ y;
+
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
{
if (quantum == 1)
{
- (void) WriteBlobByte(image,ScaleQuantumToChar(s->green));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(
+ GetGreenPixelComponent(s)));
(void) WriteBlobByte(image,ScaleQuantumToChar(
GetRedPixelComponent(p)));
p++;
- (void) WriteBlobByte(image,ScaleQuantumToChar(s->blue));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(
+ GetBluePixelComponent(s)));
(void) WriteBlobByte(image,ScaleQuantumToChar(
GetRedPixelComponent(p)));
}
else
{
- (void) WriteBlobShort(image,ScaleQuantumToShort(s->green));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(
+ GetGreenPixelComponent(s)));
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetRedPixelComponent(p)));
p++;
- (void) WriteBlobShort(image,ScaleQuantumToShort(s->blue));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(
+ GetBluePixelComponent(s)));
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetRedPixelComponent(p)));
}
projects / imagemagick / commitdiff