From: cristy Date: Thu, 5 Jan 2012 13:11:31 +0000 (+0000) Subject: (no commit message) X-Git-Tag: 7.0.1-0~6455 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=1930c67f6c085d323a9ffa0828fa1132236039be;p=imagemagick --- diff --git a/MagickCore/quantum-export.c b/MagickCore/quantum-export.c index a45ae90c6..9519c7406 100644 --- a/MagickCore/quantum-export.c +++ b/MagickCore/quantum-export.c @@ -233,6 +233,304 @@ static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state, return(pixels); } +static void ExportRGBQuantum(Image *image,const QuantumInfo *quantum_info, + QuantumState quantum_state,const MagickSizeType number_pixels, + const Quantum *restrict p,unsigned char *restrict q) +{ + EndianType + endian; + + QuantumAny + range; + + register size_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(GetPixelRed(image,p)),q); + q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q); + q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + case 10: + { + register unsigned int + pixel; + + range=GetQuantumRange(quantum_info->depth); + if (quantum_info->pack == MagickFalse) + { + for (x=0; x < (ssize_t) number_pixels; x++) + { + pixel=(unsigned int) ( + ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 | + ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 | + ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2); + q=PopLongPixel(endian,pixel,q); + p+=GetPixelChannels(image); + q+=quantum_info->pad; + } + break; + } + if (quantum_info->quantum == 32UL) + { + for (x=0; x < (ssize_t) number_pixels; x++) + { + pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range); + q=PopQuantumLongPixel(&quantum_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) + { + 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+=GetPixelChannels(image); + 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+=GetPixelChannels(image); + 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+=GetPixelChannels(image); + break; + } + } + q=PopShortPixel(endian,(unsigned short) (pixel << 4),q); + q+=quantum_info->pad; + } + if (bit != 0) + p+=GetPixelChannels(image); + 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+=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 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); + 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 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+=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); + 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+=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; + } + } +} + MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view, const QuantumInfo *quantum_info,const QuantumType quantum_type, unsigned char *pixels,ExceptionInfo *exception) @@ -2317,310 +2615,7 @@ MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view, case RGBQuantum: case CbYCrQuantum: { - switch (quantum_info->depth) - { - case 8: - { - for (x=0; x < (ssize_t) number_pixels; x++) - { - q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q); - q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q); - q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q); - p+=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 (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+=quantum_info->pad; - } - break; - } - case 12: - { - register unsigned int - pixel; - - range=GetQuantumRange(quantum_info->depth); - if (quantum_info->pack == MagickFalse) - { - for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2) - { - switch (x % 3) - { - default: - case 0: - { - pixel=(unsigned int) ScaleQuantumToAny( - 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+=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); - p+=channels; - q+=quantum_info->pad; - } - break; - } - for (x=0; x < (ssize_t) number_pixels; x++) - { - pixel=ScaleQuantumToShort(GetPixelRed(image,p)); - q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelGreen(image,p)); - q=PopShortPixel(endian,pixel,q); - pixel=ScaleQuantumToShort(GetPixelBlue(image,p)); - q=PopShortPixel(endian,pixel,q); - p+=channels; - 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(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+=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: - { - 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+=quantum_info->pad; - } - break; - } - } + ExportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q); break; } case RGBAQuantum: diff --git a/MagickCore/quantum-import.c b/MagickCore/quantum-import.c index 797b881b7..e656701dc 100644 --- a/MagickCore/quantum-import.c +++ b/MagickCore/quantum-import.c @@ -191,9 +191,7 @@ static inline const unsigned char *PushFloatPixel( return(pixels); } -static inline const unsigned char *PushQuantumPixel( - QuantumState *quantum_state,const size_t depth, - const unsigned char *pixels,unsigned int *quantum) +static inline const unsigned char *PushQuantumPixel(QuantumState *quantum_state, const size_t depth,const unsigned char *pixels,unsigned int *quantum) { register ssize_t i; @@ -222,8 +220,8 @@ static inline const unsigned char *PushQuantumPixel( } static inline const unsigned char *PushQuantumLongPixel( - QuantumState *quantum_state,const size_t depth, - const unsigned char *pixels,unsigned int *quantum) + QuantumState *quantum_state,const size_t depth,const unsigned char *pixels, + unsigned int *quantum) { register ssize_t i; @@ -251,6 +249,320 @@ static inline const unsigned char *PushQuantumLongPixel( return(pixels); } +static void ImportRGBQuantum(Image *image,const QuantumInfo *quantum_info, + QuantumState quantum_state,const MagickSizeType number_pixels, + const unsigned char *restrict p,Quantum *restrict q) +{ + EndianType + endian; + + QuantumAny + range; + + register size_t + x; + + ssize_t + bit; + + unsigned int + pixel; + + assert(image != (Image *) NULL); + endian=quantum_state.endian; + switch (quantum_info->depth) + { + case 8: + { + unsigned char + pixel; + + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushCharPixel(p,&pixel); + SetPixelRed(image,ScaleCharToQuantum(pixel),q); + p=PushCharPixel(p,&pixel); + SetPixelGreen(image,ScaleCharToQuantum(pixel),q); + p=PushCharPixel(p,&pixel); + SetPixelBlue(image,ScaleCharToQuantum(pixel),q); + SetPixelAlpha(image,OpaqueAlpha,q); + p+=quantum_info->pad; + q+=GetPixelChannels(image); + } + break; + } + case 10: + { + range=GetQuantumRange(image->depth); + if (quantum_info->pack == MagickFalse) + { + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushLongPixel(endian,p,&pixel); + SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q); + SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range), + q); + SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q); + p+=quantum_info->pad; + q+=GetPixelChannels(image); + } + break; + } + if (quantum_info->quantum == 32U) + { + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); + SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); + SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); + SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); + q+=GetPixelChannels(image); + } + break; + } + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); + q+=GetPixelChannels(image); + } + break; + } + case 12: + { + range=GetQuantumRange(image->depth); + if (quantum_info->pack == MagickFalse) + { + unsigned short + pixel; + + for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2) + { + p=PushShortPixel(endian,p,&pixel); + switch (x % 3) + { + default: + case 0: + { + SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + break; + } + case 1: + { + SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + break; + } + case 2: + { + SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + q+=GetPixelChannels(image); + break; + } + } + p=PushShortPixel(endian,p,&pixel); + switch ((x+1) % 3) + { + default: + case 0: + { + SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + break; + } + case 1: + { + SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + break; + } + case 2: + { + SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + q+=GetPixelChannels(image); + break; + } + } + p+=quantum_info->pad; + } + for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++) + { + p=PushShortPixel(endian,p,&pixel); + switch ((x+bit) % 3) + { + default: + case 0: + { + SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + break; + } + case 1: + { + SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + break; + } + case 2: + { + SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4), + range),q); + q+=GetPixelChannels(image); + break; + } + } + p+=quantum_info->pad; + } + if (bit != 0) + p++; + break; + } + if (quantum_info->quantum == 32U) + { + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); + SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); + SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); + SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); + q+=GetPixelChannels(image); + } + break; + } + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); + q+=GetPixelChannels(image); + } + break; + } + case 16: + { + unsigned short + pixel; + + if (quantum_info->format == FloatingPointQuantumFormat) + { + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushShortPixel(endian,p,&pixel); + SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange* + HalfToSinglePrecision(pixel)),q); + p=PushShortPixel(endian,p,&pixel); + SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange* + HalfToSinglePrecision(pixel)),q); + p=PushShortPixel(endian,p,&pixel); + SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange* + HalfToSinglePrecision(pixel)),q); + p+=quantum_info->pad; + q+=GetPixelChannels(image); + } + break; + } + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushShortPixel(endian,p,&pixel); + SetPixelRed(image,ScaleShortToQuantum(pixel),q); + p=PushShortPixel(endian,p,&pixel); + SetPixelGreen(image,ScaleShortToQuantum(pixel),q); + p=PushShortPixel(endian,p,&pixel); + SetPixelBlue(image,ScaleShortToQuantum(pixel),q); + p+=quantum_info->pad; + q+=GetPixelChannels(image); + } + break; + } + case 32: + { + unsigned int + pixel; + + if (quantum_info->format == FloatingPointQuantumFormat) + { + float + pixel; + + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushFloatPixel(&quantum_state,p,&pixel); + SetPixelRed(image,ClampToQuantum(pixel),q); + p=PushFloatPixel(&quantum_state,p,&pixel); + SetPixelGreen(image,ClampToQuantum(pixel),q); + p=PushFloatPixel(&quantum_state,p,&pixel); + SetPixelBlue(image,ClampToQuantum(pixel),q); + p+=quantum_info->pad; + q+=GetPixelChannels(image); + } + break; + } + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushLongPixel(endian,p,&pixel); + SetPixelRed(image,ScaleLongToQuantum(pixel),q); + p=PushLongPixel(endian,p,&pixel); + SetPixelGreen(image,ScaleLongToQuantum(pixel),q); + p=PushLongPixel(endian,p,&pixel); + SetPixelBlue(image,ScaleLongToQuantum(pixel),q); + p+=quantum_info->pad; + q+=GetPixelChannels(image); + } + break; + } + case 64: + { + if (quantum_info->format == FloatingPointQuantumFormat) + { + double + pixel; + + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushDoublePixel(&quantum_state,p,&pixel); + SetPixelRed(image,ClampToQuantum(pixel),q); + p=PushDoublePixel(&quantum_state,p,&pixel); + SetPixelGreen(image,ClampToQuantum(pixel),q); + p=PushDoublePixel(&quantum_state,p,&pixel); + SetPixelBlue(image,ClampToQuantum(pixel),q); + p+=quantum_info->pad; + q+=GetPixelChannels(image); + } + break; + } + } + default: + { + range=GetQuantumRange(image->depth); + for (x=0; x < (ssize_t) number_pixels; x++) + { + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); + p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); + SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); + q+=GetPixelChannels(image); + } + break; + } + } +} + MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view, const QuantumInfo *quantum_info,const QuantumType quantum_type, const unsigned char *pixels,ExceptionInfo *exception) @@ -2281,299 +2593,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view, case RGBQuantum: case CbYCrQuantum: { - switch (quantum_info->depth) - { - case 8: - { - unsigned char - pixel; - - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushCharPixel(p,&pixel); - SetPixelRed(image,ScaleCharToQuantum(pixel),q); - p=PushCharPixel(p,&pixel); - SetPixelGreen(image,ScaleCharToQuantum(pixel),q); - p=PushCharPixel(p,&pixel); - SetPixelBlue(image,ScaleCharToQuantum(pixel),q); - SetPixelAlpha(image,OpaqueAlpha,q); - p+=quantum_info->pad; - q+=channels; - } - break; - } - case 10: - { - range=GetQuantumRange(image->depth); - if (quantum_info->pack == MagickFalse) - { - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushLongPixel(endian,p,&pixel); - SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff, - range),q); - SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff, - range),q); - SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff, - range),q); - p+=quantum_info->pad; - q+=channels; - } - break; - } - if (quantum_info->quantum == 32U) - { - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); - SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); - SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); - SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); - q+=channels; - } - break; - } - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); - q+=channels; - } - break; - } - case 12: - { - range=GetQuantumRange(image->depth); - if (quantum_info->pack == MagickFalse) - { - unsigned short - pixel; - - for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2) - { - p=PushShortPixel(endian,p,&pixel); - switch (x % 3) - { - default: - case 0: - { - SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - break; - } - case 1: - { - SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - break; - } - case 2: - { - SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - q+=channels; - break; - } - } - p=PushShortPixel(endian,p,&pixel); - switch ((x+1) % 3) - { - default: - case 0: - { - SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - break; - } - case 1: - { - SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - break; - } - case 2: - { - SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - q+=channels; - break; - } - } - p+=quantum_info->pad; - } - for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++) - { - p=PushShortPixel(endian,p,&pixel); - switch ((x+bit) % 3) - { - default: - case 0: - { - SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - break; - } - case 1: - { - SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - break; - } - case 2: - { - SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) - (pixel >> 4),range),q); - q+=channels; - break; - } - } - p+=quantum_info->pad; - } - if (bit != 0) - p++; - break; - } - if (quantum_info->quantum == 32U) - { - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); - SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); - SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel); - SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); - q+=channels; - } - break; - } - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); - q+=channels; - } - break; - } - case 16: - { - unsigned short - pixel; - - if (quantum_info->format == FloatingPointQuantumFormat) - { - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushShortPixel(endian,p,&pixel); - SetPixelRed(image,ClampToQuantum((MagickRealType) - QuantumRange*HalfToSinglePrecision(pixel)),q); - p=PushShortPixel(endian,p,&pixel); - SetPixelGreen(image,ClampToQuantum((MagickRealType) - QuantumRange*HalfToSinglePrecision(pixel)),q); - p=PushShortPixel(endian,p,&pixel); - SetPixelBlue(image,ClampToQuantum((MagickRealType) - QuantumRange*HalfToSinglePrecision(pixel)),q); - p+=quantum_info->pad; - q+=channels; - } - break; - } - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushShortPixel(endian,p,&pixel); - SetPixelRed(image,ScaleShortToQuantum(pixel),q); - p=PushShortPixel(endian,p,&pixel); - SetPixelGreen(image,ScaleShortToQuantum(pixel),q); - p=PushShortPixel(endian,p,&pixel); - SetPixelBlue(image,ScaleShortToQuantum(pixel),q); - p+=quantum_info->pad; - q+=channels; - } - break; - } - case 32: - { - unsigned int - pixel; - - if (quantum_info->format == FloatingPointQuantumFormat) - { - float - pixel; - - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushFloatPixel(&quantum_state,p,&pixel); - SetPixelRed(image,ClampToQuantum(pixel),q); - p=PushFloatPixel(&quantum_state,p,&pixel); - SetPixelGreen(image,ClampToQuantum(pixel),q); - p=PushFloatPixel(&quantum_state,p,&pixel); - SetPixelBlue(image,ClampToQuantum(pixel),q); - p+=quantum_info->pad; - q+=channels; - } - break; - } - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushLongPixel(endian,p,&pixel); - SetPixelRed(image,ScaleLongToQuantum(pixel),q); - p=PushLongPixel(endian,p,&pixel); - SetPixelGreen(image,ScaleLongToQuantum(pixel),q); - p=PushLongPixel(endian,p,&pixel); - SetPixelBlue(image,ScaleLongToQuantum(pixel),q); - p+=quantum_info->pad; - q+=channels; - } - break; - } - case 64: - { - if (quantum_info->format == FloatingPointQuantumFormat) - { - double - pixel; - - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushDoublePixel(&quantum_state,p,&pixel); - SetPixelRed(image,ClampToQuantum(pixel),q); - p=PushDoublePixel(&quantum_state,p,&pixel); - SetPixelGreen(image,ClampToQuantum(pixel),q); - p=PushDoublePixel(&quantum_state,p,&pixel); - SetPixelBlue(image,ClampToQuantum(pixel),q); - p+=quantum_info->pad; - q+=channels; - } - break; - } - } - default: - { - range=GetQuantumRange(image->depth); - for (x=0; x < (ssize_t) number_pixels; x++) - { - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); - p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel); - SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); - q+=channels; - } - break; - } - } + ImportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q); break; } case RGBAQuantum: