%
% The format of the ExportQuantumPixels method is:
%
-% size_t ExportQuantumPixels(const Image *image,const CacheView *image_view,
-% const QuantumInfo *quantum_info,const QuantumType quantum_type,
-% unsigned char *pixels,ExceptionInfo *exception)
+% size_t ExportQuantumPixels(const Image *image,
+% const CacheView *image_view,const QuantumInfo *quantum_info,
+% const QuantumType quantum_type,unsigned char *pixels,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
}
static inline unsigned char *PopQuantumPixel(QuantumState *quantum_state,
- const unsigned long depth,const QuantumAny pixel,unsigned char *pixels)
+ const size_t depth,const QuantumAny pixel,unsigned char *pixels)
{
- register long
+ register ssize_t
i;
- register unsigned long
+ size_t
quantum_bits;
if (quantum_state->bits == 0UL)
- quantum_state->bits=8UL;
- for (i=(long) depth; i > 0L; )
+ quantum_state->bits=8U;
+ for (i=(ssize_t) depth; i > 0L; )
{
- quantum_bits=(unsigned long) i;
+ quantum_bits=(size_t) i;
if (quantum_bits > quantum_state->bits)
quantum_bits=quantum_state->bits;
- i-=quantum_bits;
- if (quantum_state->bits == 8)
+ i-=(ssize_t) quantum_bits;
+ if (quantum_state->bits == 8UL)
*pixels='\0';
quantum_state->bits-=quantum_bits;
*pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
}
static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
- const unsigned long depth,const unsigned long pixel,unsigned char *pixels)
+ const size_t depth,const size_t pixel,unsigned char *pixels)
{
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
quantum_bits;
- if (quantum_state->bits == 0UL)
+ if (quantum_state->bits == 0U)
quantum_state->bits=32UL;
- for (i=(long) depth; i > 0; )
+ for (i=(ssize_t) depth; i > 0; )
{
- quantum_bits=(unsigned long) i;
+ quantum_bits=(size_t) i;
if (quantum_bits > quantum_state->bits)
quantum_bits=quantum_state->bits;
quantum_state->pixel|=(((pixel >> (depth-i)) &
- quantum_state->mask[quantum_bits]) << (32UL-quantum_state->bits));
- i-=quantum_bits;
+ quantum_state->mask[quantum_bits]) << (32U-quantum_state->bits));
+ i-=(ssize_t) quantum_bits;
quantum_state->bits-=quantum_bits;
if (quantum_state->bits == 0U)
{
pixels=PopLongPixel(quantum_state->endian,quantum_state->pixel,pixels);
quantum_state->pixel=0U;
- quantum_state->bits=32UL;
+ quantum_state->bits=32U;
}
}
return(pixels);
EndianType
endian;
- long
- bit;
-
MagickRealType
alpha;
register const PixelPacket
*restrict p;
- register long
+ register ssize_t
x;
register unsigned char
size_t
extent;
+ ssize_t
+ bit;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
assert(quantum_info->signature == MagickSignature);
if (pixels == (unsigned char *) NULL)
pixels=GetQuantumPixels(quantum_info);
- number_pixels=GetImageExtent(image);
- p=GetVirtualPixelQueue(image);
- indexes=GetVirtualIndexQueue(image);
- if (image_view != (CacheView *) NULL)
+ if (image_view == (CacheView *) NULL)
+ {
+ number_pixels=GetImageExtent(image);
+ p=GetVirtualPixelQueue(image);
+ indexes=GetVirtualIndexQueue(image);
+ }
+ else
{
number_pixels=GetCacheViewExtent(image_view);
p=GetCacheViewVirtualPixelQueue(image_view);
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
alpha=QuantumScale*((double) QuantumRange-q->opacity);
q->red=ClampToQuantum(alpha*q->red);
q++;
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
+ if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+ (quantum_type == BGROQuantum))
{
register PixelPacket
*restrict q;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q->opacity=(Quantum) GetAlphaPixelComponent(q);
q++;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=GetAuthenticPixelQueue(image);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
quantum=q->red;
q->red=q->green;
register unsigned char
pixel;
- for (x=((long) number_pixels-7); x > 0; x-=8)
+ for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
{
pixel=(unsigned char) *indexes++;
*q=((pixel & 0x01) << 7);
if ((number_pixels % 8) != 0)
{
*q='\0';
- for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
{
pixel=(unsigned char) *indexes++;
*q|=((pixel & 0x01) << (unsigned char) bit);
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) *indexes++;
*q=((pixel & 0xf) << 4);
}
case 8:
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopCharPixel((unsigned char) indexes[x],q);
q+=quantum_info->pad;
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
indexes[x]),q);
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopShortPixel(endian,(unsigned short) indexes[x],q);
q+=quantum_info->pad;
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
p++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopLongPixel(endian,(unsigned long) indexes[x],q);
+ q=PopLongPixel(endian,(unsigned int) indexes[x],q);
q+=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++)
{
q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
p++;
}
default:
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,indexes[x],q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=((long) number_pixels-3); x > 0; x-=4)
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
{
pixel=(unsigned char) *indexes++;
*q=((pixel & 0x01) << 7);
- pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ?
1 : 0);
*q|=((pixel & 0x01) << 6);
p++;
pixel=(unsigned char) *indexes++;
*q|=((pixel & 0x01) << 5);
- pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ?
1 : 0);
*q|=((pixel & 0x01) << 4);
p++;
pixel=(unsigned char) *indexes++;
*q|=((pixel & 0x01) << 3);
- pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ?
1 : 0);
*q|=((pixel & 0x01) << 2);
p++;
pixel=(unsigned char) *indexes++;
*q|=((pixel & 0x01) << 1);
- pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ?
1 : 0);
*q|=((pixel & 0x01) << 0);
p++;
if ((number_pixels % 4) != 0)
{
*q='\0';
- for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
{
pixel=(unsigned char) *indexes++;
*q|=((pixel & 0x01) << (unsigned char) (bit+4));
- pixel=(unsigned char) (p->opacity == (Quantum)
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum)
TransparentOpacity ? 1 : 0);
*q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
p++;
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels ; x++)
+ for (x=0; x < (ssize_t) number_pixels ; x++)
{
pixel=(unsigned char) *indexes++;
*q=((pixel & 0xf) << 4);
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopCharPixel((unsigned char) indexes[x],q);
pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopShortPixel(endian,(unsigned short) indexes[x],q);
pixel=SinglePrecisionToHalf(QuantumScale*
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopShortPixel(endian,(unsigned short) indexes[x],q);
pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
float
pixel;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopLongPixel(endian,(unsigned long) indexes[x],q);
+ q=PopLongPixel(endian,(unsigned int) indexes[x],q);
pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
GetOpacityPixelComponent(p)));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
double
pixel;
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) (GetAlphaPixelComponent(p)),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,indexes[x],q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny((Quantum) (GetAlphaPixelComponent(p)),range),q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ break;
+ }
+ case BGRQuantum:
+ {
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) (ScaleQuantumToAny(GetRedPixelComponent(p),range) << 22 |
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range) << 12 |
+ ScaleQuantumToAny(GetBluePixelComponent(p),range) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ switch (x % 3)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ p++;
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ switch ((x+1) % 3)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ p++;
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q+=quantum_info->pad;
+ }
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ switch ((x+bit) % 3)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ p++;
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q+=quantum_info->pad;
+ }
+ if (bit != 0)
+ p++;
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetBluePixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetGreenPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetRedPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
+ q=PopLongPixel(endian,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ break;
+ }
+ case BGRAQuantum:
+ case BGROQuantum:
+ {
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
+ q=PopCharPixel(pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ pixel=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (i)
+ {
+ case 0: quantum=GetRedPixelComponent(p); break;
+ case 1: quantum=GetGreenPixelComponent(p); break;
+ case 2: quantum=GetBluePixelComponent(p); break;
+ case 3: quantum=(Quantum) (QuantumRange-GetOpacityPixelComponent(p)); break;
+ }
+ switch (n % 3)
+ {
+ case 0:
+ {
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 22);
+ break;
+ }
+ case 1:
+ {
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 12);
+ break;
+ }
+ case 2:
+ {
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ pixel=0;
+ break;
+ }
+ }
+ n++;
+ }
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetBluePixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetGreenPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetRedPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetAlphaPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
+ q=PopShortPixel(endian,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ float
+ pixel;
+
+ q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
+ pixel=(float) GetAlphaPixelComponent(p);
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
+ q=PopLongPixel(endian,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ double
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
+ pixel=(double) GetAlphaPixelComponent(p);
+ q=PopDoublePixel(&quantum_state,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny((Quantum) GetAlphaPixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
white=0x00;
}
threshold=(Quantum) (QuantumRange/2);
- for (x=((long) number_pixels-7); x > 0; x-=8)
+ for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
{
*q='\0';
*q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
if ((number_pixels % 8) != 0)
{
*q='\0';
- for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
{
*q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
bit;
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=ScaleQuantumToChar(PixelIntensityToQuantum(p));
*q=(((pixel >> 4) & 0xf) << 4);
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
q=PopCharPixel(pixel,q);
}
case 10:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
- register unsigned long
+ register unsigned int
pixel;
- for (x=0; x < (long) (number_pixels-2); x+=3)
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- pixel=(unsigned long) (
+ pixel=(unsigned int) (
ScaleQuantumToAny(PixelIntensityToQuantum(p+2),range) << 22 |
ScaleQuantumToAny(PixelIntensityToQuantum(p+1),range) << 12 |
ScaleQuantumToAny(PixelIntensityToQuantum(p+0),range) << 2);
q+=quantum_info->pad;
}
pixel=0UL;
- if (x++ < (long) (number_pixels-1))
+ if (x++ < (ssize_t) (number_pixels-1))
pixel|=ScaleQuantumToAny(PixelIntensityToQuantum(p+1),
range) << 12;
- if (x++ < (long) number_pixels)
+ if (x++ < (ssize_t) number_pixels)
pixel|=ScaleQuantumToAny(PixelIntensityToQuantum(p+0),
range) << 2;
q=PopLongPixel(endian,pixel,q);
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- PixelIntensityToQuantum(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned short
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- PixelIntensityToQuantum(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
p++;
q+=quantum_info->pad;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
PixelIntensityToQuantum(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
float
pixel;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
double
pixel;
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- PixelIntensityToQuantum(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
p++;
q+=quantum_info->pad;
}
white=0x00;
}
threshold=(Quantum) (QuantumRange/2);
- for (x=((long) number_pixels-3); x > 0; x-=4)
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
{
*q='\0';
- *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
- pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
+ *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 7;
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
*q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
p++;
- *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
- pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
+ *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 5;
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
*q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
p++;
- *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
- pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
+ *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 3;
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
*q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
p++;
- *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
- pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
+ *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 1;
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
*q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
p++;
q++;
if ((number_pixels % 4) != 0)
{
*q='\0';
- for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
+ for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
{
- *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
- (bit+4);
- pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
+ *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) <<
+ (7-bit);
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 :
0x01);
*q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
- (bit+4-1));
+ (7-bit-1));
p++;
}
q++;
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels ; x++)
+ for (x=0; x < (ssize_t) number_pixels ; x++)
{
pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
*q=(((pixel >> 4) & 0xf) << 4);
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
q=PopCharPixel(pixel,q);
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
PixelIntensityToQuantum(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
float
pixel;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
double
pixel;
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- PixelIntensityToQuantum(p),range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) (GetAlphaPixelComponent(p)),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny((Quantum) (GetAlphaPixelComponent(p)),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
q=PopCharPixel(pixel,q);
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetRedPixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) p->red,q);
+ q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) p->red,q);
+ q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->red,range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
q=PopCharPixel(pixel,q);
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetGreenPixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) p->green,q);
+ q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) p->green,q);
+ q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->green,range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
q=PopCharPixel(pixel,q);
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetBluePixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+ q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+ q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->blue,range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
GetOpacityPixelComponent(p)));
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetAlphaPixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
GetOpacityPixelComponent(p)));
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
float
pixel;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
GetOpacityPixelComponent(p)));
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
double
pixel;
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) (GetAlphaPixelComponent(p)),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny((Quantum) (GetAlphaPixelComponent(p)),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
q=PopCharPixel(pixel,q);
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetOpacityPixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
+ q=PopFloatPixel(&quantum_state,(float) GetOpacityPixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
+ q=PopDoublePixel(&quantum_state,(double) GetOpacityPixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->opacity,range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetOpacityPixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(indexes[x]);
q=PopCharPixel(pixel,q);
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
q=PopShortPixel(endian,pixel,q);
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(indexes[x]);
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
p++;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(indexes[x]);
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
p++;
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) indexes[x],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny((Quantum) indexes[x],range),q);
p++;
q+=quantum_info->pad;
}
{
case 8:
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
}
case 10:
{
- register unsigned long
+ register unsigned int
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned long) (ScaleQuantumToAny(p->red,range) << 22 |
- ScaleQuantumToAny(p->green,range) << 12 |
- ScaleQuantumToAny(p->blue,range) << 2);
+ pixel=(unsigned int) (ScaleQuantumToAny(GetRedPixelComponent(p),range) << 22 |
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range) << 12 |
+ ScaleQuantumToAny(GetBluePixelComponent(p),range) << 2);
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
}
if (quantum_info->quantum == 32UL)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
p++;
q+=quantum_info->pad;
}
}
case 12:
{
- register unsigned long
+ register unsigned int
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
- for (x=0; x < (long) (3*number_pixels-1); x+=2)
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
{
switch (x % 3)
{
default:
case 0:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
break;
}
case 1:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
break;
}
case 2:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
p++;
break;
}
default:
case 0:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
break;
}
case 1:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
break;
}
case 2:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
p++;
break;
}
q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
q+=quantum_info->pad;
}
- for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
{
switch ((x+bit) % 3)
{
default:
case 0:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
break;
}
case 1:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
break;
}
case 2:
{
- pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
p++;
break;
}
}
if (quantum_info->quantum == 32UL)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
p++;
q+=quantum_info->pad;
}
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetRedPixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) p->red,q);
- q=PopFloatPixel(&quantum_state,(float) p->green,q);
- q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+ q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) p->red,q);
- q=PopDoublePixel(&quantum_state,(double) p->green,q);
- q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+ q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
p++;
q+=quantum_info->pad;
}
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->red,range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->green,range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->blue,range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
q=PopCharPixel(pixel,q);
q=PopCharPixel(pixel,q);
pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetAlphaPixelComponent(p));
+ pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
}
break;
}
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ pixel=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (i)
+ {
+ case 0: quantum=GetRedPixelComponent(p); break;
+ case 1: quantum=GetGreenPixelComponent(p); break;
+ case 2: quantum=GetBluePixelComponent(p); break;
+ case 3: quantum=(Quantum) (QuantumRange-GetOpacityPixelComponent(p)); break;
+ }
+ switch (n % 3)
+ {
+ case 0:
+ {
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 22);
+ break;
+ }
+ case 1:
+ {
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 12);
+ break;
+ }
+ case 2:
+ {
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ pixel=0;
+ break;
+ }
+ }
+ n++;
+ }
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p++;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
case 16:
{
register unsigned short
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetRedPixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
q=PopShortPixel(endian,pixel,q);
pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetAlphaPixelComponent(p));
+ pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
float
pixel;
- q=PopFloatPixel(&quantum_state,(float) p->red,q);
- q=PopFloatPixel(&quantum_state,(float) p->green,q);
- q=PopFloatPixel(&quantum_state,(float) p->blue,q);
- pixel=GetAlphaPixelComponent(p);
+ q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
+ pixel=(float) GetAlphaPixelComponent(p);
q=PopFloatPixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
q=PopLongPixel(endian,pixel,q);
pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetAlphaPixelComponent(p));
+ pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) p->red,q);
- q=PopDoublePixel(&quantum_state,(double) p->green,q);
- q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+ q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
pixel=(double) GetAlphaPixelComponent(p);
q=PopDoublePixel(&quantum_state,pixel,q);
p++;
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- GetRedPixelComponent(p),range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- GetGreenPixelComponent(p),range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- GetBluePixelComponent(p),range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- GetAlphaPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny((Quantum) GetAlphaPixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
q=PopCharPixel(pixel,q);
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetRedPixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) p->red,q);
- q=PopFloatPixel(&quantum_state,(float) p->green,q);
- q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+ q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
p++;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) p->red,q);
- q=PopDoublePixel(&quantum_state,(double) p->green,q);
- q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+ q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
p++;
q+=quantum_info->pad;
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->red,range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->green,range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->blue,range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- indexes[x],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range),q);
p++;
q+=quantum_info->pad;
}
register unsigned char
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
q=PopCharPixel(pixel,q);
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetRedPixelComponent(p));
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
}
case 32:
{
- register unsigned long
+ register unsigned int
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
float
pixel;
- q=PopFloatPixel(&quantum_state,(float) p->red,q);
- q=PopFloatPixel(&quantum_state,(float) p->green,q);
- q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+ q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
pixel=(float) (GetAlphaPixelComponent(p));
q=PopFloatPixel(&quantum_state,pixel,q);
}
break;
}
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
double
pixel;
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) p->red,q);
- q=PopDoublePixel(&quantum_state,(double) p->green,q);
- q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+ q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
pixel=(double) (GetAlphaPixelComponent(p));
q=PopDoublePixel(&quantum_state,pixel,q);
}
default:
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (long) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->red,range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->green,range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->blue,range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- indexes[x],range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- p->opacity,range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetOpacityPixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
}
case CbYCrYQuantum:
{
- long
- n;
-
Quantum
cbcr[4];
- register long
+ register ssize_t
i;
- register unsigned long
+ register unsigned int
pixel;
- unsigned long
+ size_t
quantum;
+ ssize_t
+ n;
+
n=0;
quantum=0;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
switch (quantum_info->depth)
{
case 10:
{
if (quantum_info->pack == MagickFalse)
{
- 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++)
{
cbcr[i]=(Quantum) quantum;
n++;
}
- pixel=(unsigned long) ((unsigned long) (cbcr[1]) << 22 |
- (unsigned long) (cbcr[0]) << 12 |
- (unsigned long) (cbcr[2]) << 2);
+ pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 |
+ (size_t) (cbcr[0]) << 12 |
+ (size_t) (cbcr[2]) << 2);
q=PopLongPixel(endian,pixel,q);
p++;
- pixel=(unsigned long) ((unsigned long) (cbcr[3]) << 22 |
- (unsigned long) (cbcr[0]) << 12 |
- (unsigned long) (cbcr[2]) << 2);
+ pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 |
+ (size_t) (cbcr[0]) << 12 |
+ (size_t) (cbcr[2]) << 2);
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
}
default:
{
- 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++)
{
cbcr[i]=(Quantum) quantum;
n++;
}
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- cbcr[1],range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- cbcr[0],range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- cbcr[2],range),q);
- p++;
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- cbcr[3],range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- cbcr[0],range),q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- cbcr[2],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[1],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[0],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[2],range),q);
+ p++;
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[3],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[0],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[2],range),q);
p++;
q+=quantum_info->pad;
}
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=(PixelPacket *) GetCacheViewVirtualPixelQueue(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++;
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
+ if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+ (quantum_type == BGROQuantum))
{
register PixelPacket
*restrict q;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
- for (x=0; x < (long) number_pixels; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
q->opacity=(Quantum) GetAlphaPixelComponent(q);
q++;
projects / imagemagick / blobdiff