*/
static inline IndexPacket PushColormapIndex(Image *image,
- const unsigned long index,MagickBooleanType *range_exception)
+ const size_t index,MagickBooleanType *range_exception)
{
if (index < image->colors)
return((IndexPacket) index);
}
static inline const unsigned char *PushQuantumPixel(
- QuantumState *quantum_state,const unsigned long depth,
- const unsigned char *pixels,unsigned long *quantum)
+ QuantumState *quantum_state,const size_t depth,
+ const unsigned char *pixels,unsigned int *quantum)
{
- register long
+ register ssize_t
i;
- register unsigned long
+ register size_t
quantum_bits;
*quantum=(QuantumAny) 0;
- for (i=(long) depth; i > 0L; )
+ for (i=(ssize_t) depth; i > 0L; )
{
if (quantum_state->bits == 0UL)
{
quantum_state->pixel=(*pixels++);
quantum_state->bits=8UL;
}
- quantum_bits=(unsigned long) i;
+ quantum_bits=(size_t) i;
if (quantum_bits > quantum_state->bits)
quantum_bits=quantum_state->bits;
- i-=quantum_bits;
+ i-=(ssize_t) quantum_bits;
quantum_state->bits-=quantum_bits;
- *quantum=(*quantum << quantum_bits) | ((quantum_state->pixel >>
- quantum_state->bits) &~ ((~0UL) << quantum_bits));
+ *quantum=(unsigned int) ((*quantum << quantum_bits) |
+ ((quantum_state->pixel >> quantum_state->bits) &~ ((~0UL) <<
+ quantum_bits)));
}
return(pixels);
}
static inline const unsigned char *PushQuantumLongPixel(
- QuantumState *quantum_state,const unsigned long depth,
- const unsigned char *pixels,unsigned long *quantum)
+ QuantumState *quantum_state,const size_t depth,
+ const unsigned char *pixels,unsigned int *quantum)
{
- register long
+ register ssize_t
i;
- register unsigned long
+ register size_t
quantum_bits;
*quantum=0UL;
- for (i=(long) depth; i > 0; )
+ for (i=(ssize_t) depth; i > 0; )
{
if (quantum_state->bits == 0)
{
pixels=PushLongPixel(quantum_state->endian,pixels,
&quantum_state->pixel);
- quantum_state->bits=32UL;
+ quantum_state->bits=32U;
}
- quantum_bits=(unsigned long) i;
+ quantum_bits=(size_t) i;
if (quantum_bits > quantum_state->bits)
quantum_bits=quantum_state->bits;
- *quantum|=(((quantum_state->pixel >> (32UL-quantum_state->bits)) &
+ *quantum|=(((quantum_state->pixel >> (32U-quantum_state->bits)) &
quantum_state->mask[quantum_bits]) << (depth-i));
- i-=quantum_bits;
+ i-=(ssize_t) quantum_bits;
quantum_state->bits-=quantum_bits;
}
return(pixels);
EndianType
endian;
- long
- bit;
-
MagickSizeType
number_pixels;
register IndexPacket
*restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
size_t
extent;
- unsigned long
+ ssize_t
+ bit;
+
+ unsigned int
pixel;
assert(image != (Image *) NULL);
pixels=GetQuantumPixels(quantum_info);
x=0;
p=pixels;
- number_pixels=GetImageExtent(image);
- q=GetAuthenticPixelQueue(image);
- indexes=GetAuthenticIndexQueue(image);
- if (image_view != (CacheView *) NULL)
+ if (image_view == (CacheView *) NULL)
+ {
+ number_pixels=GetImageExtent(image);
+ q=GetAuthenticPixelQueue(image);
+ indexes=GetAuthenticIndexQueue(image);
+ }
+ else
{
number_pixels=GetCacheViewExtent(image_view);
q=GetCacheViewAuthenticPixelQueue(image_view);
register unsigned char
pixel;
- for (x=0; x < ((long) number_pixels-7); x+=8)
+ for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
{
for (bit=0; bit < 8; bit++)
{
else
pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
0x00 : 0x01);
- indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x+bit]];
+ SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,
+ pixel,&range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x+bit));
q++;
}
p++;
}
- for (bit=0; bit < (long) (number_pixels % 8); bit++)
+ for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
{
if (quantum_info->min_is_white == MagickFalse)
pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
else
pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
0x00 : 0x01);
- indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x+bit]];
+ SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x+bit));
q++;
}
break;
register unsigned char
pixel;
- for (x=0; x < ((long) number_pixels-1); x+=2)
+ for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
q++;
pixel=(unsigned char) ((*p) & 0xf);
- indexes[x+1]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x+1]];
+ SetIndexPixelComponent(indexes+x+1,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x+1));
p++;
q++;
}
- for (bit=0; bit < (long) (number_pixels % 2); bit++)
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
{
pixel=(unsigned char) ((*p++ >> 4) & 0xf);
- indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x+bit]];
+ SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x+bit));
q++;
}
break;
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(
- (MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)),
- &range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+ ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),&range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
- &range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+ ClampToQuantum(pixel),&range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
- &range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+ ClampToQuantum(pixel),&range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p+=quantum_info->pad;
q++;
}
}
default:
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p+=quantum_info->pad;
q++;
}
register unsigned char
pixel;
- for (x=0; x < ((long) number_pixels-3); x+=4)
+ for (x=0; x < ((ssize_t) number_pixels-3); x+=4)
{
for (bit=0; bit < 8; bit+=2)
{
else
pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
0x00 : 0x01);
- indexes[x+bit/2]=(IndexPacket) (pixel == 0 ? 0 : 1);
- q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
- q->green=q->red;
- q->blue=q->red;
- q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit)))
- == 0 ? TransparentOpacity : OpaqueOpacity);
+ SetIndexPixelComponent(indexes+x+bit/2,pixel == 0 ? 0 : 1);
+ SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+ (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
q++;
}
}
- for (bit=0; bit < (long) (number_pixels % 4); bit+=2)
+ for (bit=0; bit < (ssize_t) (number_pixels % 4); bit+=2)
{
if (quantum_info->min_is_white == MagickFalse)
pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
else
pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
0x00 : 0x01);
- indexes[x+bit/2]=(IndexPacket) (pixel == 0 ? 0 : 1);
- q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
- q->green=q->red;
- q->blue=q->red;
- q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit))) ==
- 0 ? TransparentOpacity : OpaqueOpacity);
+ SetIndexPixelComponent(indexes+x+bit/2,pixel == 0 ? 0 : 1);
+ SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+ (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
q++;
}
break;
pixel;
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
pixel=(unsigned char) ((*p) & 0xf);
- q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+ SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p++;
q++;
}
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p=PushCharPixel(p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(
- (MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)),
- &range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+ ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),&range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
- (MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
- &range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+ ClampToQuantum(pixel),&range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p=PushLongPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
- &range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+ ClampToQuantum(pixel),&range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- indexes[x]=PushColormapIndex(image,pixel,&range_exception);
- *q=image->colormap[(long) indexes[x]];
+ SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+ &range_exception));
+ SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+ GetIndexPixelComponent(indexes+x));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+ SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
break;
}
+ case BGRQuantum:
+ {
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+ p=PushCharPixel(p,&pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
+ p=PushCharPixel(p,&pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ case 10:
+ {
+ range=GetQuantumRange(image->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
+ range));
+ SetGreenPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+ 0x3ff,range));
+ SetBluePixelComponent(q,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+ range));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32U)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ q++;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ q++;
+ }
+ break;
+ }
+ case 12:
+ {
+ range=GetQuantumRange(image->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ unsigned short
+ pixel;
+
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ switch (x % 3)
+ {
+ default:
+ case 0:
+ {
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ break;
+ }
+ case 1:
+ {
+ SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ break;
+ }
+ case 2:
+ {
+ SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ q++;
+ break;
+ }
+ }
+ p=PushShortPixel(endian,p,&pixel);
+ switch ((x+1) % 3)
+ {
+ default:
+ case 0:
+ {
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ break;
+ }
+ case 1:
+ {
+ SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ break;
+ }
+ case 2:
+ {
+ SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ q++;
+ break;
+ }
+ }
+ p+=quantum_info->pad;
+ }
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ switch ((x+bit) % 3)
+ {
+ default:
+ case 0:
+ {
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ break;
+ }
+ case 1:
+ {
+ SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ break;
+ }
+ case 2:
+ {
+ SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ q++;
+ break;
+ }
+ }
+ p+=quantum_info->pad;
+ }
+ if (bit != 0)
+ p++;
+ break;
+ }
+ if (quantum_info->quantum == 32U)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ q++;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ q++;
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ p=PushShortPixel(endian,p,&pixel);
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ p=PushShortPixel(endian,p,&pixel);
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+ p=PushShortPixel(endian,p,&pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
+ p=PushShortPixel(endian,p,&pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ float
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
+ p=PushLongPixel(endian,p,&pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
+ p=PushLongPixel(endian,p,&pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ double
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ q++;
+ }
+ break;
+ }
+ }
+ break;
+ }
+ case BGRAQuantum:
+ case BGROQuantum:
+ {
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+ p=PushCharPixel(p,&pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
+ p=PushCharPixel(p,&pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+ p=PushCharPixel(p,&pixel);
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ case 10:
+ {
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
+ {
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (n % 3)
+ {
+ case 0:
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ quantum=(size_t) (ScaleShortToQuantum(
+ (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+ break;
+ }
+ case 1:
+ {
+ quantum=(size_t) (ScaleShortToQuantum(
+ (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+ break;
+ }
+ case 2:
+ {
+ quantum=(size_t) (ScaleShortToQuantum(
+ (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
+ break;
+ }
+ }
+ switch (i)
+ {
+ case 0: SetRedPixelComponent(q,quantum); break;
+ case 1: SetGreenPixelComponent(q,quantum); break;
+ case 2: SetBluePixelComponent(q,quantum); break;
+ case 3: SetAlphaPixelComponent(q,quantum); break;
+ }
+ n++;
+ }
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ (pixel << 6)));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ (pixel << 6)));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+ (pixel << 6)));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetAlphaPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ (pixel << 6)));
+ q++;
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ p=PushShortPixel(endian,p,&pixel);
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ p=PushShortPixel(endian,p,&pixel);
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ p=PushShortPixel(endian,p,&pixel);
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+ p=PushShortPixel(endian,p,&pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
+ p=PushShortPixel(endian,p,&pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+ p=PushShortPixel(endian,p,&pixel);
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ float
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
+ p=PushLongPixel(endian,p,&pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
+ p=PushLongPixel(endian,p,&pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+ p=PushLongPixel(endian,p,&pixel);
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ double
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
+ p+=quantum_info->pad;
+ q++;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ q++;
+ }
+ break;
+ }
+ }
+ break;
+ }
case GrayQuantum:
{
switch (quantum_info->depth)
black=(Quantum) QuantumRange;
white=0;
}
- for (x=0; x < ((long) number_pixels-7); x+=8)
+ for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
{
for (bit=0; bit < 8; bit++)
{
- q->red=(((*p) & (1 << (7-bit))) == 0 ? black : white);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,((*p) & (1 << (7-bit))) == 0 ?
+ black : white);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
p++;
}
- for (bit=0; bit < (long) (number_pixels % 8); bit++)
+ for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
{
- q->red=(((*p) & (1 << (7-bit))) == 0 ? black : white);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,((*p) & (0x01 << (7-bit))) == 0 ?
+ black : white);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (bit != 0)
pixel;
range=GetQuantumRange(image->depth);
- for (x=0; x < ((long) number_pixels-1); x+=2)
+ for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
pixel=(unsigned char) ((*p) & 0xf);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p++;
q++;
}
- for (bit=0; bit < (long) (number_pixels % 2); bit++)
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
{
pixel=(unsigned char) (*p++ >> 4);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
break;
if (quantum_info->min_is_white != MagickFalse)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
- q->green=q->red;
- q->blue=q->red;
- SetOpacitySample(q,OpaqueOpacity);
+ SetRedPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
- SetOpacitySample(q,OpaqueOpacity);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
p+=quantum_info->pad;
q++;
}
{
if (image->endian != LSBEndian)
{
- for (x=0; x < (long) number_pixels/3; x++)
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleAnyToQuantum((pixel >> 0) & 0x3ff,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
- q->red=ScaleAnyToQuantum((pixel >> 10) & 0x3ff,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
- q->red=ScaleAnyToQuantum((pixel >> 20) & 0x3ff,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
+ p=PushLongPixel(endian,p,&pixel);
+ if (x++ < (ssize_t) (number_pixels-1))
+ {
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ q++;
+ }
+ if (x++ < (ssize_t) number_pixels)
+ {
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ q++;
+ }
break;
}
- for (x=0; x < (long) number_pixels/3; x++)
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
- q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
- q->red=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
+ p=PushLongPixel(endian,p,&pixel);
+ if (x++ < (ssize_t) (number_pixels-1))
+ {
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ q++;
+ }
+ if (x++ < (ssize_t) number_pixels)
+ {
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ q++;
+ }
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
unsigned short
pixel;
- for (x=0; x < (long) (number_pixels-1); x+=2)
+ for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
- for (bit=0; bit < (long) (number_pixels % 2); bit++)
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
p++;
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
if (quantum_info->min_is_white != MagickFalse)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p+=quantum_info->pad;
q++;
}
register unsigned char
pixel;
- for (x=0; x < ((long) number_pixels-3); x+=4)
+ for (x=0; x < ((ssize_t) number_pixels-3); x+=4)
{
for (bit=0; bit < 8; bit+=2)
{
pixel=(unsigned char)
(((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
- q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
- q->green=q->red;
- q->blue=q->red;
- q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit)))
- == 0 ? TransparentOpacity : OpaqueOpacity);
+ SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+ (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
q++;
}
p++;
}
- for (bit=0; bit < (long) (number_pixels % 4); bit+=2)
+ for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
{
pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
- q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
- q->green=q->red;
- q->blue=q->red;
- q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit))) == 0
- ? TransparentOpacity : OpaqueOpacity);
+ SetRedPixelComponent(q,pixel != 0 ? 0 : QuantumRange);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
+ SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+ (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
q++;
}
if (bit != 0)
pixel;
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
pixel=(unsigned char) ((*p) & 0xf);
- q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+ SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p++;
q++;
}
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushCharPixel(p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
case 10:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
case 12:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
- (MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushLongPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+ SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
- (MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel)));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+ SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- indexes[x]=ScaleCharToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
}
break;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetIndexPixelComponent(indexes+x,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=ScaleShortToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
}
break;
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=RoundToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- indexes[x]=ScaleLongToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=RoundToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- indexes[x]=ScaleAnyToQuantum(pixel,range);
+ SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
- SetOpacitySample(q,OpaqueOpacity);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
p+=quantum_info->pad;
q++;
}
range=GetQuantumRange(image->depth);
if (quantum_info->pack == MagickFalse)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
- q->green=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
- q->blue=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+ 0x3ff,range));
+ SetGreenPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+ 0x3ff,range));
+ SetBluePixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+ 0x3ff,range));
p+=quantum_info->pad;
q++;
}
break;
}
- if (quantum_info->quantum == 32UL)
+ if (quantum_info->quantum == 32U)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
unsigned short
pixel;
- for (x=0; x < (long) (3*number_pixels-1); x+=2)
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
{
p=PushShortPixel(endian,p,&pixel);
switch (x % 3)
default:
case 0:
{
- q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
break;
}
case 1:
{
- q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
break;
}
case 2:
{
- q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
q++;
break;
}
default:
case 0:
{
- q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
break;
}
case 1:
{
- q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
break;
}
case 2:
{
- q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
q++;
break;
}
}
p+=quantum_info->pad;
}
- for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
{
p=PushShortPixel(endian,p,&pixel);
switch ((x+bit) % 3)
default:
case 0:
{
- q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
break;
}
case 1:
{
- q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
break;
}
case 2:
{
- q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+ (pixel >> 4),range));
q++;
break;
}
p++;
break;
}
- if (quantum_info->quantum == 32UL)
+ if (quantum_info->quantum == 32U)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
pixel=0;
if (quantum_info->pack == MagickFalse)
{
- long
- n;
-
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
quantum;
+ ssize_t
+ n;
+
n=0;
quantum=0;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
for (i=0; i < 4; i++)
{
case 0:
{
p=PushLongPixel(endian,p,&pixel);
- quantum=(unsigned long) (ScaleShortToQuantum(
- (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 22) & 0x3ff) << 6)));
break;
}
case 1:
{
- quantum=(unsigned long) (ScaleShortToQuantum(
- (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 12) & 0x3ff) << 6)));
break;
}
case 2:
{
- quantum=(unsigned long) (ScaleShortToQuantum(
- (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 2) & 0x3ff) << 6)));
break;
}
}
switch (i)
{
- case 0: q->red=(Quantum) (quantum); break;
- case 1: q->green=(Quantum) (quantum); break;
- case 2: q->blue=(Quantum) (quantum); break;
- case 3: q->opacity=(Quantum) (QuantumRange-quantum); break;
+ case 0: SetRedPixelComponent(q,quantum); break;
+ case 1: SetGreenPixelComponent(q,quantum); break;
+ case 2: SetBluePixelComponent(q,quantum); break;
+ case 3: SetAlphaPixelComponent(q,quantum); break;
}
n++;
}
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleShortToQuantum((unsigned short) (pixel << 6));
+ SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ (pixel << 6)));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleShortToQuantum((unsigned short) (pixel << 6));
+ SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ (pixel << 6)));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleShortToQuantum((unsigned short) (pixel << 6));
+ SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+ (pixel << 6)));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(
- (unsigned short) (pixel << 6)));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum((unsigned short)
+ (pixel << 6)));
q++;
}
break;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
- (MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+ SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- indexes[x]=ScaleCharToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(
+ (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=ScaleShortToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- indexes[x]=ScaleLongToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- indexes[x]=ScaleAnyToQuantum(pixel,range);
+ SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- indexes[x]=ScaleCharToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*
- ScaleHalfToFloat(pixel));
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(
+ (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
- (MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=ScaleShortToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
}
case 32:
{
- unsigned long
+ unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
float
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- indexes[x]=ScaleLongToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ SetRedPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ SetBluePixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ SetAlphaPixelComponent(q,ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
p+=quantum_info->pad;
q++;
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- indexes[x]=ScaleAnyToQuantum(pixel,range);
+ SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+ SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
pixel=0;
if (quantum_info->pack == MagickFalse)
{
- long
- n;
-
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
quantum;
+ ssize_t
+ n;
+
n=0;
quantum=0;
- for (x=0; x < (long) number_pixels; x+=2)
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
{
for (i=0; i < 4; i++)
{
case 0:
{
p=PushLongPixel(endian,p,&pixel);
- quantum=(unsigned long) (ScaleShortToQuantum(
- (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 22) & 0x3ff) << 6)));
break;
}
case 1:
{
- quantum=(unsigned long) (ScaleShortToQuantum(
- (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 12) & 0x3ff) << 6)));
break;
}
case 2:
{
- quantum=(unsigned long) (ScaleShortToQuantum(
- (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 2) & 0x3ff) << 6)));
break;
}
}
n++;
}
p+=quantum_info->pad;
- q->red=cbcr[1];
- q->green=cbcr[0];
- q->blue=cbcr[2];
+ SetRedPixelComponent(q,cbcr[1]);
+ SetGreenPixelComponent(q,cbcr[0]);
+ SetBluePixelComponent(q,cbcr[2]);
q++;
- q->red=cbcr[3];
- q->green=cbcr[0];
- q->blue=cbcr[2];
+ SetRedPixelComponent(q,cbcr[3]);
+ SetGreenPixelComponent(q,cbcr[0]);
+ SetBluePixelComponent(q,cbcr[2]);
q++;
}
break;
default:
{
range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- quantum=q->red;
- q->red=q->green;
- q->green=quantum;
+ quantum=GetRedPixelComponent(q);
+ SetRedPixelComponent(q,GetGreenPixelComponent(q));
+ SetGreenPixelComponent(q,quantum);
q++;
}
}
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q->opacity=(Quantum) (QuantumRange-q->opacity);
+ SetOpacityPixelComponent(q,GetAlphaPixelComponent(q));
q++;
}
}
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- alpha=QuantumScale*((MagickRealType) QuantumRange-q->opacity);
+ alpha=QuantumScale*GetAlphaPixelComponent(q);
alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
- q->red=RoundToQuantum(alpha*q->red);
- q->green=RoundToQuantum(alpha*q->green);
- q->blue=RoundToQuantum(alpha*q->blue);
+ SetRedPixelComponent(q,ClampToQuantum(alpha*
+ GetRedPixelComponent(q)));
+ SetGreenPixelComponent(q,ClampToQuantum(alpha*
+ GetGreenPixelComponent(q)));
+ SetBluePixelComponent(q,ClampToQuantum(alpha*
+ GetBluePixelComponent(q)));
q++;
}
}