% MagickCore Methods to Export Quantum Pixels %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% October 1998 %
% %
% %
-% Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2018 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
% obtain a copy of the License at %
% %
-% http://www.imagemagick.org/script/license.php %
+% https://www.imagemagick.org/script/license.php %
% %
% Unless required by applicable law or agreed to in writing, software %
% distributed under the License is distributed on an "AS IS" BASIS, %
%
% 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 *magick_restrict pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
*/
-static inline unsigned char *PopDoublePixel(const QuantumState *quantum_state,
- const double pixel,unsigned char *pixels)
+static inline unsigned char *PopDoublePixel(QuantumInfo *quantum_info,
+ const double pixel,unsigned char *magick_restrict pixels)
{
double
*p;
unsigned char
quantum[8];
+ (void) memset(quantum,0,sizeof(quantum));
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];
- *pixels++=quantum[5];
- *pixels++=quantum[4];
- *pixels++=quantum[3];
- *pixels++=quantum[2];
- *pixels++=quantum[1];
*pixels++=quantum[0];
+ *pixels++=quantum[1];
+ *pixels++=quantum[2];
+ *pixels++=quantum[3];
+ *pixels++=quantum[4];
+ *pixels++=quantum[5];
+ *pixels++=quantum[6];
+ *pixels++=quantum[7];
return(pixels);
}
- *pixels++=quantum[0];
- *pixels++=quantum[1];
- *pixels++=quantum[2];
- *pixels++=quantum[3];
- *pixels++=quantum[4];
- *pixels++=quantum[5];
- *pixels++=quantum[6];
*pixels++=quantum[7];
+ *pixels++=quantum[6];
+ *pixels++=quantum[5];
+ *pixels++=quantum[4];
+ *pixels++=quantum[3];
+ *pixels++=quantum[2];
+ *pixels++=quantum[1];
+ *pixels++=quantum[0];
return(pixels);
}
-static inline unsigned char *PopFloatPixel(const QuantumState *quantum_state,
- const float pixel,unsigned char *pixels)
+static inline unsigned char *PopFloatPixel(QuantumInfo *quantum_info,
+ const float pixel,unsigned char *magick_restrict pixels)
{
float
*p;
unsigned char
quantum[4];
+ (void) memset(quantum,0,sizeof(quantum));
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];
- *pixels++=quantum[1];
*pixels++=quantum[0];
+ *pixels++=quantum[1];
+ *pixels++=quantum[2];
+ *pixels++=quantum[3];
return(pixels);
}
- *pixels++=quantum[0];
- *pixels++=quantum[1];
- *pixels++=quantum[2];
*pixels++=quantum[3];
+ *pixels++=quantum[2];
+ *pixels++=quantum[1];
+ *pixels++=quantum[0];
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 *magick_restrict 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 (i < 0)
+ i=0;
+ 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 *magick_restrict 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);
}
-MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
- const QuantumInfo *quantum_info,const QuantumType quantum_type,
- unsigned char *pixels,ExceptionInfo *exception)
+static void ExportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
- MagickRealType
- alpha;
-
- MagickSizeType
- number_pixels;
-
QuantumAny
range;
- QuantumState
- quantum_state;
-
- register const Quantum
- *restrict p;
-
register ssize_t
x;
- register unsigned char
- *restrict q;
-
- size_t
- channels,
- extent;
-
- ssize_t
- bit;
-
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(quantum_info != (QuantumInfo *) NULL);
- assert(quantum_info->signature == MagickSignature);
- if (pixels == (unsigned char *) NULL)
- pixels=GetQuantumPixels(quantum_info);
- if (image_view == (CacheView *) NULL)
- {
- number_pixels=GetImageExtent(image);
- p=GetVirtualPixelQueue(image);
- channels=GetPixelChannels(image);
- }
- else
- {
- number_pixels=GetCacheViewExtent(image_view);
- p=GetCacheViewVirtualPixelQueue(image_view);
- channels=GetPixelChannels(image);
- }
- if (quantum_info->alpha_type == AssociatedQuantumAlpha)
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ (void) exception;
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- register Quantum
- *restrict q;
+ register unsigned char
+ pixel;
- /*
- Associate alpha.
- */
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (ssize_t) image->columns; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- alpha=QuantumScale*GetPixelAlpha(image,q);
- SetPixelRed(image,ClampToQuantum(alpha*GetPixelRed(image,q)),q);
- SetPixelGreen(image,ClampToQuantum(alpha*GetPixelGreen(image,q)),q);
- SetPixelBlue(image,ClampToQuantum(alpha*GetPixelBlue(image,q)),q);
- q++;
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
+ break;
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
- (quantum_type == BGROQuantum))
+ case 16:
{
- register Quantum
- *restrict q;
+ register unsigned short
+ pixel;
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q++;
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
+ break;
}
- if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
+ case 32:
{
- Quantum
- quantum;
-
- register Quantum
- *restrict q;
+ register unsigned int
+ pixel;
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetAuthenticPixelQueue(image);
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(quantum_info,(float) GetPixelAlpha(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- quantum=GetPixelRed(image,q);
- SetPixelRed(image,GetPixelGreen(image,q),q);
- SetPixelGreen(image,quantum,q);
- q+=channels;
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
+ break;
}
- x=0;
- q=pixels;
- InitializeQuantumState(quantum_info,image->endian,&quantum_state);
- extent=GetQuantumExtent(image,quantum_info,quantum_type);
- endian=quantum_state.endian;
- switch (quantum_type)
- {
- case IndexQuantum:
+ case 64:
{
- if (image->storage_class != PseudoClass)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 1:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
- for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0x01) << 7);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 6);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 5);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 4);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 3);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 2);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 1);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 0);
- p+=channels;
- q++;
+ q=PopDoublePixel(quantum_info,(double) GetPixelAlpha(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
- if ((number_pixels % 8) != 0)
- {
- *q='\0';
- for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << (unsigned char) bit);
- p+=channels;
- }
- q++;
- }
break;
}
- case 4:
- {
- register unsigned char
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
- for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0xf) << 0);
- p+=channels;
- q++;
+ pixel=(unsigned int) (
+ ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
+ ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
+ ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
- if ((number_pixels % 2) != 0)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- p+=channels;
- q++;
- }
break;
}
- case 8:
+ if (quantum_info->quantum == 32UL)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ switch (x % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
- GetPixelIndex(image,p)),q);
- p+=channels;
- q+=quantum_info->pad;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ p+=GetPixelChannels(image);
+ break;
}
- break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
+ switch ((x+1) % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelIndex(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ p+=GetPixelChannels(image);
+ break;
}
- break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
- p+=channels;
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
q+=quantum_info->pad;
}
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ switch ((x+bit) % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelIndex(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ p+=GetPixelChannels(image);
+ break;
}
- break;
}
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
+ q+=quantum_info->pad;
+ }
+ if (bit != 0)
+ p+=GetPixelChannels(image);
+ break;
}
- default:
+ if (quantum_info->quantum == 32UL)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- GetPixelIndex(image,p),q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case IndexAlphaQuantum:
+ case 16:
{
- if (image->storage_class != PseudoClass)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 1:
- {
- register unsigned char
- pixel;
+ register unsigned short
+ pixel;
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0x01) << 7);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 6);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 5);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 4);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 3);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 2);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 1);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 0);
- p+=channels;
- q++;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
- if ((number_pixels % 4) != 0)
- {
- *q='\0';
- for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << (unsigned char) (bit+4));
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
- p+=channels;
- }
- q++;
- }
break;
}
- case 4:
- {
- register unsigned char
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
- for (x=0; x < (ssize_t) number_pixels ; x++)
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
- *q|=((pixel & 0xf) << 0);
- p+=channels;
- 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;
}
break;
}
- case 8:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ 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;
}
break;
}
- case 16:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- register unsigned short
- pixel;
+ register ssize_t
+ i;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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++)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (i)
{
- q=PopShortPixel(endian,(unsigned short)
- GetPixelIndex(image,p),q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
+ case 0: quantum=GetPixelRed(image,p); break;
+ case 1: quantum=GetPixelGreen(image,p); break;
+ case 2: quantum=GetPixelBlue(image,p); break;
+ case 3: quantum=GetPixelAlpha(image,p); break;
}
- 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(quantum_info->endian,pixel,q);
+ pixel=0;
+ break;
+ }
+ }
+ n++;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
+ if (quantum_info->quantum == 32UL)
{
- 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)
- GetPixelIndex(image,p),q);
- pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
-
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelIndex(image,p),q);
- pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case BGRQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
- p+=channels;
+ float
+ pixel;
+
+ 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_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 10:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned int
+ double
pixel;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) (
- ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
- ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
- ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- 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);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
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);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ 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_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 12:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- register unsigned int
- pixel;
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ n=0;
+ quantum=0;
+ pixel=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
{
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ switch (i)
+ {
+ case 0: quantum=GetPixelRed(image,p); break;
+ case 1: quantum=GetPixelGreen(image,p); break;
+ case 2: quantum=GetPixelBlue(image,p); break;
+ case 3: quantum=GetPixelOpacity(image,p); break;
+ }
+ switch (n % 3)
{
- switch (x % 3)
+ case 0:
{
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 22);
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- switch ((x+1) % 3)
+ case 1:
{
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 12);
+ 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)
+ case 2:
{
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 2);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=0;
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- if (bit != 0)
- p+=channels;
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- 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);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
}
- break;
+ n++;
}
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
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);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ 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*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
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)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- 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)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
- p+=channels;
+ float
+ pixel;
+
+ 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) GetPixelOpacity(image,p);
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case BGRAQuantum:
- case BGROQuantum:
+ case 64:
{
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ 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) GetPixelOpacity(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 10:
- {
- register unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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(GetPixelOpacity(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
+static void ExportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
- size_t
- quantum;
+ register ssize_t
+ x;
- ssize_t
- n;
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
- 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=GetPixelRed(image,p); break;
- case 1: quantum=GetPixelGreen(image,p); break;
- case 2: quantum=GetPixelBlue(image,p); break;
- case 3: quantum=GetPixelAlpha(image,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+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- 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);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ 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=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlack(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlack(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- 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);
- pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+static void ExportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case GrayQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 1:
- {
- register Quantum
- threshold;
-
- register unsigned char
- black,
- white;
+ register unsigned int
+ pixel;
- black=0x00;
- white=0x01;
- if (quantum_info->min_is_white != MagickFalse)
- {
- black=0x01;
- white=0x00;
- }
- threshold=(Quantum) (QuantumRange/2);
- for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
- {
- *q='\0';
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 7;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 6;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 5;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 4;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 3;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 2;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 1;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 0;
- p+=channels;
- q++;
- }
- if ((number_pixels % 8) != 0)
- {
- *q='\0';
- for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
- {
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) <<
- bit;
- p+=channels;
- }
- q++;
- }
- break;
- }
- case 4:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- p+=channels;
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q|=pixel >> 4;
- p+=channels;
- q++;
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
- if ((number_pixels % 2) != 0)
- {
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- p+=channels;
- q++;
- }
break;
}
- case 8:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 10:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ Quantum
+ cbcr[4];
+
+ register ssize_t
+ i,
+ x;
+
+ register unsigned int
+ pixel;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ n=0;
+ quantum=0;
+ switch (quantum_info->depth)
+ {
+ case 10:
+ {
+ if (quantum_info->pack == MagickFalse)
{
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
+ {
+ for (i=0; i < 4; i++)
{
- register unsigned int
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
+ switch (n % 3)
{
- pixel=(unsigned int) (
- ScaleQuantumToAny(GetPixelIntensity(image,p+2),range) << 22 |
- ScaleQuantumToAny(GetPixelIntensity(image,p+1),range) << 12 |
- ScaleQuantumToAny(GetPixelIntensity(image,p+0),range) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=3;
- q+=quantum_info->pad;
+ case 0:
+ {
+ quantum=GetPixelRed(image,p);
+ break;
+ }
+ case 1:
+ {
+ quantum=GetPixelGreen(image,p);
+ break;
+ }
+ case 2:
+ {
+ quantum=GetPixelBlue(image,p);
+ break;
+ }
}
- pixel=0UL;
- if (x++ < (ssize_t) (number_pixels-1))
- pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+1),
- range) << 12;
- if (x++ < (ssize_t) number_pixels)
- pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+0),
- range) << 2;
- q=PopLongPixel(endian,pixel,q);
- break;
+ cbcr[i]=(Quantum) quantum;
+ n++;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- p+=channels;
+ pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
+ (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
+ 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(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 12:
- {
- register unsigned short
- pixel;
+ break;
+ }
+ default:
+ {
+ QuantumAny
+ range;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (n % 3)
+ {
+ case 0:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
- p+=channels;
- q+=quantum_info->pad;
- }
+ quantum=GetPixelRed(image,p);
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- p+=channels;
- 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*
- GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 1:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- float
- pixel;
-
- pixel=(float) GetPixelIntensity(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
+ quantum=GetPixelGreen(image,p);
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 2:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
-
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
+ quantum=GetPixelBlue(image,p);
break;
}
- }
- default:
- {
- 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);
- p+=channels;
- q+=quantum_info->pad;
}
- break;
+ cbcr[i]=(Quantum) quantum;
+ n++;
}
+ range=GetQuantumRange(quantum_info->depth);
+ 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_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;
}
break;
}
- case GrayAlphaQuantum:
- {
- switch (quantum_info->depth)
- {
- case 1:
- {
- register Quantum
- threshold;
+ }
+}
- register unsigned char
- black,
- pixel,
- white;
+static void ExportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ register ssize_t
+ x;
- black=0x00;
- white=0x01;
- if (quantum_info->min_is_white == MagickFalse)
- {
- black=0x01;
- white=0x00;
- }
- threshold=(Quantum) (QuantumRange/2);
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
- {
- *q='\0';
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 7;
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
- p+=channels;
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 5;
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
- p+=channels;
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 3;
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
- p+=channels;
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 1;
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
- p+=channels;
- q++;
- }
- if ((number_pixels % 4) != 0)
- {
- *q='\0';
- for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
- {
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) <<
- (7-bit);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
- (7-bit-1));
- p+=channels;
- }
- q++;
- }
- break;
- }
- case 4:
- {
- register unsigned char
- pixel;
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
- for (x=0; x < (ssize_t) number_pixels ; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
- *q|=pixel & 0xf;
- p+=channels;
- q++;
- }
- break;
- }
- case 8:
- {
- register unsigned char
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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;
-
- pixel=(float) GetPixelIntensity(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- pixel=(float) (GetPixelAlpha(image,p));
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ 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;
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
-
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
- p+=channels;
+ 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;
}
break;
}
+ }
+ default:
+ {
+ QuantumAny
+ range;
+
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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;
}
break;
}
- case RedQuantum:
- case CyanQuantum:
+ }
+}
+
+static void ExportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ register ssize_t
+ x;
+
+ if (image->colorspace != CMYKColorspace)
{
- switch (quantum_info->depth)
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
- {
- register unsigned char
- pixel;
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ 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=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ float
+ pixel;
+
+ 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_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned int
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelRed(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ 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_info,pixel,q);
+ p+=GetPixelChannels(image);
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)
- GetPixelRed(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ }
+ default:
+ {
+ QuantumAny
+ range;
+
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ register ssize_t
+ x;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case GreenQuantum:
- case MagentaQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned int
+ pixel;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ float
+ pixel;
+
+ 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) (GetPixelOpacity(image,p));
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ 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) (GetPixelOpacity(image,p));
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ }
+ default:
+ {
+ QuantumAny
+ range;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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(GetPixelOpacity(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register double
+ threshold;
+
+ register unsigned char
+ black,
+ white;
+
+ ssize_t
+ bit;
+
+ black=0x00;
+ white=0x01;
+ if (quantum_info->min_is_white != MagickFalse)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ black=0x01;
+ white=0x00;
}
- default:
+ threshold=QuantumRange/2.0;
+ for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ {
+ *q='\0';
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 8) != 0)
{
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
+ *q='\0';
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- p+=channels;
- q+=quantum_info->pad;
+ *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
+ p+=GetPixelChannels(image);
}
- break;
+ q++;
}
- }
break;
}
- case BlueQuantum:
- case YellowQuantum:
+ case 4:
{
- switch (quantum_info->depth)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
{
- case 8:
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
+ *q|=pixel >> 4;
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 2) != 0)
{
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ q++;
}
- case 16:
- {
- register unsigned short
- pixel;
+ break;
+ }
+ case 8:
+ {
+ register unsigned char
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
register unsigned int
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ pixel=(unsigned int) (ScaleQuantumToAny(ClampToQuantum(
+ GetPixelLuma(image,p+2*GetPixelChannels(image))),range) << 22 |
+ ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
+ GetPixelChannels(image))),range) << 12 | ScaleQuantumToAny(
+ ClampToQuantum(GetPixelLuma(image,p)),range) << 2);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=3*GetPixelChannels(image);
q+=quantum_info->pad;
}
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ if (x < (ssize_t) number_pixels)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
+ pixel=0U;
+ if (x++ < (ssize_t) (number_pixels-1))
+ pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
+ GetPixelChannels(image))),range) << 12;
+ if (x++ < (ssize_t) number_pixels)
+ pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),
+ range) << 2;
+ q=PopLongPixel(quantum_info->endian,pixel,q);
}
+ break;
}
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+ GetPixelLuma(image,p)),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned short
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- 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);
- p+=channels;
+ pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel >> 4),
+ q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+ GetPixelLuma(image,p)),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case AlphaQuantum:
+ case 16:
{
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned short
+ pixel;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelLuma(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ float
+ pixel;
+
+ pixel=(float) GetPixelLuma(image,p);
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- float
- pixel;
-
- pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ double
+ pixel;
+
+ pixel=GetPixelLuma(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+ GetPixelLuma(image,p)),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register double
+ threshold;
+
+ register unsigned char
+ black,
+ pixel,
+ white;
+
+ ssize_t
+ bit;
+
+ black=0x00;
+ white=0x01;
+ if (quantum_info->min_is_white != MagickFalse)
+ {
+ black=0x01;
+ white=0x00;
}
- default:
+ threshold=QuantumRange/2.0;
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ {
+ *q='\0';
+ *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 7;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 5;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 3;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 4) != 0)
{
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
+ *q='\0';
+ for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
- q+=quantum_info->pad;
+ *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
+ (7-bit);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
+ (7-bit-1));
+ p+=GetPixelChannels(image);
}
- break;
+ q++;
}
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels ; x++)
+ {
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
+ *q|=pixel & 0xf;
+ p+=GetPixelChannels(image);
+ q++;
}
break;
}
- case OpacityQuantum:
+ case 8:
{
- switch (quantum_info->depth)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
- {
- register unsigned char
- pixel;
+ pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelLuma(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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)
- GetPixelAlpha(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- 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)
- GetPixelAlpha(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
- p+=channels;
+ float
+ pixel;
+
+ pixel=(float) GetPixelLuma(image,p);
+ q=PopFloatPixel(quantum_info,pixel,q);
+ pixel=(float) (GetPixelAlpha(image,p));
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case BlackQuantum:
+ case 64:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ double
+ pixel;
+
+ pixel=GetPixelLuma(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
+ pixel=(double) (GetPixelAlpha(image,p));
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
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*
- GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+ GetPixelLuma(image,p)),range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ 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=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlack(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+static void ExportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ if (image->storage_class != PseudoClass)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0x01) << 7);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 6);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 5);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 4);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 3);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 2);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 1);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 8) != 0)
+ {
+ *q='\0';
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << (unsigned char) bit);
+ p+=GetPixelChannels(image);
+ }
+ q++;
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0xf) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 2) != 0)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ break;
+ }
+ case 8:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(
+ QuantumScale*GetPixelIndex(image,p)),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopShortPixel(quantum_info->endian,(unsigned short)
+ GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlack(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(quantum_info,(float) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
}
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopLongPixel(quantum_info->endian,(unsigned int)
+ GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny((Quantum) GetPixelBlack(image,p),range),q);
- p+=channels;
+ q=PopDoublePixel(quantum_info,(double) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ }
+ default:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case RGBQuantum:
- case CbYCrQuantum:
+ }
+}
+
+static void ExportIndexAlphaQuantum(const Image *image,
+ QuantumInfo *quantum_info,const MagickSizeType number_pixels,
+ const Quantum *magick_restrict p,unsigned char *magick_restrict q,
+ ExceptionInfo *exception)
+{
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ if (image->storage_class != PseudoClass)
{
- switch (quantum_info->depth)
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
{
- case 8:
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0x01) << 7);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 6);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 5);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 4);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 3);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 2);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 1);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 4) != 0)
+ {
+ *q='\0';
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << (unsigned char) (bit+4));
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
+ p+=GetPixelChannels(image);
+ }
+ q++;
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels ; x++)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0xf) << 4);
+ pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
+ *q|=((pixel & 0xf) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ break;
+ }
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ 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++)
+ {
+ q=PopShortPixel(quantum_info->endian,(unsigned short)
+ GetPixelIndex(image,p),q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopShortPixel(quantum_info->endian,(unsigned short)
+ GetPixelIndex(image,p),q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
- p+=channels;
+ float
+ pixel;
+
+ q=PopFloatPixel(quantum_info,(float) GetPixelIndex(image,p),q);
+ pixel=(float) GetPixelAlpha(image,p);
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 10:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopLongPixel(quantum_info->endian,(unsigned int)
+ GetPixelIndex(image,p),q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ double
+ pixel;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) (
- ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
- ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
- ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
+ q=PopDoublePixel(quantum_info,(double) GetPixelIndex(image,p),q);
+ pixel=(double) GetPixelAlpha(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ QuantumAny
+ range;
+
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ 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*GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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_info,(float) GetPixelOpacity(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(quantum_info,(double) GetPixelOpacity(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
+ GetPixelOpacity(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportRedQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ 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*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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_info,(float) GetPixelRed(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
+ p+=GetPixelChannels(image);
+ 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(GetPixelRed(image,p),range) << 22 |
+ ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
+ ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ 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)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
+ break;
+ }
+ case 1:
+ {
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
+ break;
+ }
+ case 2:
+ {
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
+ p+=GetPixelChannels(image);
+ break;
}
- break;
}
- 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);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 12:
- {
- register unsigned int
- pixel;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
+ switch ((x+1) % 3)
{
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ default:
+ case 0:
{
- switch (x % 3)
- {
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
- }
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- switch ((x+1) % 3)
- {
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
- }
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
}
- for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ case 1:
{
- switch ((x+bit) % 3)
- {
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
- }
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ p+=GetPixelChannels(image);
+ break;
}
- if (bit != 0)
- p+=channels;
- break;
}
- if (quantum_info->quantum == 32UL)
+ 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++)
+ {
+ switch ((x+bit) % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
+ break;
+ }
+ case 1:
+ {
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
+ break;
+ }
+ case 2:
+ {
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
+ p+=GetPixelChannels(image);
+ break;
}
- break;
}
- 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);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
+ q);
q+=quantum_info->pad;
}
+ if (bit != 0)
+ p+=GetPixelChannels(image);
break;
}
- case 16:
+ if (quantum_info->quantum == 32UL)
{
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ 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++)
- {
- 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);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
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)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
- p+=channels;
+ 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;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case RGBAQuantum:
- case RGBOQuantum:
- case CbYCrAQuantum:
+ case 64:
{
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ 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;
}
break;
}
- case 10:
- {
- register unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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;
+ }
+ break;
+ }
+ }
+}
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
+static void ExportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ 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;
+ size_t
+ quantum;
- ssize_t
- n;
+ ssize_t
+ n;
- n=0;
- quantum=0;
- pixel=0;
- for (x=0; x < (ssize_t) number_pixels; x++)
+ n=0;
+ quantum=0;
+ pixel=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (i)
{
- for (i=0; i < 4; i++)
- {
- switch (i)
- {
- case 0: quantum=GetPixelRed(image,p); break;
- case 1: quantum=GetPixelGreen(image,p); break;
- case 2: quantum=GetPixelBlue(image,p); break;
- case 3: quantum=GetPixelAlpha(image,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+=channels;
- q+=quantum_info->pad;
+ case 0: quantum=GetPixelRed(image,p); break;
+ case 1: quantum=GetPixelGreen(image,p); break;
+ case 2: quantum=GetPixelBlue(image,p); break;
+ case 3: quantum=GetPixelAlpha(image,p); break;
}
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (n % 3)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
+ 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(quantum_info->endian,pixel,q);
+ pixel=0;
+ break;
+ }
}
- break;
+ n++;
}
- 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);
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelAlpha(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ if (quantum_info->quantum == 32UL)
{
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ 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++)
- {
- 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);
- pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
- 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);
- pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
- p+=channels;
+ float
+ pixel;
+
+ 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_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case CMYKQuantum:
+ case 64:
{
- if (image->colorspace != CMYKColorspace)
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
+ double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ 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_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickCoreSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- register unsigned short
- pixel;
+ register ssize_t
+ i;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ pixel=0;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (i=0; i < 4; i++)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (i)
{
- 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);
- p+=channels;
- q+=quantum_info->pad;
+ case 0: quantum=GetPixelRed(image,p); break;
+ case 1: quantum=GetPixelGreen(image,p); break;
+ case 2: quantum=GetPixelBlue(image,p); break;
+ case 3: quantum=GetPixelOpacity(image,p); break;
}
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (n % 3)
{
- 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);
- p+=channels;
- q+=quantum_info->pad;
+ 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(quantum_info->endian,pixel,q);
+ pixel=0;
+ break;
+ }
}
- break;
+ n++;
}
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
}
- default:
+ if (quantum_info->quantum == 32UL)
{
- 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);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case CMYKAQuantum:
- case CMYKOQuantum:
+ case 16:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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)
- 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);
- pixel=(float) (GetPixelAlpha(image,p));
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ float
+ pixel;
+
+ 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) GetPixelOpacity(image,p);
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ double
+ pixel;
- 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);
- pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- 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(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);
- p+=channels;
+ 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) GetPixelOpacity(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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(GetPixelOpacity(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case CbYCrYQuantum:
- {
- Quantum
- cbcr[4];
+ }
+}
+
+MagickExport size_t ExportQuantumPixels(const Image *image,
+ CacheView *image_view,QuantumInfo *quantum_info,
+ const QuantumType quantum_type,unsigned char *magick_restrict pixels,
+ ExceptionInfo *exception)
+{
+ MagickSizeType
+ number_pixels;
- register ssize_t
- i;
+ register const Quantum
+ *magick_restrict p;
- register unsigned int
- pixel;
+ register ssize_t
+ x;
- size_t
- quantum;
+ register unsigned char
+ *magick_restrict q;
- ssize_t
- n;
+ size_t
+ extent;
- n=0;
- quantum=0;
- range=GetQuantumRange(quantum_info->depth);
- switch (quantum_info->depth)
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ assert(quantum_info != (QuantumInfo *) NULL);
+ assert(quantum_info->signature == MagickCoreSignature);
+ if (pixels == (unsigned char *) NULL)
+ pixels=(unsigned char *) GetQuantumPixels(quantum_info);
+ if (image_view == (CacheView *) NULL)
+ {
+ number_pixels=GetImageExtent(image);
+ p=GetVirtualPixelQueue(image);
+ }
+ else
+ {
+ number_pixels=GetCacheViewExtent(image_view);
+ p=GetCacheViewVirtualPixelQueue(image_view);
+ }
+ if (quantum_info->alpha_type == AssociatedQuantumAlpha)
+ {
+ double
+ Sa;
+
+ register Quantum
+ *magick_restrict q;
+
+ /*
+ Associate alpha.
+ */
+ q=GetAuthenticPixelQueue(image);
+ if (image_view != (CacheView *) NULL)
+ q=GetCacheViewAuthenticPixelQueue(image_view);
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- case 10:
- {
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x+=2)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- quantum=GetPixelRed(image,p);
- break;
- }
- case 1:
- {
- quantum=GetPixelGreen(image,p);
- break;
- }
- case 2:
- {
- quantum=GetPixelBlue(image,p);
- break;
- }
- }
- cbcr[i]=(Quantum) quantum;
- n++;
- }
- pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
- (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
- (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- break;
- }
- default:
- {
- for (x=0; x < (ssize_t) number_pixels; x+=2)
+ register ssize_t
+ i;
+
+ if (GetPixelWriteMask(image,q) <= (QuantumRange/2))
{
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- quantum=GetPixelRed(image,p);
- break;
- }
- case 1:
- {
- quantum=GetPixelGreen(image,p);
- break;
- }
- case 2:
- {
- quantum=GetPixelBlue(image,p);
- break;
- }
- }
- cbcr[i]=(Quantum) quantum;
- n++;
- }
- 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+=channels;
- 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+=channels;
- q+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ continue;
}
- break;
+ Sa=QuantumScale*GetPixelAlpha(image,q);
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel = GetPixelChannelChannel(image,i);
+ PixelTrait traits = GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(Sa*q[i]);
}
+ q+=GetPixelChannels(image);
}
- break;
}
- default:
- break;
- }
if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
{
Quantum
quantum;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
+ q=GetAuthenticPixelQueue(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
quantum=GetPixelRed(image,q);
SetPixelRed(image,GetPixelGreen(image,q),q);
SetPixelGreen(image,quantum,q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
- (quantum_type == BGROQuantum))
+ x=0;
+ q=pixels;
+ ResetQuantumState(quantum_info);
+ extent=GetQuantumExtent(image,quantum_info,quantum_type);
+ switch (quantum_type)
+ {
+ case AlphaQuantum:
+ {
+ ExportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BGRQuantum:
+ {
+ ExportBGRQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BGRAQuantum:
+ {
+ ExportBGRAQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BGROQuantum:
+ {
+ ExportBGROQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BlackQuantum:
+ {
+ ExportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ ExportBlueQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case CMYKQuantum:
+ {
+ ExportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case CMYKAQuantum:
+ {
+ ExportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case CMYKOQuantum:
+ {
+ ExportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case CbYCrYQuantum:
+ {
+ ExportCbYCrYQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case GrayQuantum:
+ {
+ ExportGrayQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case GrayAlphaQuantum:
+ {
+ ExportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ ExportGreenQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case IndexQuantum:
+ {
+ ExportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case IndexAlphaQuantum:
+ {
+ ExportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ ExportRedQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ ExportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case RGBQuantum:
+ case CbYCrQuantum:
+ {
+ ExportRGBQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case RGBAQuantum:
+ case CbYCrAQuantum:
+ {
+ ExportRGBAQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case RGBOQuantum:
+ {
+ ExportRGBOQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ default:
+ break;
+ }
+ if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
{
+ Quantum
+ quantum;
+
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=GetCacheViewAuthenticPixelQueue(image_view);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=channels;
+ quantum=GetPixelRed(image,q);
+ SetPixelRed(image,GetPixelGreen(image,q),q);
+ SetPixelGreen(image,quantum,q);
+ q+=GetPixelChannels(image);
}
}
return(extent);
projects / imagemagick / blobdiff