EndianType
endian;
- ssize_t
- bit;
-
MagickRealType
alpha;
size_t
extent;
+ ssize_t
+ bit;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
q++;
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
+ if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+ (quantum_type == BGROQuantum))
{
register PixelPacket
*restrict q;
{
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;
}
{
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++;
{
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++;
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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,image->depth,indexes[x],q);
- q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) (GetAlphaPixelComponent(p)),range),q);
+ 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;
}
}
case 10:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
register unsigned int
}
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 < (ssize_t) 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;
}
}
default:
{
- range=GetQuantumRange(image->depth);
+ 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;
}
{
*q='\0';
*q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 7;
- pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? black : white) << 6);
+ 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|=(((int) pixel != 0 ? black : white) << 4);
+ 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|=(((int) pixel != 0 ? black : white) << 2);
+ 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|=(((int) pixel != 0 ? black : white) << 0);
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
p++;
q++;
}
{
*q|=(PixelIntensityToQuantum(p) > threshold ? black : white) <<
(7-bit);
- pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
+ pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 :
0x01);
- *q|=(((int) pixel != 0 ? black : white) << (unsigned char)
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
(7-bit-1));
p++;
}
}
default:
{
- range=GetQuantumRange(image->depth);
+ 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;
}
{
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;
}
{
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);
+ 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;
}
{
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;
}
{
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);
+ 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;
}
{
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;
}
{
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);
+ 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;
}
}
default:
{
- range=GetQuantumRange(image->depth);
+ 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;
}
{
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;
}
{
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);
+ 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;
}
}
default:
{
- range=GetQuantumRange(image->depth);
+ 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;
}
register unsigned int
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) (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;
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) 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;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) 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;
}
register unsigned int
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
default:
case 0:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
break;
}
case 1:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
break;
}
case 2:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
p++;
break;
}
default:
case 0:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
break;
}
case 1:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
break;
}
case 2:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
p++;
break;
}
default:
case 0:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
break;
}
case 1:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
break;
}
case 2:
{
- pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+ pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
p++;
break;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) 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;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) 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;
}
{
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;
}
{
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);
+ 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 int
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
- ssize_t
- n;
-
register ssize_t
i;
size_t
quantum;
+ ssize_t
+ n;
+
n=0;
quantum=0;
pixel=0;
{
switch (i)
{
- case 0: quantum=p->red; break;
- case 1: quantum=p->green; break;
- case 2: quantum=p->blue; break;
- case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
+ 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)
{
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) 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);
pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
- p->opacity),range);
- q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+ GetOpacityPixelComponent(p)),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
p++;
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(unsigned int) 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);
pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
- p->opacity),range);
- q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+ GetOpacityPixelComponent(p)),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
p++;
q+=quantum_info->pad;
}
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);
pixel=(float) GetAlphaPixelComponent(p);
q=PopFloatPixel(&quantum_state,pixel,q);
p++;
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);
+ 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(
- (Quantum) 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;
}
{
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;
{
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);
+ 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;
}
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);
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);
+ 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:
{
- ssize_t
- n;
-
Quantum
cbcr[4];
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:
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++;
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
+ if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+ (quantum_type == BGROQuantum))
{
register PixelPacket
*restrict q;