%
% 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,CacheView *image_view,
+% QuantumInfo *quantum_info,const QuantumType quantum_type,
+% unsigned char *pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
*/
-static inline unsigned char *PopDoublePixel(const QuantumState *quantum_state,
+static inline unsigned char *PopDoublePixel(QuantumInfo *quantum_info,
const double pixel,unsigned char *pixels)
{
double
quantum[8];
p=(double *) quantum;
- *p=(double) (pixel*quantum_state->inverse_scale+quantum_state->minimum);
- if (quantum_state->endian != LSBEndian)
+ *p=(double) (pixel*quantum_info->state.inverse_scale+quantum_info->minimum);
+ if (quantum_info->endian != LSBEndian)
{
*pixels++=quantum[7];
*pixels++=quantum[6];
return(pixels);
}
-static inline unsigned char *PopFloatPixel(const QuantumState *quantum_state,
+static inline unsigned char *PopFloatPixel(QuantumInfo *quantum_info,
const float pixel,unsigned char *pixels)
{
float
quantum[4];
p=(float *) quantum;
- *p=(float) ((double) pixel*quantum_state->inverse_scale+
- quantum_state->minimum);
- if (quantum_state->endian != LSBEndian)
+ *p=(float) ((double) pixel*quantum_info->state.inverse_scale+
+ quantum_info->minimum);
+ if (quantum_info->endian != LSBEndian)
{
*pixels++=quantum[3];
*pixels++=quantum[2];
return(pixels);
}
-static inline unsigned char *PopQuantumPixel(QuantumState *quantum_state,
- const size_t depth,const QuantumAny pixel,unsigned char *pixels)
+static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,
+ const QuantumAny pixel,unsigned char *pixels)
{
register ssize_t
i;
size_t
quantum_bits;
- if (quantum_state->bits == 0UL)
- quantum_state->bits=8U;
- for (i=(ssize_t) depth; i > 0L; )
+ if (quantum_info->state.bits == 0UL)
+ quantum_info->state.bits=8U;
+ for (i=(ssize_t) quantum_info->depth; i > 0L; )
{
quantum_bits=(size_t) i;
- if (quantum_bits > quantum_state->bits)
- quantum_bits=quantum_state->bits;
+ if (quantum_bits > quantum_info->state.bits)
+ quantum_bits=quantum_info->state.bits;
i-=(ssize_t) quantum_bits;
- if (quantum_state->bits == 8UL)
+ if (quantum_info->state.bits == 8UL)
*pixels='\0';
- quantum_state->bits-=quantum_bits;
+ quantum_info->state.bits-=quantum_bits;
*pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
- quantum_state->bits);
- if (quantum_state->bits == 0UL)
+ quantum_info->state.bits);
+ if (quantum_info->state.bits == 0UL)
{
pixels++;
- quantum_state->bits=8UL;
+ quantum_info->state.bits=8UL;
}
}
return(pixels);
}
-static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
- const size_t depth,const size_t pixel,unsigned char *pixels)
+static inline unsigned char *PopQuantumLongPixel(QuantumInfo *quantum_info,
+ const size_t pixel,unsigned char *pixels)
{
register ssize_t
i;
size_t
quantum_bits;
- if (quantum_state->bits == 0U)
- quantum_state->bits=32UL;
- for (i=(ssize_t) depth; i > 0; )
+ if (quantum_info->state.bits == 0U)
+ quantum_info->state.bits=32UL;
+ for (i=(ssize_t) quantum_info->depth; i > 0; )
{
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]) << (32U-quantum_state->bits));
+ if (quantum_bits > quantum_info->state.bits)
+ quantum_bits=quantum_info->state.bits;
+ quantum_info->state.pixel|=(((pixel >> (quantum_info->depth-i)) &
+ quantum_info->state.mask[quantum_bits]) << (32U-
+ quantum_info->state.bits));
i-=(ssize_t) quantum_bits;
- quantum_state->bits-=quantum_bits;
- if (quantum_state->bits == 0U)
+ quantum_info->state.bits-=quantum_bits;
+ if (quantum_info->state.bits == 0U)
{
- pixels=PopLongPixel(quantum_state->endian,quantum_state->pixel,pixels);
- quantum_state->pixel=0U;
- quantum_state->bits=32U;
+ pixels=PopLongPixel(quantum_info->endian,quantum_info->state.pixel,
+ pixels);
+ quantum_info->state.pixel=0U;
+ quantum_info->state.bits=32U;
}
}
return(pixels);
}
-static void ExportAlphaQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelAlpha(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelAlpha(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelAlpha(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelAlpha(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportBGRQuantum(const Image *image,const QuantumInfo *quantum_info,
- QuantumState quantum_state,const MagickSizeType number_pixels,
- const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
+static void ExportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
ssize_t
bit;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
switch ((x+1) % 3)
{
default:
break;
}
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
q+=quantum_info->pad;
}
for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
break;
}
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
q+=quantum_info->pad;
}
if (bit != 0)
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportBGRAQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
range) << 2);
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=0;
break;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
float
pixel;
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
+ q=PopFloatPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
+ q=PopDoublePixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportBlackQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
+ "ColorSeparatedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlack(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlack(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportBlueQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportCbYCrYQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
Quantum
cbcr[4];
ssize_t
n;
- endian=quantum_state.endian;
n=0;
quantum=0;
switch (quantum_info->depth)
}
pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
(cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
(cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
n++;
}
range=GetQuantumRange(quantum_info->depth);
- 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);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[1],range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[0],range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[2],range),q);
p+=GetPixelChannels(image);
- 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);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[3],range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[0],range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[2],range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportCMYKQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
register ssize_t
x;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
+ "ColorSeparatedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlack(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlack(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportCMYKAQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
register ssize_t
x;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
+ "ColorSeparatedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
float
pixel;
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlack(image,p),q);
pixel=(float) (GetPixelAlpha(image,p));
- q=PopFloatPixel(&quantum_state,pixel,q);
+ q=PopFloatPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlack(image,p),q);
pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
+ q=PopDoublePixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportGrayQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 1:
{
- register Quantum
+ register double
threshold;
register unsigned char
black=0x01;
white=0x00;
}
- threshold=(Quantum) (QuantumRange/2);
+ threshold=QuantumRange/2.0;
for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
{
*q='\0';
for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
*q=(((pixel >> 4) & 0xf) << 4);
p+=GetPixelChannels(image);
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
*q|=pixel >> 4;
p+=GetPixelChannels(image);
q++;
}
if ((number_pixels % 2) != 0)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
*q=(((pixel >> 4) & 0xf) << 4);
p+=GetPixelChannels(image);
q++;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
q=PopCharPixel(pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- pixel=(unsigned int) (
- ScaleQuantumToAny(GetPixelIntensity(image,p+2*GetPixelChannels(image)),range) << 22 |
- ScaleQuantumToAny(GetPixelIntensity(image,p+GetPixelChannels(image)),range) << 12 |
- ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
+ pixel=(unsigned int) (ScaleQuantumToAny(ClampToQuantum(
+ GetPixelIntensity(image,p+2*GetPixelChannels(image))),range) <<
+ 22 | ScaleQuantumToAny(ClampToQuantum(GetPixelIntensity(image,
+ p+GetPixelChannels(image))),range) << 12 | ScaleQuantumToAny(
+ ClampToQuantum(GetPixelIntensity(image,p)),range) << 2);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=3*GetPixelChannels(image);
q+=quantum_info->pad;
}
{
pixel=0U;
if (x++ < (ssize_t) (number_pixels-1))
- pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+GetPixelChannels(image)),
- range) << 12;
+ pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelIntensity(image,
+ p+GetPixelChannels(image))),range) << 12;
if (x++ < (ssize_t) number_pixels)
- pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p),
- range) << 2;
- q=PopLongPixel(endian,pixel,q);
+ pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelIntensity(image,
+ p)),range) << 2;
+ q=PopLongPixel(quantum_info->endian,pixel,q);
}
break;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+ GetPixelIntensity(image,p)),range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
+ pixel=ScaleQuantumToShort(ClampToQuantum(
+ GetPixelIntensity(image,p)));
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel >> 4),
+ q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+ GetPixelIntensity(image,p)),range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
pixel;
pixel=(float) GetPixelIntensity(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
+ q=PopFloatPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
- q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
double
pixel;
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
+ pixel=GetPixelIntensity(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+ GetPixelIntensity(image,p)),range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportGrayAlphaQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 1:
{
- register Quantum
+ register double
threshold;
register unsigned char
black=0x01;
white=0x00;
}
- threshold=(Quantum) (QuantumRange/2);
+ threshold=QuantumRange/2.0;
for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
{
*q='\0';
for (x=0; x < (ssize_t) number_pixels ; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
*q=(((pixel >> 4) & 0xf) << 4);
pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
*q|=pixel & 0xf;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
q=PopCharPixel(pixel,q);
pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
q=PopCharPixel(pixel,q);
{
pixel=SinglePrecisionToHalf(QuantumScale*
GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
pixel;
pixel=(float) GetPixelIntensity(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
+ q=PopFloatPixel(quantum_info,pixel,q);
pixel=(float) (GetPixelAlpha(image,p));
- q=PopFloatPixel(&quantum_state,pixel,q);
+ q=PopFloatPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
- q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
double
pixel;
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
+ pixel=GetPixelIntensity(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
+ q=PopDoublePixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+ GetPixelIntensity(image,p)),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportGreenQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportIndexQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
register ssize_t
x;
if (image->storage_class != PseudoClass)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
+ "ColormappedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 1:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
- GetPixelIndex(image,p)),q);
+ q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(
+ QuantumScale*GetPixelIndex(image,p)),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short)
+ GetPixelIndex(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelIndex(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
+ q=PopLongPixel(quantum_info->endian,(unsigned int)
+ GetPixelIndex(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelIndex(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- GetPixelIndex(image,p),q);
+ q=PopQuantumPixel(quantum_info,GetPixelIndex(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
static void ExportIndexAlphaQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ QuantumInfo *quantum_info,const MagickSizeType number_pixels,
+ const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
register ssize_t
x;
if (image->storage_class != PseudoClass)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
+ "ColormappedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 1:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short)
+ GetPixelIndex(image,p),q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short)
+ GetPixelIndex(image,p),q);
pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
float
pixel;
- q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelIndex(image,p),q);
pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
+ q=PopFloatPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
+ q=PopLongPixel(quantum_info->endian,(unsigned int)
+ GetPixelIndex(image,p),q);
pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
double
pixel;
- q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelIndex(image,p),q);
pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
+ q=PopDoublePixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- GetPixelIndex(image,p),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,GetPixelIndex(image,p),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportOpacityQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelOpacity(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelOpacity(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelOpacity(image,p),
- q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelOpacity(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelOpacity(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
+ GetPixelOpacity(image,p),range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportRedQuantum(const Image *image,const QuantumInfo *quantum_info,
- QuantumState quantum_state,const MagickSizeType number_pixels,
- const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
+static void ExportRedQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportRGBQuantum(const Image *image,const QuantumInfo *quantum_info,
- QuantumState quantum_state,const MagickSizeType number_pixels,
- const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
+static void ExportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
ssize_t
bit;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
switch ((x+1) % 3)
{
default:
break;
}
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
q+=quantum_info->pad;
}
for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
break;
}
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
q+=quantum_info->pad;
}
if (bit != 0)
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-static void ExportRGBAQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ExportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
register ssize_t
x;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
range) << 2);
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=0;
break;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
+ q=PopShortPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
float
pixel;
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
+ q=PopFloatPixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
+ q=PopDoublePixel(quantum_info,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
}
-MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
- const QuantumInfo *quantum_info,const QuantumType quantum_type,
- unsigned char *pixels,ExceptionInfo *exception)
+MagickExport size_t ExportQuantumPixels(const Image *image,
+ CacheView *image_view,QuantumInfo *quantum_info,
+ const QuantumType quantum_type,unsigned char *pixels,ExceptionInfo *exception)
{
MagickSizeType
number_pixels;
- QuantumState
- quantum_state;
-
register const Quantum
*restrict p;
}
if (quantum_info->alpha_type == AssociatedQuantumAlpha)
{
- MagickRealType
+ double
Sa;
register Quantum
register ssize_t
i;
+ if (GetPixelMask(image,q) != 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
Sa=QuantumScale*GetPixelAlpha(image,q);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelTrait
traits;
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
- if ((traits & UpdatePixelTrait) != 0)
- q[i]=ClampToQuantum(Sa*q[i]);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(Sa*q[i]);
}
q+=GetPixelChannels(image);
}
}
x=0;
q=pixels;
- InitializeQuantumState(quantum_info,image->endian,&quantum_state);
+ ResetQuantumState(quantum_info);
extent=GetQuantumExtent(image,quantum_info,quantum_type);
switch (quantum_type)
{
case AlphaQuantum:
{
- ExportAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case BGRQuantum:
{
- ExportBGRQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportBGRQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case BGRAQuantum:
case BGROQuantum:
{
- ExportBGRAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportBGRAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case BlackQuantum:
{
- ExportBlackQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- ExportBlueQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportBlueQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case CMYKQuantum:
{
- ExportCMYKQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case CMYKAQuantum:
case CMYKOQuantum:
{
- ExportCMYKAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case CbYCrYQuantum:
{
- ExportCbYCrYQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportCbYCrYQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case GrayQuantum:
{
- ExportGrayQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportGrayQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case GrayAlphaQuantum:
{
- ExportGrayAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- ExportGreenQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportGreenQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case IndexQuantum:
{
- ExportIndexQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case IndexAlphaQuantum:
{
- ExportIndexAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,
- q,exception);
+ ExportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case RedQuantum:
case CyanQuantum:
{
- ExportRedQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportRedQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case OpacityQuantum:
{
- ExportOpacityQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case RGBQuantum:
case CbYCrQuantum:
{
- ExportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportRGBQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case RGBAQuantum:
case RGBOQuantum:
case CbYCrAQuantum:
{
- ExportRGBAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ExportRGBAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
default:
projects / imagemagick / blobdiff