From 0897d38090922ca628fa87157844e3ee0ca07911 Mon Sep 17 00:00:00 2001 From: cristy Date: Fri, 6 Jan 2012 01:41:05 +0000 Subject: [PATCH] --- MagickCore/quantum-export.c | 5087 ++++++++++++++++++----------------- 1 file changed, 2638 insertions(+), 2449 deletions(-) diff --git a/MagickCore/quantum-export.c b/MagickCore/quantum-export.c index fd8a70fce..de0ea4498 100644 --- a/MagickCore/quantum-export.c +++ b/MagickCore/quantum-export.c @@ -233,3068 +233,3257 @@ static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state, 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, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *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) + endian=quantum_state.endian; + 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(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(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_state,(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(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_state,(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_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelAlpha(image,p),range),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} + +static void ExportBGRQuantum(const Image *image,const QuantumInfo *quantum_info, + QuantumState quantum_state,const MagickSizeType number_pixels, + const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + ssize_t + bit; + + endian=quantum_state.endian; + 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(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_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+=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_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+=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(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(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: + { + pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p), + range); + break; + } + case 1: { - q=PopDoublePixel(&quantum_state,(double) - GetPixelIndex(image,p),q); - p+=channels; - 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; } - break; } + q=PopShortPixel(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_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+=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_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+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case IndexAlphaQuantum: + case 16: { - if (image->storage_class != PseudoClass) + register unsigned short + pixel; + + if (quantum_info->format == FloatingPointQuantumFormat) { - (void) ThrowMagickException(exception,GetMagickModule(),ImageError, - "ColormappedImageRequired","`%s'",image->filename); - return(extent); + 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+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; } - switch (quantum_info->depth) + for (x=0; x < (ssize_t) number_pixels; x++) { - case 1: - { - register unsigned char - pixel; - - for (x=((ssize_t) number_pixels-3); x > 0; x-=4) - { - 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++; - } - 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=(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++; - } - 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+=channels; - q+=quantum_info->pad; - } - break; - } - case 16: - { - register unsigned short - pixel; + 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+=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=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; - } - break; - } - 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; - q+=quantum_info->pad; - } - break; - } - case 32: + 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) - 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; + 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+=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=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+=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, - GetPixelIndex(image,p),q); - q=PopQuantumPixel(&quantum_state,quantum_info->depth, - ScaleQuantumToAny(GetPixelAlpha(image,p),range),q); - p+=channels; + 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+=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_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+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case BGRQuantum: + } +} + +static void ExportBGRAQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 8: { - switch (quantum_info->depth) + register unsigned char + pixel; + + for (x=0; x < (ssize_t) number_pixels; x++) { - case 8: + 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 ssize_t + i; + + size_t + quantum; + + ssize_t + n; + + n=0; + quantum=0; + pixel=0; 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; - 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(endian,pixel,q); - p+=channels; - q+=quantum_info->pad; - } - break; - } - if (quantum_info->quantum == 32UL) + for (i=0; i < 4; i++) { - for (x=0; x < (ssize_t) number_pixels; x++) + switch (i) { - 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; + 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; - } - 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) - { - for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2) + 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(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_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), + 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=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q); - p+=channels; + q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,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_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+=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)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p)); + q=PopShortPixel(endian,pixel,q); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p)); q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelGreen(image,p)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p)); q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelRed(image,p)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p)); q=PopShortPixel(endian,pixel,q); - p+=channels; + 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(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+=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: + 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_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+=GetPixelChannels(image); 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+=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_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+=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; + } + default: + { + 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+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} - size_t - quantum; +static void ExportBlackQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; - ssize_t - n; + QuantumAny + range; - 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; - } + register ssize_t + x; + + if (image->colorspace != CMYKColorspace) + { + (void) ThrowMagickException(exception,GetMagickModule(),ImageError, + "ColorSeparatedImageRequired","`%s'",image->filename); + return; + } + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 8: + { + register unsigned char + pixel; + + 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(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(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_state,(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(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_state,(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_state,quantum_info->depth, + 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, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 8: + { + 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(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(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_state,(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(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_state,(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_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelBlue(image,p),range),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} + +static void ExportCbYCrYQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + Quantum + cbcr[4]; + + register ssize_t + i, + x; + + register unsigned int + pixel; + + size_t + quantum; + + ssize_t + n; + + endian=quantum_state.endian; + 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*channels),range) << 22 | - ScaleQuantumToAny(GetPixelIntensity(image,p+channels),range) << 12 | - ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2); - q=PopLongPixel(endian,pixel,q); - p+=3*channels; - q+=quantum_info->pad; - } - if (x < (ssize_t) number_pixels) + case 0: { - pixel=0U; - if (x++ < (ssize_t) (number_pixels-1)) - pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+channels), - range) << 12; - if (x++ < (ssize_t) number_pixels) - pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p), - range) << 2; - q=PopLongPixel(endian,pixel,q); + quantum=GetPixelRed(image,p); + break; } - break; + case 1: + { + quantum=GetPixelGreen(image,p); + break; + } + case 2: + { + quantum=GetPixelBlue(image,p); + 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(endian,pixel,q); + p+=GetPixelChannels(image); + pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t) + (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2); + q=PopLongPixel(endian,pixel,q); + 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) + case 1: { - 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; - } + quantum=GetPixelGreen(image,p); 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 2: { - 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=GetPixelBlue(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) - { - for (x=0; x < (ssize_t) number_pixels; x++) - { - double - pixel; + cbcr[i]=(Quantum) quantum; + n++; + } + range=GetQuantumRange(quantum_info->depth); + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(cbcr[1],range),q); + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(cbcr[0],range),q); + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(cbcr[2],range),q); + p+=GetPixelChannels(image); + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(cbcr[3],range),q); + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(cbcr[0],range),q); + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(cbcr[2],range),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} - pixel=(double) GetPixelIntensity(image,p); - q=PopDoublePixel(&quantum_state,pixel,q); - p+=channels; - q+=quantum_info->pad; - } - break; - } - } - default: +static void ExportCMYKQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + register ssize_t + x; + + if (image->colorspace != CMYKColorspace) + { + (void) ThrowMagickException(exception,GetMagickModule(),ImageError, + "ColorSeparatedImageRequired","`%s'",image->filename); + return; + } + endian=quantum_state.endian; + 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); + 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(GetPixelIntensity(image,p),range),q); - p+=channels; + 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+=GetPixelChannels(image); 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); + p+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case GrayAlphaQuantum: + case 32: { - switch (quantum_info->depth) - { - case 1: - { - register Quantum - threshold; - - register unsigned char - black, - pixel, - 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-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: + if (quantum_info->format == FloatingPointQuantumFormat) { - register unsigned char - pixel; - - for (x=0; x < (ssize_t) number_pixels ; x++) + 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++; + 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+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case 8: + 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+=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); - pixel=ScaleQuantumToChar(GetPixelAlpha(image,p)); - q=PopCharPixel(pixel,q); - p+=channels; + 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+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 16: - { - register unsigned short - pixel; + } + default: + { + QuantumAny + range; - 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; - } + 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+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} + +static void ExportCMYKAQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + register ssize_t + x; + + if (image->colorspace != CMYKColorspace) + { + (void) ThrowMagickException(exception,GetMagickModule(),ImageError, + "ColorSeparatedImageRequired","`%s'",image->filename); + return; + } + endian=quantum_state.endian; + 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(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=ScaleQuantumToShort(GetPixelIntensity(image,p)); + 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=ScaleQuantumToShort(GetPixelAlpha(image,p)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p)); q=PopShortPixel(endian,pixel,q); - p+=channels; + 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(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+=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; - } - 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+=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: + 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; + 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+=GetPixelChannels(image); q+=quantum_info->pad; } 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); + pixel=ScaleQuantumToLong(GetPixelAlpha(image,p)); + q=PopLongPixel(endian,pixel,q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case RedQuantum: - case CyanQuantum: + 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(GetPixelRed(image,p)); - q=PopCharPixel(pixel,q); - p+=channels; + 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+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 16: - { - register unsigned short - pixel; + } + default: + { + QuantumAny + range; - 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; - } - for (x=0; x < (ssize_t) number_pixels; x++) + 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+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} + +static void ExportGrayQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 1: + { + register Quantum + threshold; + + register unsigned char + black, + white; + + ssize_t + bit; + + 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+=GetPixelChannels(image); + *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 6; + p+=GetPixelChannels(image); + *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 5; + p+=GetPixelChannels(image); + *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 4; + p+=GetPixelChannels(image); + *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 3; + p+=GetPixelChannels(image); + *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 2; + p+=GetPixelChannels(image); + *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 1; + p+=GetPixelChannels(image); + *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 0; + p+=GetPixelChannels(image); + q++; + } + if ((number_pixels % 8) != 0) + { + *q='\0'; + for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--) { - pixel=ScaleQuantumToShort(GetPixelRed(image,p)); - q=PopShortPixel(endian,pixel,q); - p+=channels; - q+=quantum_info->pad; + *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << bit; + p+=GetPixelChannels(image); } - break; + q++; + } + break; + } + case 4: + { + register unsigned char + pixel; + + for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2) + { + pixel=ScaleQuantumToChar(GetPixelIntensity(image,p)); + *q=(((pixel >> 4) & 0xf) << 4); + p+=GetPixelChannels(image); + pixel=ScaleQuantumToChar(GetPixelIntensity(image,p)); + *q|=pixel >> 4; + p+=GetPixelChannels(image); + q++; + } + if ((number_pixels % 2) != 0) + { + pixel=ScaleQuantumToChar(GetPixelIntensity(image,p)); + *q=(((pixel >> 4) & 0xf) << 4); + p+=GetPixelChannels(image); + q++; } - case 32: + break; + } + case 8: + { + register unsigned char + pixel; + + for (x=0; x < (ssize_t) number_pixels; x++) + { + pixel=ScaleQuantumToChar(GetPixelIntensity(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) - GetPixelRed(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(GetPixelRed(image,p)); + pixel=(unsigned int) ( + ScaleQuantumToAny(GetPixelIntensity(image,p+2*GetPixelChannels(image)),range) << 22 | + ScaleQuantumToAny(GetPixelIntensity(image,p+GetPixelChannels(image)),range) << 12 | + ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2); q=PopLongPixel(endian,pixel,q); - p+=channels; + 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) - GetPixelRed(image,p),q); - p+=channels; - q+=quantum_info->pad; - } - break; + pixel=0U; + if (x++ < (ssize_t) (number_pixels-1)) + pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+GetPixelChannels(image)), + range) << 12; + if (x++ < (ssize_t) number_pixels) + pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p), + range) << 2; + q=PopLongPixel(endian,pixel,q); } + break; } - default: + for (x=0; x < (ssize_t) number_pixels; x++) + { + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelIntensity(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(GetPixelRed(image,p),range),q); - p+=channels; + pixel=ScaleQuantumToShort(GetPixelIntensity(image,p)); + q=PopShortPixel(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_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelIntensity(image,p),range),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case GreenQuantum: - case MagentaQuantum: + 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(GetPixelGreen(image,p)); - q=PopCharPixel(pixel,q); - p+=channels; + pixel=SinglePrecisionToHalf(QuantumScale* + GetPixelIntensity(image,p)); + q=PopShortPixel(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(GetPixelIntensity(image,p)); + q=PopShortPixel(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* - GetPixelGreen(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(GetPixelGreen(image,p)); - q=PopShortPixel(endian,pixel,q); - p+=channels; + float + pixel; + + pixel=(float) GetPixelIntensity(image,p); + q=PopFloatPixel(&quantum_state,pixel,q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 32: + for (x=0; x < (ssize_t) number_pixels; x++) + { + pixel=ScaleQuantumToLong(GetPixelIntensity(image,p)); + q=PopLongPixel(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++) - { - 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; + double + pixel; + + pixel=(double) GetPixelIntensity(image,p); + q=PopDoublePixel(&quantum_state,pixel,q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 64: + } + 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+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} + +static void ExportGrayAlphaQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 1: + { + register Quantum + threshold; + + register unsigned char + black, + pixel, + 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=(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+=GetPixelChannels(image); + *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+=GetPixelChannels(image); + *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+=GetPixelChannels(image); + *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+=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(GetPixelGreen(image,p),range),q); - p+=channels; - q+=quantum_info->pad; + *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+=GetPixelChannels(image); } - break; + q++; } + break; + } + case 4: + { + 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+=GetPixelChannels(image); + q++; } break; } - case BlueQuantum: - case YellowQuantum: + 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(GetPixelIntensity(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(GetPixelBlue(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* - 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)); + pixel=SinglePrecisionToHalf(QuantumScale* + GetPixelIntensity(image,p)); q=PopShortPixel(endian,pixel,q); - p+=channels; + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p)); + q=PopShortPixel(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(GetPixelIntensity(image,p)); + q=PopShortPixel(endian,pixel,q); + pixel=ScaleQuantumToShort(GetPixelAlpha(image,p)); + q=PopShortPixel(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) - 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); - 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) - GetPixelBlue(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(GetPixelBlue(image,p),range),q); - p+=channels; + 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+=GetPixelChannels(image); q+=quantum_info->pad; } break; } + 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+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case AlphaQuantum: + 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(GetPixelAlpha(image,p)); - q=PopCharPixel(pixel,q); - p+=channels; - q+=quantum_info->pad; - } - break; - } - case 16: - { - register unsigned short - pixel; + double + 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=(double) GetPixelIntensity(image,p); + q=PopDoublePixel(&quantum_state,pixel,q); + pixel=(double) (GetPixelAlpha(image,p)); + q=PopDoublePixel(&quantum_state,pixel,q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 32: - { - register unsigned int - pixel; + } + 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); + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelAlpha(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++) - { - float - pixel; +static void ExportGreenQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; - 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; - q+=quantum_info->pad; - } - break; - } - case 64: - { - if (quantum_info->format == FloatingPointQuantumFormat) - { - for (x=0; x < (ssize_t) number_pixels; x++) - { - double - pixel; + QuantumAny + range; - pixel=(double) (GetPixelAlpha(image,p)); - q=PopDoublePixel(&quantum_state,pixel,q); - p+=channels; - q+=quantum_info->pad; - } - break; - } - } - default: + register ssize_t + x; + + endian=quantum_state.endian; + 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) { - 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; + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p)); + q=PopShortPixel(endian,pixel,q); + p+=GetPixelChannels(image); 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+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case OpacityQuantum: + 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(GetPixelAlpha(image,p)); - q=PopCharPixel(pixel,q); - p+=channels; + q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 16: + for (x=0; x < (ssize_t) number_pixels; x++) + { + pixel=ScaleQuantumToLong(GetPixelGreen(image,p)); + q=PopLongPixel(endian,pixel,q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + case 64: + { + 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; + q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),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; + } + default: + { + range=GetQuantumRange(quantum_info->depth); + for (x=0; x < (ssize_t) number_pixels; x++) + { + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelGreen(image,p),range),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} + +static void ExportIndexQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + register ssize_t + x; + + ssize_t + bit; + + if (image->storage_class != PseudoClass) + { + (void) ThrowMagickException(exception,GetMagickModule(),ImageError, + "ColormappedImageRequired","`%s'",image->filename); + return; + } + endian=quantum_state.endian; + 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); } - break; + q++; } - case 64: + 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) { - 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; - } + pixel=(unsigned char) GetPixelIndex(image,p); + *q=((pixel & 0xf) << 4); + p+=GetPixelChannels(image); + q++; } - default: + 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) { - 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; + q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale* + GetPixelIndex(image,p)),q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } + for (x=0; x < (ssize_t) number_pixels; x++) + { + q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case BlackQuantum: + case 32: { - if (image->colorspace != CMYKColorspace) + if (quantum_info->format == FloatingPointQuantumFormat) { - (void) ThrowMagickException(exception,GetMagickModule(),ImageError, - "ColorSeparatedImageRequired","`%s'",image->filename); - return(extent); + for (x=0; x < (ssize_t) number_pixels; x++) + { + q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; } - switch (quantum_info->depth) + for (x=0; x < (ssize_t) number_pixels; x++) { - case 8: + q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),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(GetPixelBlack(image,p)); - q=PopCharPixel(pixel,q); - p+=channels; + q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 16: + } + default: + { + for (x=0; x < (ssize_t) number_pixels; x++) + { + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + GetPixelIndex(image,p),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} + +static void ExportIndexAlphaQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + register ssize_t + x; + + ssize_t + bit; + + if (image->storage_class != PseudoClass) + { + (void) ThrowMagickException(exception,GetMagickModule(),ImageError, + "ColormappedImageRequired","`%s'",image->filename); + return; + } + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 1: + { + register unsigned char + pixel; + + for (x=((ssize_t) number_pixels-3); x > 0; x-=4) + { + 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) { - register unsigned short - pixel; + *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; - 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; - } + 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++) { - pixel=ScaleQuantumToShort(GetPixelBlack(image,p)); + q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p)); q=PopShortPixel(endian,pixel,q); - p+=channels; + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 32: - { - register unsigned int - pixel; + 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+=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) - GetPixelBlack(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(GetPixelBlack(image,p)); - q=PopLongPixel(endian,pixel,q); - p+=channels; + float + pixel; + + q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q); + pixel=(float) GetPixelAlpha(image,p); + q=PopFloatPixel(&quantum_state,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) - GetPixelBlack(image,p),q); - p+=channels; - q+=quantum_info->pad; - } - break; - } - } - default: + 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+=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; + double + pixel; + + q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q); + pixel=(double) GetPixelAlpha(image,p); + q=PopDoublePixel(&quantum_state,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_state,quantum_info->depth, + GetPixelIndex(image,p),q); + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelAlpha(image,p),range),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case RGBQuantum: - case CbYCrQuantum: + } +} + +static void ExportOpacityQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 8: { - switch (quantum_info->depth) + register unsigned char + pixel; + + for (x=0; x < (ssize_t) number_pixels; x++) { - case 8: + 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++) { - q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q); - q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q); - q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q); - p+=channels; + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p)); + q=PopShortPixel(endian,pixel,q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 10: - { - register unsigned int - pixel; + for (x=0; x < (ssize_t) number_pixels; x++) + { + pixel=ScaleQuantumToShort(GetPixelOpacity(image,p)); + q=PopShortPixel(endian,pixel,q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + case 32: + { + 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(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; - } + 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); - p+=channels; + q=PopFloatPixel(&quantum_state,(float) GetPixelOpacity(image,p),q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 12: + for (x=0; x < (ssize_t) number_pixels; x++) + { + pixel=ScaleQuantumToLong(GetPixelOpacity(image,p)); + q=PopLongPixel(endian,pixel,q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + case 64: + { + if (quantum_info->format == FloatingPointQuantumFormat) { - register unsigned int - pixel; - - range=GetQuantumRange(quantum_info->depth); - if (quantum_info->pack == MagickFalse) - { - for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2) - { - switch (x % 3) - { - default: - case 0: - { - pixel=(unsigned int) ScaleQuantumToAny( - 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; - } - for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++) - { - 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; - } - 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; - } 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_state,(double) GetPixelOpacity(image,p), + q); + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 16: - { - register unsigned short - pixel; + } + default: + { + range=GetQuantumRange(quantum_info->depth); + for (x=0; x < (ssize_t) number_pixels; x++) + { + q=PopQuantumPixel(&quantum_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelOpacity(image,p),range),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} - 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; - } +static void ExportRedQuantum(const Image *image,const QuantumInfo *quantum_info, + QuantumState quantum_state,const MagickSizeType number_pixels, + const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + endian=quantum_state.endian; + 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=ScaleQuantumToShort(GetPixelRed(image,p)); - q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelGreen(image,p)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p)); q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelBlue(image,p)); - q=PopShortPixel(endian,pixel,q); - p+=channels; + 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(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; - } + 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; + q=PopFloatPixel(&quantum_state,(float) GetPixelRed(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++) - { - 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=ScaleQuantumToLong(GetPixelRed(image,p)); + q=PopLongPixel(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(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=PopDoublePixel(&quantum_state,(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_state,quantum_info->depth, + ScaleQuantumToAny(GetPixelRed(image,p),range),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case RGBAQuantum: - case RGBOQuantum: - case CbYCrAQuantum: + } +} + +static void ExportRGBQuantum(const Image *image,const QuantumInfo *quantum_info, + QuantumState quantum_state,const MagickSizeType number_pixels, + const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + ssize_t + bit; + + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 8: { - switch (quantum_info->depth) + for (x=0; x < (ssize_t) number_pixels; x++) { - case 8: - { - register unsigned char - pixel; + 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=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; + 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+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 10: + if (quantum_info->quantum == 32UL) { - register unsigned int - pixel; + 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+=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_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+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + case 12: + { + register unsigned int + pixel; - range=GetQuantumRange(quantum_info->depth); - if (quantum_info->pack == MagickFalse) + 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) { - register ssize_t - i; - - size_t - quantum; - - ssize_t - n; - - n=0; - quantum=0; - pixel=0; - for (x=0; x < (ssize_t) number_pixels; x++) + default: + case 0: { - 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; + 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; } - if (quantum_info->quantum == 32UL) + q=PopShortPixel(endian,(unsigned short) (pixel << 4),q); + switch ((x+1) % 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); - pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(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); - pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p), - range); - q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q); - p+=channels; + q=PopShortPixel(endian,(unsigned short) (pixel << 4),q); q+=quantum_info->pad; } - break; - } - case 16: - { - register unsigned short - pixel; - - 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: { - 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; + 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++) - { - 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; + q=PopShortPixel(endian,(unsigned short) (pixel << 4),q); q+=quantum_info->pad; } + if (bit != 0) + p+=GetPixelChannels(image); 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) - 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(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=(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+=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=(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+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + case 16: + { + register unsigned short + 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; + 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+=GetPixelChannels(image); 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+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case CMYKQuantum: + case 32: { - 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 int + pixel; + if (quantum_info->format == FloatingPointQuantumFormat) + { 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=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+=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(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; - } + 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+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + case 64: + { + if (quantum_info->format == FloatingPointQuantumFormat) + { 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=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+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 32: + } + 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); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + } +} + +static void ExportRGBAQuantum(const Image *image, + const QuantumInfo *quantum_info,QuantumState quantum_state, + const MagickSizeType number_pixels,const Quantum *restrict p, + unsigned char *restrict q,ExceptionInfo *exception) +{ + EndianType + endian; + + QuantumAny + range; + + register ssize_t + x; + + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 8: + { + 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 unsigned int - 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=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=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(endian,pixel,q); + pixel=0; + break; + } + } + n++; } - 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; + p+=GetPixelChannels(image); q+=quantum_info->pad; } break; } - case 64: + if (quantum_info->quantum == 32UL) { - 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); - q=PopDoublePixel(&quantum_state,(double) - GetPixelBlack(image,p),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); - p+=channels; + 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+=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_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+=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)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p)); q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelGreen(image,p)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p)); q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelBlue(image,p)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p)); q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelBlack(image,p)); + pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p)); q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelAlpha(image,p)); - q=PopShortPixel(endian,pixel,q); - p+=channels; + 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(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+=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_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+=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(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+=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_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+=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_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+=GetPixelChannels(image); + q+=quantum_info->pad; } break; } - case CbYCrYQuantum: - { - Quantum - cbcr[4]; + } +} - register ssize_t - i; +MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view, + const QuantumInfo *quantum_info,const QuantumType quantum_type, + unsigned char *pixels,ExceptionInfo *exception) +{ + MagickSizeType + number_pixels; - register unsigned int - pixel; + QuantumState + quantum_state; - size_t - quantum; + register const Quantum + *restrict p; - ssize_t - n; + register ssize_t + x; - n=0; - quantum=0; - range=GetQuantumRange(quantum_info->depth); - switch (quantum_info->depth) + register unsigned char + *restrict q; + + size_t + extent; + + 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); + } + else + { + number_pixels=GetCacheViewExtent(image_view); + p=GetCacheViewVirtualPixelQueue(image_view); + } + if (quantum_info->alpha_type == AssociatedQuantumAlpha) + { + MagickRealType + Sa; + + register Quantum + *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: + register ssize_t + i; + + Sa=QuantumScale*GetPixelAlpha(image,q); + for (i=0; i < (ssize_t) GetPixelChannels(image); i++) { - 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++; - } - 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; - } - break; + PixelChannel + channel; + + PixelTrait + traits; + + channel=GetPixelChannelMapChannel(image,i); + traits=GetPixelChannelMapTraits(image,channel); + if ((traits & UpdatePixelTrait) != 0) + q[i]=ClampToQuantum(Sa*q[i]); } + q+=GetPixelChannels(image); } + } + if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) || + (quantum_type == BGROQuantum)) + { + register Quantum + *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+=GetPixelChannels(image); + } + } + if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum)) + { + Quantum + quantum; + + register Quantum + *restrict q; + + q=GetAuthenticPixelQueue(image); + if (image_view != (CacheView *) NULL) + 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+=GetPixelChannels(image); + } + } + x=0; + q=pixels; + InitializeQuantumState(quantum_info,image->endian,&quantum_state); + extent=GetQuantumExtent(image,quantum_info,quantum_type); + switch (quantum_type) + { + case AlphaQuantum: + { + ExportAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case BGRQuantum: + { + ExportBGRQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case BGRAQuantum: + case BGROQuantum: + { + ExportBGRAQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case BlackQuantum: + { + ExportBlackQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case BlueQuantum: + case YellowQuantum: + { + ExportBlueQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case CMYKQuantum: + { + ExportCMYKQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case CMYKAQuantum: + case CMYKOQuantum: + { + ExportCMYKAQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case CbYCrYQuantum: + { + ExportCbYCrYQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case GrayQuantum: + { + ExportGrayQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case GrayAlphaQuantum: + { + ExportGrayAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case GreenQuantum: + case MagentaQuantum: + { + ExportGreenQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case IndexQuantum: + { + ExportIndexQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case IndexAlphaQuantum: + { + ExportIndexAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p, + q,exception); + break; + } + case RedQuantum: + case CyanQuantum: + { + ExportRedQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case OpacityQuantum: + { + ExportOpacityQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case RGBQuantum: + case CbYCrQuantum: + { + ExportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); + break; + } + case RGBAQuantum: + case RGBOQuantum: + case CbYCrAQuantum: + { + ExportRGBAQuantum(image,quantum_info,quantum_state,number_pixels,p,q, + exception); break; } default: @@ -3316,7 +3505,7 @@ MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view, 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) || @@ -3331,7 +3520,7 @@ MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view, for (x=0; x < (ssize_t) number_pixels; x++) { SetPixelAlpha(image,GetPixelAlpha(image,q),q); - q+=channels; + q+=GetPixelChannels(image); } } return(extent); -- 2.40.0