return(pixels);
}
-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)
+MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
+ const QuantumInfo *quantum_info,const QuantumType quantum_type,
+ unsigned char *pixels,ExceptionInfo *exception)
{
EndianType
endian;
+ MagickRealType
+ alpha;
+
+ MagickSizeType
+ number_pixels;
+
QuantumAny
range;
+ QuantumState
+ quantum_state;
+
+ register const Quantum
+ *restrict p;
+
register ssize_t
x;
- endian=quantum_state.endian;
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned char
+ *restrict q;
- 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;
+ 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);
}
- case 16:
+ else
{
- register unsigned short
- pixel;
+ number_pixels=GetCacheViewExtent(image_view);
+ p=GetCacheViewVirtualPixelQueue(image_view);
+ channels=GetPixelChannels(image);
+ }
+ if (quantum_info->alpha_type == AssociatedQuantumAlpha)
+ {
+ register Quantum
+ *restrict q;
- 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++)
+ /*
+ Associate alpha.
+ */
+ q=GetAuthenticPixelQueue(image);
+ if (image_view != (CacheView *) NULL)
+ q=GetCacheViewAuthenticPixelQueue(image_view);
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
+ alpha=QuantumScale*GetPixelAlpha(image,q);
+ SetPixelRed(image,ClampToQuantum(alpha*GetPixelRed(image,q)),q);
+ SetPixelGreen(image,ClampToQuantum(alpha*GetPixelGreen(image,q)),q);
+ SetPixelBlue(image,ClampToQuantum(alpha*GetPixelBlue(image,q)),q);
+ q++;
}
- break;
}
- case 32:
+ if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+ (quantum_type == BGROQuantum))
{
- register unsigned int
- pixel;
+ register Quantum
+ *restrict q;
- 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;
- }
+ q=GetAuthenticPixelQueue(image);
+ if (image_view != (CacheView *) NULL)
+ q=GetCacheViewAuthenticPixelQueue(image_view);
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;
+ SetPixelAlpha(image,GetPixelAlpha(image,q),q);
+ q++;
}
- 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:
+ if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
{
- range=GetQuantumRange(quantum_info->depth);
+ 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++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
+ quantum=GetPixelRed(image,q);
+ SetPixelRed(image,GetPixelGreen(image,q),q);
+ SetPixelGreen(image,quantum,q);
+ q+=channels;
}
- break;
}
- }
-}
-
-static void ExportBGRQuantum(const Image *image,const QuantumInfo *quantum_info,
- QuantumState quantum_state,const MagickSizeType number_pixels,
- const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
-{
- EndianType
- endian;
-
- QuantumAny
- range;
-
- register ssize_t
- x;
-
- ssize_t
- bit;
-
+ x=0;
+ q=pixels;
+ InitializeQuantumState(quantum_info,image->endian,&quantum_state);
+ extent=GetQuantumExtent(image,quantum_info,quantum_type);
endian=quantum_state.endian;
- switch (quantum_info->depth)
+ switch (quantum_type)
{
- case 8:
+ case IndexQuantum:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ if (image->storage_class != PseudoClass)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return(extent);
+ }
+ switch (quantum_info->depth)
{
- q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 10:
- {
- register unsigned int
- pixel;
+ case 1:
+ {
+ register unsigned char
+ pixel;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ {
+ 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)
+ {
+ *q='\0';
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << (unsigned char) bit);
+ p+=channels;
+ }
+ q++;
+ }
+ break;
+ }
+ case 4:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
{
- 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;
+ 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++;
+ }
break;
}
- if (quantum_info->quantum == 32UL)
+ case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=GetPixelChannels(image);
+ q=PopCharPixel((unsigned char) GetPixelIndex(image,p),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+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 12:
- {
- register unsigned int
- pixel;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ case 16:
{
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
- {
- switch (x % 3)
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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:
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- p+=GetPixelChannels(image);
- break;
+ q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
+ GetPixelIndex(image,p)),q);
+ p+=channels;
+ q+=quantum_info->pad;
}
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- switch ((x+1) % 3)
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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:
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- p+=GetPixelChannels(image);
- break;
+ q=PopFloatPixel(&quantum_state,(float)
+ GetPixelIndex(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
}
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
+ p+=channels;
q+=quantum_info->pad;
}
- for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
- {
- switch ((x+bit) % 3)
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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:
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- p+=GetPixelChannels(image);
- break;
+ q=PopDoublePixel(&quantum_state,(double)
+ GetPixelIndex(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
}
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- if (bit != 0)
- p+=GetPixelChannels(image);
- break;
}
- if (quantum_info->quantum == 32UL)
+ default:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=GetPixelChannels(image);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ GetPixelIndex(image,p),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+=GetPixelChannels(image);
- q+=quantum_info->pad;
}
break;
}
- case 16:
+ case IndexAlphaQuantum:
{
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ if (image->storage_class != PseudoClass)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return(extent);
}
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (quantum_info->depth)
{
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0x01) << 7);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 6);
+ p+=channels;
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 5);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 4);
+ p+=channels;
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 3);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 2);
+ p+=channels;
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 1);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 0);
+ p+=channels;
+ q++;
+ }
+ if ((number_pixels % 4) != 0)
+ {
+ *q='\0';
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << (unsigned char) (bit+4));
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
+ p+=channels;
+ }
+ q++;
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (x=0; x < (ssize_t) number_pixels ; x++)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0xf) << 4);
+ pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
+ *q|=((pixel & 0xf) << 0);
+ p+=channels;
+ q++;
+ }
+ break;
+ }
+ case 8:
{
+ register unsigned char
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
- p+=GetPixelChannels(image);
+ q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 16:
{
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopShortPixel(endian,(unsigned short)
+ GetPixelIndex(image,p),q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelAlpha(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=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=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- }
- 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 ExportBGRAQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
-{
- EndianType
- endian;
-
- QuantumAny
- range;
-
- register ssize_t
- x;
-
- endian=quantum_state.endian;
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ case 32:
+ {
+ register unsigned int
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
+ 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+=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:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ GetPixelIndex(image,p),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
}
break;
}
- case 10:
+ case BGRQuantum:
{
- register unsigned int
- pixel;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- 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++)
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- switch (i)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- 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;
+ 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;
}
- switch (n % 3)
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 0:
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ switch (x % 3)
{
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 22);
- break;
+ 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;
+ }
}
- case 1:
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ switch ((x+1) % 3)
{
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 12);
- break;
+ 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;
+ }
}
- case 2:
+ 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)
{
- pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
- range) << 2);
- q=PopLongPixel(endian,pixel,q);
- pixel=0;
- break;
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelRed(image,p),range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelGreen(image,p),range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelBlue(image,p),range);
+ p+=channels;
+ break;
+ }
}
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q+=quantum_info->pad;
}
- n++;
+ 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;
}
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ q=PopQuantumPixel(&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),
+ q=PopQuantumPixel(&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=PopQuantumPixel(&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+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 16:
{
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
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));
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ 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);
- 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;
+ case 32:
+ {
+ register unsigned int
+ 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)
+ GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float)
+ GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float)
+ GetPixelBlue(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(&quantum_state,(double)
+ GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double)
+ GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double)
+ GetPixelBlue(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
{
+ range=GetQuantumRange(quantum_info->depth);
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+=GetPixelChannels(image);
+ 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;
}
- 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 64:
+ case BGRAQuantum:
+ case BGROQuantum:
{
- if (quantum_info->format == FloatingPointQuantumFormat)
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- double
+ register unsigned char
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+=GetPixelChannels(image);
+ 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;
}
- }
- 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;
- }
- }
-}
+ case 10:
+ {
+ register unsigned int
+ 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;
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ register ssize_t
+ i;
- 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;
+ size_t
+ quantum;
- 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;
+ ssize_t
+ n;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
+ 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=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ 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;
}
- 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)
+ 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;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- 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)
+ 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;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
- p+=GetPixelChannels(image);
+ 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+=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(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;
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ double
+ pixel;
- 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);
+ 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++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ 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+=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 32:
+ case GrayQuantum:
{
- register unsigned int
- pixel;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register Quantum
+ threshold;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ register unsigned char
+ black,
+ 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-7); x > 0; x-=8)
+ {
+ *q='\0';
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 7;
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 6;
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 5;
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 4;
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 3;
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 2;
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 1;
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 0;
+ p+=channels;
+ q++;
+ }
+ if ((number_pixels % 8) != 0)
+ {
+ *q='\0';
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+ {
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) <<
+ bit;
+ p+=channels;
+ }
+ q++;
+ }
+ break;
+ }
+ case 4:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ p+=channels;
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q|=pixel >> 4;
+ p+=channels;
+ q++;
}
+ if ((number_pixels % 2) != 0)
+ {
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ p+=channels;
+ q++;
+ }
break;
}
- 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)
+ case 8:
{
+ register unsigned char
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ q=PopCharPixel(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(GetPixelBlue(image,p),range),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- }
-}
-
-static void ExportCbYCrYQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
-{
- EndianType
- endian;
-
- Quantum
- cbcr[4];
-
- register ssize_t
- i,
- x;
-
- register unsigned int
- pixel;
-
- size_t
- quantum;
-
- ssize_t
- n;
-
- endian=quantum_state.endian;
- n=0;
- quantum=0;
- switch (quantum_info->depth)
- {
- case 10:
- {
- if (quantum_info->pack == MagickFalse)
+ case 10:
{
- for (x=0; x < (ssize_t) number_pixels; x+=2)
- {
- for (i=0; i < 4; i++)
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- switch (n % 3)
+ register unsigned int
+ pixel;
+
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- case 0:
- {
- quantum=GetPixelRed(image,p);
- break;
- }
- case 1:
- {
- quantum=GetPixelGreen(image,p);
- break;
- }
- case 2:
+ 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)
{
- quantum=GetPixelBlue(image,p);
- break;
+ 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);
}
- }
- cbcr[i]=(Quantum) quantum;
- n++;
+ break;
}
- 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);
+ 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;
}
- break;
- }
- default:
- {
- QuantumAny
- range;
-
- for (x=0; x < (ssize_t) number_pixels; x+=2)
- {
- for (i=0; i < 4; i++)
+ case 12:
{
- switch (n % 3)
- {
- case 0:
+ register unsigned short
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- quantum=GetPixelRed(image,p);
+ 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;
}
- case 1:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- quantum=GetPixelGreen(image,p);
+ 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;
}
- case 2:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- quantum=GetPixelBlue(image,p);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ float
+ pixel;
+
+ pixel=(float) GetPixelIntensity(image,p);
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
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;
}
- 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;
- }
- }
-}
-
-static void ExportCMYKQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
-{
- EndianType
- endian;
-
- register ssize_t
- x;
-
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return;
- }
- endian=quantum_state.endian;
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
- q=PopCharPixel(pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ double
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ pixel=(double) GetPixelIntensity(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++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
}
break;
}
- case 32:
+ case GrayAlphaQuantum:
{
- register unsigned int
- pixel;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register Quantum
+ threshold;
+
+ register unsigned char
+ black,
+ pixel,
+ white;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ black=0x00;
+ white=0x01;
+ if (quantum_info->min_is_white == MagickFalse)
+ {
+ black=0x01;
+ white=0x00;
+ }
+ threshold=(Quantum) (QuantumRange/2);
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ {
+ *q='\0';
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 7;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 5;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 3;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
+ p+=channels;
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 1;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
+ p+=channels;
+ q++;
+ }
+ if ((number_pixels % 4) != 0)
+ {
+ *q='\0';
+ for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
+ {
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) <<
+ (7-bit);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
+ (7-bit-1));
+ p+=channels;
+ }
+ q++;
+ }
+ break;
+ }
+ case 4:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ register unsigned char
+ pixel;
+
+ 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+=GetPixelChannels(image);
- q+=quantum_info->pad;
+ 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;
}
- 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)
+ case 8:
{
+ register unsigned char
+ 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);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- }
- 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;
- }
- }
-}
-
-static void ExportCMYKAQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
-{
- EndianType
- endian;
-
- register ssize_t
- x;
-
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return;
- }
- endian=quantum_state.endian;
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 16:
{
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelIntensity(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ 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=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));
+ pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 32:
{
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ float
+ pixel;
+
+ pixel=(float) GetPixelIntensity(image,p);
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ pixel=(float) (GetPixelAlpha(image,p));
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- 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);
+ pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- 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)
+ case 64:
{
- double
- pixel;
-
+ 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:
+ {
+ range=GetQuantumRange(quantum_info->depth);
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+=GetPixelChannels(image);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ p+=channels;
q+=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);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
}
break;
}
- }
-}
-
-static void ExportGrayQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
-{
- EndianType
- endian;
-
- QuantumAny
- range;
-
- register ssize_t
- x;
-
- endian=quantum_state.endian;
- switch (quantum_info->depth)
- {
- case 1:
+ case RedQuantum:
+ case CyanQuantum:
{
- register Quantum
- threshold;
-
- register unsigned char
- black,
- white;
-
- ssize_t
- bit;
-
- black=0x00;
- white=0x01;
- if (quantum_info->min_is_white != MagickFalse)
- {
- black=0x01;
- white=0x00;
- }
- threshold=(Quantum) (QuantumRange/2);
- for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ switch (quantum_info->depth)
{
- *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)
+ case 8:
{
- *q='\0';
- for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << bit;
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
}
- q++;
+ break;
}
- break;
- }
- case 4:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
- {
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- p+=GetPixelChannels(image);
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q|=pixel >> 4;
- p+=GetPixelChannels(image);
- q++;
- }
- if ((number_pixels % 2) != 0)
+ case 16:
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- p+=GetPixelChannels(image);
- q++;
- }
- break;
- }
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- q=PopCharPixel(pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 10:
- {
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ 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;
- for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
+ 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=(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);
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
q=PopLongPixel(endian,pixel,q);
- p+=3*GetPixelChannels(image);
+ p+=channels;
q+=quantum_info->pad;
}
- if (x < (ssize_t) number_pixels)
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(&quantum_state,(double)
+ GetPixelRed(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
}
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
}
break;
}
- case 12:
+ case GreenQuantum:
+ case MagentaQuantum:
{
- register unsigned short
- pixel;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ switch (quantum_info->depth)
+ {
+ case 8:
{
+ register unsigned char
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,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+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 16:
{
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelIntensity(image,p));
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ 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+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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)
+ GetPixelGreen(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- float
- pixel;
-
- pixel=(float) GetPixelIntensity(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,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+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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:
+ {
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- double
- pixel;
-
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=GetPixelChannels(image);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),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(GetPixelIntensity(image,p),range),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
}
break;
}
- }
-}
-
-static void ExportGrayAlphaQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
-{
- EndianType
- endian;
-
- QuantumAny
- range;
-
- register ssize_t
- x;
-
- endian=quantum_state.endian;
- switch (quantum_info->depth)
- {
- case 1:
+ case BlueQuantum:
+ case YellowQuantum:
{
- register Quantum
- threshold;
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
- register unsigned char
- black,
- pixel,
- white;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
- ssize_t
- bit;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
- 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=PopFloatPixel(&quantum_state,(float)
+ GetPixelBlue(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
{
- black=0x01;
- white=0x00;
+ 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;
+ }
}
- 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)
+ default:
{
- *q='\0';
- for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- *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);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ p+=channels;
+ q+=quantum_info->pad;
}
- q++;
+ break;
}
- 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 8:
+ case AlphaQuantum:
{
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (quantum_info->depth)
{
- 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;
+ case 8:
+ {
+ register unsigned char
+ 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+=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+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelIntensity(image,p));
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 32:
{
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ float
+ pixel;
+
+ pixel=(float) GetPixelAlpha(image,p);
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- 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);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ double
+ pixel;
+
+ 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++)
{
- 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=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),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(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:
+ case OpacityQuantum:
{
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (quantum_info->depth)
{
- 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)
+ case 8:
{
+ register unsigned char
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToShort(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=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 32:
{
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(&quantum_state,(float)
+ GetPixelAlpha(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- }
- default:
- {
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_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)
+ case 64:
{
- *q='\0';
- for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << (unsigned char) bit);
- p+=GetPixelChannels(image);
- }
- q++;
- }
- break;
- }
- case 4:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- p+=GetPixelChannels(image);
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0xf) << 0);
- p+=GetPixelChannels(image);
- q++;
- }
- if ((number_pixels % 2) != 0)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- p+=GetPixelChannels(image);
- q++;
+ 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;
+ }
}
- 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)
+ default:
{
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
- GetPixelIndex(image,p)),q);
- p+=GetPixelChannels(image);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),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+=GetPixelChannels(image);
- q+=quantum_info->pad;
}
break;
}
- case 32:
+ case BlackQuantum:
{
- if (quantum_info->format == FloatingPointQuantumFormat)
+ if (image->colorspace != CMYKColorspace)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return(extent);
}
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (quantum_info->depth)
{
- q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 8:
{
+ register unsigned char
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- }
- default:
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- GetPixelIndex(image,p),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- }
-}
-
-static void ExportIndexAlphaQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
-{
- EndianType
- endian;
-
- register ssize_t
- x;
-
- ssize_t
- bit;
-
- if (image->storage_class != PseudoClass)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
- return;
- }
- endian=quantum_state.endian;
- switch (quantum_info->depth)
- {
- case 1:
- {
- register unsigned char
- pixel;
-
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0x01) << 7);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 6);
- p+=GetPixelChannels(image);
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 5);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 4);
- p+=GetPixelChannels(image);
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 3);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 2);
- p+=GetPixelChannels(image);
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 1);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 0);
- p+=GetPixelChannels(image);
- q++;
- }
- if ((number_pixels % 4) != 0)
+ case 16:
{
- *q='\0';
- for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << (unsigned char) (bit+4));
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
- p+=GetPixelChannels(image);
- }
- q++;
- }
- break;
- }
- case 4:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels ; x++)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
- *q|=((pixel & 0xf) << 0);
- p+=GetPixelChannels(image);
- q++;
- }
- break;
- }
- case 8:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
+ register unsigned short
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelBlack(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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;
+ }
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+=GetPixelChannels(image);
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(endian,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+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 64:
{
- 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+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
+ 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:
- {
- 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)
+ default:
{
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny((Quantum) GetPixelBlack(image,p),range),q);
+ p+=channels;
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 32:
+ case RGBQuantum:
+ case CbYCrQuantum:
{
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ switch (quantum_info->depth)
+ {
+ case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelOpacity(image,p),q);
- p+=GetPixelChannels(image);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 10:
{
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) (
+ ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
+ ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
+ ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelOpacity(image,p),
- q);
- p+=GetPixelChannels(image);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- }
- 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;
- }
- }
-}
-
-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;
+ 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)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelRed(image,p),range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelGreen(image,p),range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelBlue(image,p),range);
+ p+=channels;
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ switch ((x+1) % 3)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelRed(image,p),range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelGreen(image,p),range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelBlue(image,p),range);
+ p+=channels;
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q+=quantum_info->pad;
+ }
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ switch ((x+bit) % 3)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelRed(image,p),range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelGreen(image,p),range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(
+ GetPixelBlue(image,p),range);
+ p+=channels;
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q+=quantum_info->pad;
+ }
+ if (bit != 0)
+ p+=channels;
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
{
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 32:
{
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(&quantum_state,(float)
+ GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float)
+ GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float)
+ GetPixelBlue(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- 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)
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(&quantum_state,(double)
+ GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double)
+ GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double)
+ GetPixelBlue(image,p),q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
{
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
- p+=GetPixelChannels(image);
+ 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;
}
- }
- 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;
}
- }
-}
-
-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:
+ case RGBAQuantum:
+ case RGBOQuantum:
+ case CbYCrAQuantum:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (quantum_info->depth)
{
- q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 10:
- {
- register unsigned int
- pixel;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ case 8:
{
+ register unsigned char
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) (
- ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
- ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
- ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- if (quantum_info->quantum == 32UL)
+ case 10:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 12:
- {
- register unsigned int
- pixel;
+ register unsigned int
+ pixel;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
- {
- switch (x % 3)
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- 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:
+ 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++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- p+=GetPixelChannels(image);
- break;
+ 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;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- switch ((x+1) % 3)
+ if (quantum_info->quantum == 32UL)
{
- default:
- case 0:
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
range);
- break;
- }
- case 1:
- {
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- break;
- }
- case 2:
- {
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
range);
- p+=GetPixelChannels(image);
- break;
- }
- }
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
- {
- switch ((x+bit) % 3)
- {
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
range);
- p+=GetPixelChannels(image);
- break;
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+ q);
+ p+=channels;
+ q+=quantum_info->pad;
}
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- if (bit != 0)
- p+=GetPixelChannels(image);
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ q=PopQuantumPixel(&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=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;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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*
+ 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=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
- p+=GetPixelChannels(image);
+ 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+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 64:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ 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:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
- p+=GetPixelChannels(image);
+ q=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;
q+=quantum_info->pad;
}
break;
}
- }
- default:
- {
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
}
break;
}
- }
-}
-
-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:
+ case CMYKQuantum:
{
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return(extent);
+ }
+ switch (quantum_info->depth)
{
- 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)
+ case 8:
{
- register ssize_t
- i;
-
- size_t
- quantum;
-
- ssize_t
- n;
+ 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++)
+ 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:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- switch (i)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- 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;
+ 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;
}
- switch (n % 3)
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- 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;
- }
+ 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;
}
- n++;
+ break;
}
- p+=GetPixelChannels(image);
+ 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;
}
- if (quantum_info->quantum == 32UL)
+ 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:
+ {
+ range=GetQuantumRange(quantum_info->depth);
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+=GetPixelChannels(image);
+ 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+=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:
+ case CMYKAQuantum:
+ case CMYKOQuantum:
{
- register unsigned short
- pixel;
+ 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;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
{
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelBlack(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelAlpha(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=channels;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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;
+ }
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+=GetPixelChannels(image);
+ 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;
q+=quantum_info->pad;
}
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=GetPixelChannels(image);
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 64:
{
- double
- pixel;
+ 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);
+ 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=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=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+=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;
}
- }
-}
-
-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;
-
- QuantumState
- quantum_state;
-
- register const Quantum
- *restrict p;
-
- register ssize_t
- x;
-
- 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)
+ case CbYCrYQuantum:
{
- 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) GetPixelChannels(image); i++)
- {
- PixelChannel
- channel;
+ Quantum
+ cbcr[4];
- PixelTrait
- traits;
+ register ssize_t
+ i;
- 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;
+ register unsigned int
+ 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+=GetPixelChannels(image);
- }
- }
- if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
- {
- Quantum
+ size_t
quantum;
- register Quantum
- *restrict q;
+ ssize_t
+ n;
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetAuthenticPixelQueue(image);
- for (x=0; x < (ssize_t) number_pixels; x++)
+ n=0;
+ quantum=0;
+ range=GetQuantumRange(quantum_info->depth);
+ switch (quantum_info->depth)
{
- quantum=GetPixelRed(image,q);
- SetPixelRed(image,GetPixelGreen(image,q),q);
- SetPixelGreen(image,quantum,q);
- q+=GetPixelChannels(image);
+ case 10:
+ {
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (n % 3)
+ {
+ case 0:
+ {
+ quantum=GetPixelRed(image,p);
+ break;
+ }
+ case 1:
+ {
+ quantum=GetPixelGreen(image,p);
+ break;
+ }
+ case 2:
+ {
+ quantum=GetPixelBlue(image,p);
+ break;
+ }
+ }
+ cbcr[i]=(Quantum) quantum;
+ n++;
+ }
+ pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
+ (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
+ pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
+ (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p+=channels;
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ break;
+ }
+ default:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
+ {
+ 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;
+ }
}
- }
- 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+=GetPixelChannels(image);
+ q+=channels;
}
}
if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
for (x=0; x < (ssize_t) number_pixels; x++)
{
SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
+ q+=channels;
}
}
return(extent);
projects / imagemagick / commitdiff