return(pixels);
}
-static void ExportRGBQuantum(Image *image,const QuantumInfo *quantum_info,
+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;
+
+ 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(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=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++)
+ {
+ 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) GetPixelAlpha(image,p),q);
+ p+=GetPixelChannels(image);
+ 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+=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) GetPixelAlpha(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(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)
+ const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
{
EndianType
endian;
QuantumAny
range;
- register size_t
+ register ssize_t
x;
ssize_t
{
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);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(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=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
q=PopShortPixel(endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
q=PopShortPixel(endian,pixel,q);
pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
q=PopShortPixel(endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
q=PopLongPixel(endian,pixel,q);
pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
q=PopLongPixel(endian,pixel,q);
p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
}
-MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
- const QuantumInfo *quantum_info,const QuantumType quantum_type,
- unsigned char *pixels,ExceptionInfo *exception)
+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;
- 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)
- {
- 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++)
- {
- register ssize_t
- i;
-
- Sa=QuantumScale*GetPixelAlpha(image,q);
- for (i=0; i < (ssize_t) channels; i++)
- {
- PixelChannel
- channel;
-
- PixelTrait
- traits;
-
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
- if ((traits & UpdatePixelTrait) != 0)
- q[i]=ClampToQuantum(Sa*q[i]);
- }
- q+=channels;
- }
- }
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
- (quantum_type == BGROQuantum))
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- register Quantum
- *restrict q;
+ register unsigned char
+ pixel;
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=channels;
+ 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;
}
- if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
+ case 10:
{
- Quantum
- quantum;
-
- register Quantum
- *restrict q;
+ register unsigned int
+ pixel;
- 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+=channels;
- }
- }
- 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:
- {
- if (image->storage_class != PseudoClass)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 1:
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- register unsigned char
- pixel;
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
- for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ pixel=0;
+ 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++;
- }
- if ((number_pixels % 8) != 0)
+ for (i=0; i < 4; i++)
{
- *q='\0';
- for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+ switch (i)
{
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << (unsigned char) bit);
- p+=channels;
+ 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;
}
- q++;
- }
- break;
- }
- case 4:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0xf) << 0);
- p+=channels;
- q++;
- }
- if ((number_pixels % 2) != 0)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- p+=channels;
- q++;
+ 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++;
}
- break;
- }
- case 8:
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ if (quantum_info->quantum == 32UL)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
- GetPixelIndex(image,p)),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);
- 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;
}
- case 32:
+ 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)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelIndex(image,p),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);
- p+=channels;
+ 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+=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)
- GetPixelIndex(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(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=PopQuantumPixel(&quantum_state,quantum_info->depth,
- GetPixelIndex(image,p),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 IndexAlphaQuantum:
+ 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
+ double
pixel;
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0x01) << 7);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 6);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 5);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 4);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 3);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 2);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 1);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 0);
- p+=channels;
- q++;
+ 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;
}
- 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;
+ }
+ 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;
+ }
+ }
+}
- 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;
+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;
+
+ QuantumAny
+ range;
+
+ 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++)
{
- q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(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++)
- {
- 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;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
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=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)
- 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=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
-
- 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:
+ }
+ 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;
+ }
+ }
+}
+
+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,
- GetPixelIndex(image,p),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(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 BGRQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
- p+=channels;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 10:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(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) number_pixels; x++)
- {
- pixel=(unsigned int) (
- ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
- ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
- ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 12:
- {
- 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(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;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ ssize_t
+ n;
+
+ endian=quantum_state.endian;
+ n=0;
+ quantum=0;
+ switch (quantum_info->depth)
+ {
+ case 10:
+ {
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
+ {
+ for (i=0; i < 4; i++)
{
- 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;
- }
+ quantum=GetPixelRed(image,p);
+ 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;
- }
+ quantum=GetPixelGreen(image,p);
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
- {
- switch ((x+bit) % 3)
+ 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;
- }
+ quantum=GetPixelBlue(image,p);
+ 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;
+ cbcr[i]=(Quantum) quantum;
+ n++;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- 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 16:
- {
- register unsigned short
- pixel;
+ break;
+ }
+ default:
+ {
+ QuantumAny
+ range;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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=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;
- }
+ quantum=GetPixelRed(image,p);
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 1:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- 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;
- }
+ quantum=GetPixelGreen(image,p);
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)
+ case 2:
{
- 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;
- }
+ quantum=GetPixelBlue(image,p);
break;
}
- }
- default:
- {
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(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;
+ 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;
}
- case BGRAQuantum:
- case BGROQuantum:
- {
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(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+=quantum_info->pad;
- }
- break;
- }
- case 10:
- {
- register unsigned int
- pixel;
+ }
+}
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
+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;
- size_t
- quantum;
+ register ssize_t
+ x;
- ssize_t
- n;
+ 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;
- n=0;
- quantum=0;
- pixel=0;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- for (i=0; i < 4; i++)
- {
- switch (i)
- {
- case 0: quantum=GetPixelRed(image,p); break;
- case 1: quantum=GetPixelGreen(image,p); break;
- case 2: quantum=GetPixelBlue(image,p); break;
- case 3: quantum=GetPixelAlpha(image,p); break;
- }
- switch (n % 3)
- {
- case 0:
- {
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 22);
- break;
- }
- case 1:
- {
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 12);
- break;
- }
- case 2:
- {
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 2);
- q=PopLongPixel(endian,pixel,q);
- pixel=0;
- break;
- }
- }
- n++;
- }
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(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+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- 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);
+ 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);
- 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));
+ 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(GetPixelRed(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(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);
+ 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);
- 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(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=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 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- 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);
- pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(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)
{
- 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;
+ 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;
}
+ }
+ default:
+ {
+ QuantumAny
+ range;
+
+ 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;
}
- case GrayQuantum:
+ }
+}
+
+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)
{
- switch (quantum_info->depth)
- {
- case 1:
- {
- register Quantum
- threshold;
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
- register unsigned char
- black,
- white;
+ 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;
- 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++;
- }
+ 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+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
break;
}
- case 4:
- {
- register unsigned char
- 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;
- for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ 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++;
+ 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;
}
- 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(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 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ double
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) 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 10:
- {
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- register unsigned int
- pixel;
+ }
+ default:
+ {
+ QuantumAny
+ range;
- for (x=0; x < (ssize_t) (number_pixels-2); x+=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)
- {
- 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);
- }
- 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 12:
- {
- register unsigned short
- pixel;
+ 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;
+ }
+ }
+}
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- 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;
- }
- 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;
+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;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
+ QuantumAny
+ range;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- float
- pixel;
+ register ssize_t
+ x;
- pixel=(float) GetPixelIntensity(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);
- 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;
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register Quantum
+ threshold;
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ register unsigned char
+ black,
+ white;
+
+ ssize_t
+ bit;
+
+ black=0x00;
+ white=0x01;
+ if (quantum_info->min_is_white != MagickFalse)
+ {
+ black=0x01;
+ white=0x00;
}
- default:
+ 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)
{
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
+ *q='\0';
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- p+=channels;
- q+=quantum_info->pad;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << bit;
+ p+=GetPixelChannels(image);
}
- break;
+ q++;
}
- }
break;
}
- case GrayAlphaQuantum:
+ case 4:
{
- switch (quantum_info->depth)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
{
- case 1:
+ 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)
{
- register Quantum
- threshold;
-
- register unsigned char
- black,
- pixel,
- white;
-
- 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;
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ q++;
}
- case 4:
- {
- register unsigned char
- pixel;
+ break;
+ }
+ case 8:
+ {
+ register unsigned char
+ pixel;
- for (x=0; x < (ssize_t) number_pixels ; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
- *q|=pixel & 0xf;
- p+=channels;
- q++;
- }
- break;
- }
- case 8:
+ 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 char
+ register unsigned int
pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ 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+=3*GetPixelChannels(image);
q+=quantum_info->pad;
}
+ if (x < (ssize_t) number_pixels)
+ {
+ 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;
}
- case 16:
- {
- register unsigned short
- pixel;
+ 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;
- 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);
+ if (quantum_info->pack == MagickFalse)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- float
- pixel;
-
- pixel=(float) GetPixelIntensity(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- pixel=(float) (GetPixelAlpha(image,p));
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelIntensity(image,p));
+ q=PopShortPixel(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++)
- {
- double
- pixel;
-
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=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)
{
- 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;
+
+ pixel=(float) GetPixelIntensity(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);
+ 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
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(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 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(GetPixelIntensity(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);
- 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);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
+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;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelRed(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
+ 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)
- GetPixelRed(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(GetPixelRed(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 GreenQuantum:
- case MagentaQuantum:
+ 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;
+ 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);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(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);
+ 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++)
- {
- 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);
+ pixel=(float) (GetPixelAlpha(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);
+ 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)
{
- 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);
+ pixel=(double) (GetPixelAlpha(image,p));
+ q=PopDoublePixel(&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)
- GetPixelGreen(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ }
+ 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;
+ }
+ }
+}
+
+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;
+
+ 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(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(GetPixelGreen(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 BlueQuantum:
- case YellowQuantum:
+ 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(GetPixelBlue(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*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ q=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)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
+ }
+ 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=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
+ 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)
- GetPixelBlue(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(GetPixelBlue(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 AlphaQuantum:
+ case 32:
{
- 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=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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 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) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ }
+ 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;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- float
- pixel;
+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;
- 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;
+ register ssize_t
+ x;
- pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ 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)
{
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
+ *q='\0';
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
- q+=quantum_info->pad;
+ 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);
}
- break;
+ q++;
}
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels ; x++)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0xf) << 4);
+ pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
+ *q|=((pixel & 0xf) << 0);
+ p+=GetPixelChannels(image);
+ q++;
}
break;
}
- case OpacityQuantum:
+ case 8:
{
- switch (quantum_info->depth)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
- {
- register unsigned char
- pixel;
+ 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=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(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++)
+ {
+ 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++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ float
+ pixel;
+
+ 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 32:
+ 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)
{
- 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;
+ 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;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelAlpha(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ }
+ 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;
+ }
+ }
+}
+
+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:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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*GetPixelOpacity(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(GetPixelOpacity(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case BlackQuantum:
+ case 32:
{
- if (image->colorspace != CMYKColorspace)
+ register unsigned int
+ pixel;
+
+ 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) GetPixelOpacity(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:
+ 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 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) 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*
- GetPixelBlack(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(GetPixelBlack(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(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)
- 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;
+ 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)
- GetPixelBlack(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((Quantum) GetPixelBlack(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 RGBQuantum:
- case CbYCrQuantum:
+ }
+}
+
+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:
{
- ExportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q);
+ 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 RGBAQuantum:
- case RGBOQuantum:
- case CbYCrAQuantum:
+ case 10:
{
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ 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;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
-
- size_t
- quantum;
-
- ssize_t
- n;
-
- n=0;
- quantum=0;
- pixel=0;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- for (i=0; i < 4; i++)
- {
- switch (i)
- {
- case 0: quantum=GetPixelRed(image,p); break;
- case 1: quantum=GetPixelGreen(image,p); break;
- case 2: quantum=GetPixelBlue(image,p); break;
- case 3: quantum=GetPixelAlpha(image,p); break;
- }
- switch (n % 3)
- {
- case 0:
- {
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 22);
- break;
- }
- case 1:
- {
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 12);
- break;
- }
- case 2:
- {
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 2);
- q=PopLongPixel(endian,pixel,q);
- pixel=0;
- break;
- }
- }
- n++;
- }
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ 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);
+ q=PopQuantumLongPixel(&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=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);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned int
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ switch (x % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- pixel=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+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- 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:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
+ }
+ case 1:
{
- 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;
+ 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=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;
+ 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)
{
- double
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ 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:
{
- 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;
+ 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)
{
- 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=(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 CMYKQuantum:
+ 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);
- 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);
- 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));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*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);
+ 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);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlack(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);
- pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- 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:
+ 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(GetPixelBlack(image,p),range),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;
}
+ 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 CMYKAQuantum:
- case CMYKOQuantum:
+ case 64:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(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=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 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);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(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(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 ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ pixel=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (i)
+ {
+ case 0: quantum=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++;
}
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
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=(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 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=ScaleQuantumToShort(GetPixelBlue(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(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(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 RGBQuantum:
+ 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 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:
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) ||
for (x=0; x < (ssize_t) number_pixels; x++)
{
SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
}
return(extent);
%
*/
-static inline Quantum PushColormapIndex(Image *image,
- const size_t index,MagickBooleanType *range_exception)
+static inline Quantum PushColormapIndex(const Image *image,const size_t index,
+ MagickBooleanType *range_exception)
{
if (index < image->colors)
return((Quantum) index);
return(pixels);
}
-static void ImportRGBQuantum(Image *image,const QuantumInfo *quantum_info,
+static void ImportAlphaQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ 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);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ 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);
+ SetPixelAlpha(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);
+ SetPixelAlpha(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);
+ SetPixelAlpha(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);
+ SetPixelAlpha(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);
+ SetPixelAlpha(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);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportBGRQuantum(const Image *image,const QuantumInfo *quantum_info,
QuantumState quantum_state,const MagickSizeType number_pixels,
- const unsigned char *restrict p,Quantum *restrict q)
+ const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
{
EndianType
endian;
QuantumAny
range;
- register size_t
+ register ssize_t
x;
ssize_t
unsigned int
pixel;
- assert(image != (Image *) NULL);
endian=quantum_state.endian;
switch (quantum_info->depth)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
p=PushCharPixel(p,&pixel);
SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
SetPixelAlpha(image,OpaqueAlpha,q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ SetPixelBlue(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);
+ SetPixelRed(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);
+ SetPixelBlue(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);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ SetPixelBlue(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);
+ SetPixelRed(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);
+ SetPixelBlue(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);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
p=PushShortPixel(endian,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
p=PushLongPixel(endian,p,&pixel);
SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ SetPixelBlue(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);
+ SetPixelRed(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)
+static void ImportBGRAQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
{
EndianType
endian;
- MagickSizeType
- number_pixels;
-
QuantumAny
range;
- QuantumState
- quantum_state;
-
- register const unsigned char
- *restrict p;
-
register ssize_t
x;
- register Quantum
- *restrict q;
-
- size_t
- channels,
- extent;
-
- ssize_t
- bit;
-
unsigned int
pixel;
- 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 == (const unsigned char *) NULL)
- pixels=GetQuantumPixels(quantum_info);
- x=0;
- p=pixels;
- if (image_view == (CacheView *) NULL)
- {
- number_pixels=GetImageExtent(image);
- q=GetAuthenticPixelQueue(image);
- channels=GetPixelChannels(image);
- }
- else
- {
- number_pixels=GetCacheViewExtent(image_view);
- q=GetCacheViewAuthenticPixelQueue(image_view);
- channels=GetPixelChannels(image);
- }
- InitializeQuantumState(quantum_info,image->endian,&quantum_state);
- extent=GetQuantumExtent(image,quantum_info,quantum_type);
endian=quantum_state.endian;
- switch (quantum_type)
+ switch (quantum_info->depth)
{
- case IndexQuantum:
+ case 8:
{
- MagickBooleanType
- range_exception;
+ unsigned char
+ pixel;
- if (image->storage_class != PseudoClass)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
- return(extent);
- }
- range_exception=MagickFalse;
- switch (quantum_info->depth)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 1:
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
{
- register unsigned char
- pixel;
+ register ssize_t
+ i;
- for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- for (bit=0; bit < 8; bit++)
+ for (i=0; i < 4; i++)
{
- if (quantum_info->min_is_white == MagickFalse)
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
- 0x00 : 0x01);
- else
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
- 0x00 : 0x01);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- q+=channels;
+ switch (n % 3)
+ {
+ case 0:
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 22) & 0x3ff) << 6)));
+ break;
+ }
+ case 1:
+ {
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 12) & 0x3ff) << 6)));
+ break;
+ }
+ case 2:
+ {
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 2) & 0x3ff) << 6)));
+ break;
+ }
+ }
+ switch (i)
+ {
+ case 0: SetPixelRed(image,(Quantum) quantum,q); break;
+ case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
+ case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
+ case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
+ }
+ n++;
}
- p++;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
- {
- if (quantum_info->min_is_white == MagickFalse)
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
- 0x00 : 0x01);
- else
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
- 0x00 : 0x01);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- q+=channels;
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 4:
- {
- register unsigned char
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
- for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) ((*p >> 4) & 0xf);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- q+=channels;
- pixel=(unsigned char) ((*p) & 0xf);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p++;
- q+=channels;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
- {
- pixel=(unsigned char) ((*p++ >> 4) & 0xf);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- q+=channels;
+ 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=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 8:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
+ 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=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
- (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
+ 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=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(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);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportBlackQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,
- ClampToQuantum(pixel),&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ QuantumAny
+ range;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,
- ClampToQuantum(pixel),&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ 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);
+ SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
- if (range_exception != MagickFalse)
- (void) ThrowMagickException(exception,GetMagickModule(),
- CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
break;
}
- case IndexAlphaQuantum:
+ case 32:
{
- MagickBooleanType
- range_exception;
-
- if (image->storage_class != PseudoClass)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),
- ImageError,"ColormappedImageRequired","`%s'",image->filename);
- return(extent);
- }
- range_exception=MagickFalse;
- switch (quantum_info->depth)
- {
- case 1:
- {
- register unsigned char
- pixel;
-
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
- {
- for (bit=0; bit < 8; bit+=2)
- {
- if (quantum_info->min_is_white == MagickFalse)
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
- 0x00 : 0x01);
- else
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
- 0x00 : 0x01);
- SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
- SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
- (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
- SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
- q+=channels;
- }
- }
- if ((number_pixels % 4) != 0)
- for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
- {
- if (quantum_info->min_is_white == MagickFalse)
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
- 0x00 : 0x01);
- else
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
- 0x00 : 0x01);
- SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
- SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
- SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
- (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
- q+=channels;
- }
- break;
- }
- case 4:
- {
- register unsigned char
- pixel;
+ unsigned int
+ pixel;
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned char) ((*p >> 4) & 0xf);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- pixel=(unsigned char) ((*p) & 0xf);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- p++;
- q+=channels;
- }
- break;
- }
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
- (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(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);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,
- ClampToQuantum(pixel),&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+static void ImportBlueQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ 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);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,
- ClampToQuantum(pixel),&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
+ float
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
- if (range_exception != MagickFalse)
- (void) ThrowMagickException(exception,GetMagickModule(),
- CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
break;
}
- case BGRQuantum:
+ case 64:
{
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 10:
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportCbYCrYQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 10:
+ {
+ Quantum
+ cbcr[4];
+
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
{
- 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);
- SetPixelBlue(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);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(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);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- case 12:
- {
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
+ for (i=0; i < 4; i++)
{
- unsigned short
- pixel;
-
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ switch (n % 3)
{
- p=PushShortPixel(endian,p,&pixel);
- switch (x % 3)
+ case 0:
{
- 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=PushLongPixel(endian,p,&pixel);
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 22) & 0x3ff) << 6)));
+ break;
}
- p=PushShortPixel(endian,p,&pixel);
- switch ((x+1) % 3)
+ case 1:
{
- 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;
- }
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 12) & 0x3ff) << 6)));
+ 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)
+ case 2:
{
- 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;
- }
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 2) & 0x3ff) << 6)));
+ 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);
- SetPixelBlue(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);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
}
- break;
+ cbcr[i]=(Quantum) (quantum);
+ n++;
}
+ p+=quantum_info->pad;
+ SetPixelRed(image,cbcr[1],q);
+ SetPixelGreen(image,cbcr[0],q);
+ SetPixelBlue(image,cbcr[2],q);
+ q+=GetPixelChannels(image);
+ SetPixelRed(image,cbcr[3],q);
+ SetPixelGreen(image,cbcr[0],q);
+ SetPixelBlue(image,cbcr[2],q);
+ 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);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportCMYKQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ 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);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(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);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ 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=PushShortPixel(endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ 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=PushShortPixel(endian,p,&pixel);
+ SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ float
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);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ 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=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ 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=PushLongPixel(endian,p,&pixel);
+ SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned int
+ double
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);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ 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=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ }
+ 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);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- 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:
+static void ImportCMYKAQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ 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);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(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);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ 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=PushShortPixel(endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(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=PushShortPixel(endian,p,&pixel);
+ SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case BGRAQuantum:
- case BGROQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ 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=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 10:
- {
- pixel=0;
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
-
- size_t
- quantum;
-
- ssize_t
- n;
-
- n=0;
- quantum=0;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- p=PushLongPixel(endian,p,&pixel);
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 22) & 0x3ff) << 6)));
- break;
- }
- case 1:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 12) & 0x3ff) << 6)));
- break;
- }
- case 2:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 2) & 0x3ff) << 6)));
- break;
- }
- }
- switch (i)
- {
- case 0: SetPixelRed(image,(Quantum) quantum,q); break;
- case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
- case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
- case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
- }
- n++;
- }
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ 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=PushLongPixel(endian,p,&pixel);
+ SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
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=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(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);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ 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=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ 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);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportGrayQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
- 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=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(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);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ QuantumAny
+ range;
- 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=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register Quantum
+ black,
+ white;
+
+ black=0;
+ white=(Quantum) QuantumRange;
+ if (quantum_info->min_is_white != MagickFalse)
+ {
+ black=(Quantum) QuantumRange;
+ white=0;
}
- default:
+ for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
+ {
+ for (bit=0; bit < 8; bit++)
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(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);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
+ SetPixelGray(image,((*p) & (1 << (7-bit))) == 0 ? black : white,q);
+ q+=GetPixelChannels(image);
}
+ p++;
+ }
+ for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
+ {
+ SetPixelGray(image,((*p) & (0x01 << (7-bit))) == 0 ? black : white,q);
+ q+=GetPixelChannels(image);
}
+ if (bit != 0)
+ p++;
break;
}
- case GrayQuantum:
+ case 4:
{
- switch (quantum_info->depth)
- {
- case 1:
- {
- register Quantum
- black,
- white;
+ register unsigned char
+ pixel;
- black=0;
- white=(Quantum) QuantumRange;
- if (quantum_info->min_is_white != MagickFalse)
- {
- black=(Quantum) QuantumRange;
- white=0;
- }
- for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
- {
- for (bit=0; bit < 8; bit++)
- {
- SetPixelGray(image,((*p) & (1 << (7-bit))) == 0 ? black :
- white,q);
- q+=channels;
- }
- p++;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
- {
- SetPixelGray(image,((*p) & (0x01 << (7-bit))) == 0 ? black :
- white,q);
- q+=channels;
- }
- if (bit != 0)
- p++;
- break;
- }
- case 4:
- {
- register unsigned char
- pixel;
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
+ {
+ pixel=(unsigned char) ((*p >> 4) & 0xf);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ pixel=(unsigned char) ((*p) & 0xf);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
+ {
+ pixel=(unsigned char) (*p++ >> 4);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 8:
+ {
+ unsigned char
+ pixel;
- range=GetQuantumRange(image->depth);
- for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
- {
- pixel=(unsigned char) ((*p >> 4) & 0xf);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- pixel=(unsigned char) ((*p) & 0xf);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- p++;
- q+=channels;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
- {
- pixel=(unsigned char) (*p++ >> 4);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- case 8:
+ if (quantum_info->min_is_white != MagickFalse)
{
- unsigned char
- pixel;
-
- if (quantum_info->min_is_white != MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushCharPixel(p,&pixel);
- SetPixelGray(image,ScaleCharToQuantum(pixel),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
SetPixelGray(image,ScaleCharToQuantum(pixel),q);
SetPixelAlpha(image,OpaqueAlpha,q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 10:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelGray(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)
{
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
+ if (image->endian != LSBEndian)
{
- if (image->endian != LSBEndian)
- {
- for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
- range),q);
- q+=channels;
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
- range),q);
- q+=channels;
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
- range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- p=PushLongPixel(endian,p,&pixel);
- if (x++ < (ssize_t) (number_pixels-1))
- {
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
- range),q);
- q+=channels;
- }
- if (x++ < (ssize_t) number_pixels)
- {
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) &
- 0x3ff,range),q);
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
p=PushLongPixel(endian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
range),q);
- q+=channels;
+ q+=GetPixelChannels(image);
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
range),q);
- q+=channels;
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+ q+=GetPixelChannels(image);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
range),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
p=PushLongPixel(endian,p,&pixel);
if (x++ < (ssize_t) (number_pixels-1))
{
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
range),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
if (x++ < (ssize_t) number_pixels)
{
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
range),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
+ q);
+ q+=GetPixelChannels(image);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
+ q);
+ q+=GetPixelChannels(image);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),
+ q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
- break;
- }
- case 12:
- {
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
+ p=PushLongPixel(endian,p,&pixel);
+ if (x++ < (ssize_t) (number_pixels-1))
{
- unsigned short
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
- range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
- range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- if (bit != 0)
- p++;
- break;
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
+ q);
+ q+=GetPixelChannels(image);
+ }
+ if (x++ < (ssize_t) number_pixels)
+ {
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
+ q);
+ q+=GetPixelChannels(image);
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 12:
+ {
+ range=GetQuantumRange(image->depth);
+ if (quantum_info->pack == MagickFalse)
{
unsigned short
pixel;
- if (quantum_info->min_is_white != MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ScaleShortToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
{
p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ScaleShortToQuantum(pixel),q);
+ SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
p+=quantum_info->pad;
- q+=channels;
+ 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);
- SetPixelGray(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGray(image,ScaleLongToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
+ if (bit != 0)
+ p++;
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGray(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ if (quantum_info->min_is_white != MagickFalse)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGray(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- }
- break;
- }
- case GrayAlphaQuantum:
- {
- switch (quantum_info->depth)
- {
- case 1:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- for (bit=0; bit < 8; bit+=2)
- {
- pixel=(unsigned char)
- (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
- SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
- SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
- (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
- q+=channels;
- }
- p++;
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
- if ((number_pixels % 4) != 0)
- for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
- {
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 :
- 0x01);
- SetPixelGray(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
- SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
- (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
- q+=channels;
- }
- if (bit != 0)
- p++;
break;
}
- case 4:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGray(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ float
pixel;
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) ((*p >> 4) & 0xf);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- pixel=(unsigned char) ((*p) & 0xf);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- p++;
- q+=channels;
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 8:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelGray(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelGray(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 10:
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportGrayAlphaQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ 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)
+ {
+ for (bit=0; bit < 8; bit+=2)
+ {
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
+ SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
+ TransparentAlpha : OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
+ }
+ p++;
+ }
+ if ((number_pixels % 4) != 0)
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
{
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelGray(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
+ SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
+ TransparentAlpha : OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
}
- case 12:
+ if (bit != 0)
+ p++;
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned char) ((*p >> 4) & 0xf);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ pixel=(unsigned char) ((*p) & 0xf);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelGray(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 12:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGray(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ float
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(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);
- SetPixelGray(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelGray(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned int
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGray(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(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);
- SetPixelGray(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGray(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+static void ImportGreenQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ 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);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case RedQuantum:
- case CyanQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
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+=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=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportIndexQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(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+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ MagickBooleanType
+ range_exception;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ if (image->storage_class != PseudoClass)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return;
+ }
+ endian=quantum_state.endian;
+ range_exception=MagickFalse;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
+ {
+ for (bit=0; bit < 8; bit++)
+ {
+ if (quantum_info->min_is_white == MagickFalse)
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
+ 0x00 : 0x01);
+ else
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
+ 0x00 : 0x01);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
+ q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ q+=GetPixelChannels(image);
+ }
+ p++;
+ }
+ for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
+ {
+ if (quantum_info->min_is_white == MagickFalse)
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
+ else
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
+ {
+ pixel=(unsigned char) ((*p >> 4) & 0xf);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ q+=GetPixelChannels(image);
+ pixel=(unsigned char) ((*p) & 0xf);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
+ {
+ pixel=(unsigned char) ((*p++ >> 4) & 0xf);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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=PushShortPixel(endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
+ (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case GreenQuantum:
- case MagentaQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(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);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+ if (range_exception != MagickFalse)
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ "InvalidColormapIndex","`%s'",image->filename);
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportIndexAlphaQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(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);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
+ MagickBooleanType
+ range_exception;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ if (image->storage_class != PseudoClass)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return;
+ }
+ endian=quantum_state.endian;
+ range_exception=MagickFalse;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ {
+ for (bit=0; bit < 8; bit+=2)
+ {
+ if (quantum_info->min_is_white == MagickFalse)
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
+ else
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
+ SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
+ TransparentAlpha : OpaqueAlpha,q);
+ SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
+ q+=GetPixelChannels(image);
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ }
+ if ((number_pixels % 4) != 0)
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
+ {
+ if (quantum_info->min_is_white == MagickFalse)
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
+ else
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
+ SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
+ SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
+ TransparentAlpha : OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned char) ((*p >> 4) & 0xf);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ pixel=(unsigned char) ((*p) & 0xf);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 8:
+ {
+ unsigned char
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
+ (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType)
+ QuantumRange*HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case BlueQuantum:
- case YellowQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,
+ ClampToQuantum(pixel),&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- 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);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+ if (range_exception != MagickFalse)
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ "InvalidColormapIndex","`%s'",image->filename);
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportOpacityQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- 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);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ QuantumAny
+ range;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ 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);
+ SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case AlphaQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(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);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+static void ImportRedQuantum(const Image *image,const QuantumInfo *quantum_info,
+ QuantumState quantum_state,const MagickSizeType number_pixels,
+ const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+ QuantumAny
+ range;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(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);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ 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+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case BlackQuantum:
+ case 32:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
- {
- unsigned char
- pixel;
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushCharPixel(p,&pixel);
- SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 16:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ float
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(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);
- SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned int
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlack(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);
- SetPixelBlack(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);
- SetPixelBlack(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);
- SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ 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+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case RGBQuantum:
- case CbYCrQuantum:
+ }
+}
+
+static void ImportRGBQuantum(const Image *image,const QuantumInfo *quantum_info,
+ QuantumState quantum_state,const MagickSizeType number_pixels,
+ const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- ImportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q);
+ 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 RGBAQuantum:
- case RGBOQuantum:
- case CbYCrAQuantum:
+ case 10:
{
- switch (quantum_info->depth)
- {
- case 8:
+ range=GetQuantumRange(image->depth);
+ if (quantum_info->pack == MagickFalse)
{
- 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);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ 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;
+ q+=GetPixelChannels(image);
}
break;
}
- case 10:
+ if (quantum_info->quantum == 32U)
{
- pixel=0;
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
-
- size_t
- quantum;
-
- ssize_t
- n;
-
- n=0;
- quantum=0;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- p=PushLongPixel(endian,p,&pixel);
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 22) & 0x3ff) << 6)));
- break;
- }
- case 1:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 12) & 0x3ff) << 6)));
- break;
- }
- case 2:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 2) & 0x3ff) << 6)));
- break;
- }
- }
- switch (i)
- {
- case 0: SetPixelRed(image,(Quantum) quantum,q); break;
- case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
- case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
- case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
- }
- n++;
- }
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- q+=channels;
+ 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;
}
- case 16:
+ 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;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ switch (x % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- 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=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
+ 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;
}
- 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=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 32:
- {
- unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ switch ((x+1) % 3)
{
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- 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=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
}
- 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=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ 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;
- q+=channels;
}
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ switch ((x+bit) % 3)
{
- double
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- 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=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
+ 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;
}
- break;
}
+ p+=quantum_info->pad;
+ }
+ if (bit != 0)
+ p++;
+ break;
}
- default:
+ if (quantum_info->quantum == 32U)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ 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 CMYKQuantum:
+ case 16:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
- {
- unsigned char
- pixel;
+ unsigned short
+ 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);
- p=PushCharPixel(p,&pixel);
- SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 16:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(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);
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ 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)
{
- unsigned int
+ float
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=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlack(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=PushLongPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ 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;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
+ 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)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ 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=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlack(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);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ 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;
}
- case CMYKAQuantum:
- case CMYKOQuantum:
+ }
+}
+
+static void ImportRGBAQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
+ 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);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
{
- unsigned char
- pixel;
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
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);
- p=PushCharPixel(p,&pixel);
- SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ for (i=0; i < 4; i++)
+ {
+ switch (n % 3)
+ {
+ case 0:
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 22) & 0x3ff) << 6)));
+ break;
+ }
+ case 1:
+ {
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 12) & 0x3ff) << 6)));
+ break;
+ }
+ case 2:
+ {
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 2) & 0x3ff) << 6)));
+ break;
+ }
+ }
+ switch (i)
+ {
+ case 0: SetPixelRed(image,(Quantum) quantum,q); break;
+ case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
+ case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
+ case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
+ }
+ n++;
+ }
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
- {
- unsigned short
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ 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=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
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);
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ 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=PushShortPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned int
+ float
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=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlack(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(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=PushLongPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ 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=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
+ 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=PushLongPixel(endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ 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++)
- {
- 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=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlack(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- 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);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ 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=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- }
- break;
}
- case CbYCrYQuantum:
+ default:
{
- switch (quantum_info->depth)
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 10:
- {
- Quantum
- cbcr[4];
+ 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);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- pixel=0;
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
+MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
+ const QuantumInfo *quantum_info,const QuantumType quantum_type,
+ const unsigned char *pixels,ExceptionInfo *exception)
+{
+ MagickSizeType
+ number_pixels;
+
+ QuantumState
+ quantum_state;
- size_t
- quantum;
+ register const unsigned char
+ *restrict p;
- ssize_t
- n;
+ register ssize_t
+ x;
- n=0;
- quantum=0;
- for (x=0; x < (ssize_t) number_pixels; x+=2)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- p=PushLongPixel(endian,p,&pixel);
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 22) & 0x3ff) << 6)));
- break;
- }
- case 1:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 12) & 0x3ff) << 6)));
- break;
- }
- case 2:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 2) & 0x3ff) << 6)));
- break;
- }
- }
- cbcr[i]=(Quantum) (quantum);
- n++;
- }
- p+=quantum_info->pad;
- SetPixelRed(image,cbcr[1],q);
- SetPixelGreen(image,cbcr[0],q);
- SetPixelBlue(image,cbcr[2],q);
- q+=channels;
- SetPixelRed(image,cbcr[3],q);
- SetPixelGreen(image,cbcr[0],q);
- SetPixelBlue(image,cbcr[2],q);
- 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);
- q+=channels;
- }
- break;
- }
- }
+ register Quantum
+ *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 == (const unsigned char *) NULL)
+ pixels=GetQuantumPixels(quantum_info);
+ x=0;
+ p=pixels;
+ if (image_view == (CacheView *) NULL)
+ {
+ number_pixels=GetImageExtent(image);
+ q=GetAuthenticPixelQueue(image);
+ }
+ else
+ {
+ number_pixels=GetCacheViewExtent(image_view);
+ q=GetCacheViewAuthenticPixelQueue(image_view);
+ }
+ InitializeQuantumState(quantum_info,image->endian,&quantum_state);
+ extent=GetQuantumExtent(image,quantum_info,quantum_type);
+ switch (quantum_type)
+ {
+ case AlphaQuantum:
+ {
+ ImportAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case BGRQuantum:
+ {
+ ImportBGRQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case BGRAQuantum:
+ case BGROQuantum:
+ {
+ ImportBGRAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case BlackQuantum:
+ {
+ ImportBlackQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ ImportBlueQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case CMYKQuantum:
+ {
+ ImportCMYKQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case CMYKAQuantum:
+ case CMYKOQuantum:
+ {
+ ImportCMYKAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case CbYCrYQuantum:
+ {
+ ImportCbYCrYQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case GrayQuantum:
+ {
+ ImportGrayQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case GrayAlphaQuantum:
+ {
+ ImportGrayAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ ImportGreenQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case IndexQuantum:
+ {
+ ImportIndexQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case IndexAlphaQuantum:
+ {
+ ImportIndexAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,
+ q,exception);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ ImportOpacityQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ ImportRedQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case RGBQuantum:
+ case CbYCrQuantum:
+ {
+ ImportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case RGBAQuantum:
+ case RGBOQuantum:
+ case CbYCrAQuantum:
+ {
+ ImportRGBAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
break;
}
default:
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))
for (x=0; x < (ssize_t) number_pixels; x++)
{
SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
}
if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
Sa=QuantumScale*GetPixelAlpha(image,q);
gamma=1.0/(fabs(Sa) <= MagickEpsilon ? 1.0 : Sa);
- for (i=0; i < (ssize_t) channels; i++)
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel
channel;
if ((traits & UpdatePixelTrait) != 0)
q[i]=ClampToQuantum(gamma*q[i]);
}
- q+=channels;
+ q+=GetPixelChannels(image);
}
}
return(extent);
projects / imagemagick / commitdiff