% MagickCore Methods to Import Quantum Pixels %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% October 1998 %
% %
% %
-% Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/option.h"
#include "MagickCore/pixel.h"
#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/pixel-private.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
#include "MagickCore/resource_.h"
%
% The format of the ImportQuantumPixels method is:
%
-% size_t ImportQuantumPixels(Image *image,CacheView *image_view,
-% const QuantumInfo *quantum_info,const QuantumType quantum_type,
-% const unsigned char *pixels,ExceptionInfo *exception)
+% size_t ImportQuantumPixels(const Image *image,CacheView *image_view,
+% QuantumInfo *quantum_info,const QuantumType quantum_type,
+% const unsigned char *restrict pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
*/
-static inline Quantum PushColormapIndex(Image *image,
- const size_t index,MagickBooleanType *range_exception)
+static inline Quantum PushColormapIndex(const Image *image,const size_t index,
+ MagickBooleanType *range_exception)
{
if (index < image->colors)
return((Quantum) index);
return((Quantum) 0);
}
-static inline const unsigned char *PushDoublePixel(
- const QuantumState *quantum_state,const unsigned char *pixels,double *pixel)
+static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
+ const unsigned char *restrict pixels,double *pixel)
{
double
*p;
unsigned char
quantum[8];
- if (quantum_state->endian != LSBEndian)
+ if (quantum_info->endian == LSBEndian)
{
- quantum[7]=(*pixels++);
- quantum[6]=(*pixels++);
- quantum[5]=(*pixels++);
- quantum[5]=(*pixels++);
- quantum[3]=(*pixels++);
- quantum[2]=(*pixels++);
- quantum[1]=(*pixels++);
quantum[0]=(*pixels++);
+ quantum[1]=(*pixels++);
+ quantum[2]=(*pixels++);
+ quantum[3]=(*pixels++);
+ quantum[4]=(*pixels++);
+ quantum[5]=(*pixels++);
+ quantum[6]=(*pixels++);
+ quantum[7]=(*pixels++);
p=(double *) quantum;
*pixel=(*p);
- *pixel-=quantum_state->minimum;
- *pixel*=quantum_state->scale;
+ *pixel-=quantum_info->minimum;
+ *pixel*=quantum_info->scale;
return(pixels);
}
- quantum[0]=(*pixels++);
- quantum[1]=(*pixels++);
- quantum[2]=(*pixels++);
- quantum[3]=(*pixels++);
- quantum[4]=(*pixels++);
- quantum[5]=(*pixels++);
- quantum[6]=(*pixels++);
quantum[7]=(*pixels++);
+ quantum[6]=(*pixels++);
+ quantum[5]=(*pixels++);
+ quantum[4]=(*pixels++);
+ quantum[3]=(*pixels++);
+ quantum[2]=(*pixels++);
+ quantum[1]=(*pixels++);
+ quantum[0]=(*pixels++);
p=(double *) quantum;
*pixel=(*p);
- *pixel-=quantum_state->minimum;
- *pixel*=quantum_state->scale;
+ *pixel-=quantum_info->minimum;
+ *pixel*=quantum_info->scale;
return(pixels);
}
-static inline const unsigned char *PushFloatPixel(
- const QuantumState *quantum_state,const unsigned char *pixels,float *pixel)
+static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info,
+ const unsigned char *restrict pixels,float *pixel)
{
float
*p;
unsigned char
quantum[4];
- if (quantum_state->endian != LSBEndian)
+ if (quantum_info->endian == LSBEndian)
{
- quantum[3]=(*pixels++);
- quantum[2]=(*pixels++);
- quantum[1]=(*pixels++);
quantum[0]=(*pixels++);
+ quantum[1]=(*pixels++);
+ quantum[2]=(*pixels++);
+ quantum[3]=(*pixels++);
p=(float *) quantum;
*pixel=(*p);
- *pixel-=quantum_state->minimum;
- *pixel*=quantum_state->scale;
+ *pixel-=quantum_info->minimum;
+ *pixel*=quantum_info->scale;
return(pixels);
}
- quantum[0]=(*pixels++);
- quantum[1]=(*pixels++);
- quantum[2]=(*pixels++);
quantum[3]=(*pixels++);
+ quantum[2]=(*pixels++);
+ quantum[1]=(*pixels++);
+ quantum[0]=(*pixels++);
p=(float *) quantum;
*pixel=(*p);
- *pixel-=quantum_state->minimum;
- *pixel*=quantum_state->scale;
+ *pixel-=quantum_info->minimum;
+ *pixel*=quantum_info->scale;
return(pixels);
}
-static inline const unsigned char *PushQuantumPixel(
- QuantumState *quantum_state,const size_t depth,
- const unsigned char *pixels,unsigned int *quantum)
+static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
+ const unsigned char *restrict pixels,unsigned int *quantum)
{
register ssize_t
i;
quantum_bits;
*quantum=(QuantumAny) 0;
- for (i=(ssize_t) depth; i > 0L; )
+ for (i=(ssize_t) quantum_info->depth; i > 0L; )
{
- if (quantum_state->bits == 0UL)
+ if (quantum_info->state.bits == 0UL)
{
- quantum_state->pixel=(*pixels++);
- quantum_state->bits=8UL;
+ quantum_info->state.pixel=(*pixels++);
+ quantum_info->state.bits=8UL;
}
quantum_bits=(size_t) i;
- if (quantum_bits > quantum_state->bits)
- quantum_bits=quantum_state->bits;
+ if (quantum_bits > quantum_info->state.bits)
+ quantum_bits=quantum_info->state.bits;
i-=(ssize_t) quantum_bits;
- quantum_state->bits-=quantum_bits;
+ quantum_info->state.bits-=quantum_bits;
*quantum=(unsigned int) ((*quantum << quantum_bits) |
- ((quantum_state->pixel >> quantum_state->bits) &~ ((~0UL) <<
+ ((quantum_info->state.pixel >> quantum_info->state.bits) &~ ((~0UL) <<
quantum_bits)));
}
return(pixels);
}
static inline const unsigned char *PushQuantumLongPixel(
- QuantumState *quantum_state,const size_t depth,
- const unsigned char *pixels,unsigned int *quantum)
+ QuantumInfo *quantum_info,const unsigned char *restrict pixels,
+ unsigned int *quantum)
{
register ssize_t
i;
quantum_bits;
*quantum=0UL;
- for (i=(ssize_t) depth; i > 0; )
+ for (i=(ssize_t) quantum_info->depth; i > 0; )
{
- if (quantum_state->bits == 0)
+ if (quantum_info->state.bits == 0)
{
- pixels=PushLongPixel(quantum_state->endian,pixels,
- &quantum_state->pixel);
- quantum_state->bits=32U;
+ pixels=PushLongPixel(quantum_info->endian,pixels,
+ &quantum_info->state.pixel);
+ quantum_info->state.bits=32U;
}
quantum_bits=(size_t) i;
- if (quantum_bits > quantum_state->bits)
- quantum_bits=quantum_state->bits;
- *quantum|=(((quantum_state->pixel >> (32U-quantum_state->bits)) &
- quantum_state->mask[quantum_bits]) << (depth-i));
+ if (quantum_bits > quantum_info->state.bits)
+ quantum_bits=quantum_info->state.bits;
+ *quantum|=(((quantum_info->state.pixel >> (32U-quantum_info->state.bits)) &
+ quantum_info->state.mask[quantum_bits]) << (quantum_info->depth-i));
i-=(ssize_t) quantum_bits;
- quantum_state->bits-=quantum_bits;
+ quantum_info->state.bits-=quantum_bits;
}
return(pixels);
}
-MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
- const QuantumInfo *quantum_info,const QuantumType quantum_type,
- const unsigned char *pixels,ExceptionInfo *exception)
+static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
- MagickSizeType
- number_pixels;
-
QuantumAny
range;
- QuantumState
- quantum_state;
-
- register const unsigned char
- *restrict p;
-
register ssize_t
x;
- register Quantum
- *restrict q;
-
- size_t
- channels,
- extent;
-
- ssize_t
- bit;
-
unsigned int
pixel;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(quantum_info != (QuantumInfo *) NULL);
- assert(quantum_info->signature == MagickSignature);
- if (pixels == (const unsigned char *) NULL)
- pixels=GetQuantumPixels(quantum_info);
- x=0;
- p=pixels;
- if (image_view == (CacheView *) NULL)
- {
- number_pixels=GetImageExtent(image);
- q=GetAuthenticPixelQueue(image);
- channels=GetPixelChannels(image);
- }
- else
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- number_pixels=GetCacheViewExtent(image_view);
- q=GetCacheViewAuthenticPixelQueue(image_view);
- channels=GetPixelChannels(image);
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
}
- InitializeQuantumState(quantum_info,image->endian,&quantum_state);
- extent=GetQuantumExtent(image,quantum_info,quantum_type);
- endian=quantum_state.endian;
- switch (quantum_type)
- {
- case IndexQuantum:
+ case 16:
{
- MagickBooleanType
- range_exception;
+ unsigned short
+ pixel;
- if (image->storage_class != PseudoClass)
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
- return(extent);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
}
- range_exception=MagickFalse;
- switch (quantum_info->depth)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 1:
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ float
pixel;
- for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
- {
- for (bit=0; bit < 8; bit++)
- {
- if (quantum_info->min_is_white == MagickFalse)
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
- 0x00 : 0x01);
- else
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
- 0x00 : 0x01);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- q+=channels;
- }
- p++;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- if (quantum_info->min_is_white == MagickFalse)
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
- 0x00 : 0x01);
- else
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
- 0x00 : 0x01);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- q+=channels;
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 4:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ double
pixel;
- for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
- {
- pixel=(unsigned char) ((*p >> 4) & 0xf);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- q+=channels;
- pixel=(unsigned char) ((*p) & 0xf);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p++;
- q+=channels;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) ((*p++ >> 4) & 0xf);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- q+=channels;
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 8:
- {
- unsigned char
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
+ SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
+ q);
+ SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ if (quantum_info->quantum == 32U)
{
- unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
- (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 12:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- unsigned int
+ unsigned short
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ switch (x % 3)
{
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,
- ClampToQuantum(pixel),&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ break;
+ }
+ }
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ switch ((x+1) % 3)
+ {
+ default:
+ case 0:
+ {
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ break;
}
- break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
p+=quantum_info->pad;
- q+=channels;
}
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ switch ((x+bit) % 3)
{
- double
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,
- ClampToQuantum(pixel),&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ break;
}
- break;
}
+ p+=quantum_info->pad;
+ }
+ if (bit != 0)
+ p++;
+ break;
}
- default:
+ if (quantum_info->quantum == 32U)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
}
- if (range_exception != MagickFalse)
- (void) ThrowMagickException(exception,GetMagickModule(),
- CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
break;
}
- case IndexAlphaQuantum:
+ case 16:
{
- MagickBooleanType
- range_exception;
+ unsigned short
+ pixel;
- if (image->storage_class != PseudoClass)
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- (void) ThrowMagickException(exception,GetMagickModule(),
- ImageError,"ColormappedImageRequired","`%s'",image->filename);
- return(extent);
- }
- range_exception=MagickFalse;
- switch (quantum_info->depth)
- {
- case 1:
- {
- register unsigned char
- pixel;
-
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- for (bit=0; bit < 8; bit+=2)
- {
- if (quantum_info->min_is_white == MagickFalse)
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
- 0x00 : 0x01);
- else
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
- 0x00 : 0x01);
- SetPixelRed(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
- (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
- SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
- q+=channels;
- }
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
- if ((number_pixels % 4) != 0)
- for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
- {
- if (quantum_info->min_is_white == MagickFalse)
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
- 0x00 : 0x01);
- else
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
- 0x00 : 0x01);
- SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
- SetPixelRed(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
- (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
- q+=channels;
- }
break;
}
- case 4:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ float
pixel;
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) ((*p >> 4) & 0xf);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- pixel=(unsigned char) ((*p) & 0xf);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- p++;
- q+=channels;
- }
- break;
- }
- case 8:
- {
- unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushCharPixel(p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
- (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,
- ClampToQuantum(pixel),&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ register ssize_t
+ x;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,
- ClampToQuantum(pixel),&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelIndex(image,PushColormapIndex(image,pixel,
- &range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
- GetPixelIndex(image,q),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
- if (range_exception != MagickFalse)
- (void) ThrowMagickException(exception,GetMagickModule(),
- CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
break;
}
- case BGRQuantum:
+ case 10:
{
- switch (quantum_info->depth)
- {
- case 8:
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
{
- unsigned char
- pixel;
+ register ssize_t
+ i;
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 10:
- {
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
- range),q);
- SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
- range),q);
- SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
- range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- if (quantum_info->quantum == 32U)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- case 12:
- {
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
+ for (i=0; i < 4; i++)
{
- unsigned short
- pixel;
-
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ switch (n % 3)
{
- p=PushShortPixel(endian,p,&pixel);
- switch (x % 3)
+ case 0:
{
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 22) & 0x3ff) << 6)));
+ break;
}
- p=PushShortPixel(endian,p,&pixel);
- switch ((x+1) % 3)
+ case 1:
{
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 12) & 0x3ff) << 6)));
+ break;
}
- p+=quantum_info->pad;
- }
- for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
- {
- p=PushShortPixel(endian,p,&pixel);
- switch ((x+bit) % 3)
+ case 2:
{
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 2) & 0x3ff) << 6)));
+ break;
}
- p+=quantum_info->pad;
}
- if (bit != 0)
- p++;
- break;
- }
- if (quantum_info->quantum == 32U)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (i)
{
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ case 0: SetPixelRed(image,(Quantum) quantum,q); break;
+ case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
+ case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
+ case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
}
- break;
+ n++;
}
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ float
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned int
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case BGRAQuantum:
- case BGROQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 10:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- pixel=0;
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
-
- size_t
- quantum;
-
- ssize_t
- n;
+ double
+ pixel;
- n=0;
- quantum=0;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- p=PushLongPixel(endian,p,&pixel);
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 22) & 0x3ff) << 6)));
- break;
- }
- case 1:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 12) & 0x3ff) << 6)));
- break;
- }
- case 2:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 2) & 0x3ff) << 6)));
- break;
- }
- }
- switch (i)
- {
- case 0: SetPixelRed(image,(Quantum) quantum,q); break;
- case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
- case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
- case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
- }
- n++;
- }
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- q+=channels;
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
- {
- unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ register ssize_t
+ x;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case GrayQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 1:
- {
- register Quantum
- black,
- white;
+ unsigned int
+ pixel;
- black=0;
- white=(Quantum) QuantumRange;
- if (quantum_info->min_is_white != MagickFalse)
- {
- black=(Quantum) QuantumRange;
- white=0;
- }
- for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
- {
- for (bit=0; bit < 8; bit++)
- {
- SetPixelRed(image,((*p) & (1 << (7-bit))) == 0 ? black :
- white,q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- }
- p++;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
- {
- SetPixelRed(image,((*p) & (0x01 << (7-bit))) == 0 ? black :
- white,q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- }
- if (bit != 0)
- p++;
- break;
- }
- case 4:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ float
pixel;
- range=GetQuantumRange(image->depth);
- for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
- {
- pixel=(unsigned char) ((*p >> 4) & 0xf);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- pixel=(unsigned char) ((*p) & 0xf);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p++;
- q+=channels;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) (*p++ >> 4);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 8:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ double
pixel;
- if (quantum_info->min_is_white != MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 10:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 10:
+ {
+ Quantum
+ cbcr[4];
+
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
{
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
+ {
+ for (i=0; i < 4; i++)
{
- if (image->endian != LSBEndian)
+ switch (n % 3)
+ {
+ case 0:
{
- for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- p=PushLongPixel(endian,p,&pixel);
- if (x++ < (ssize_t) (number_pixels-1))
- {
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- }
- if (x++ < (ssize_t) number_pixels)
- {
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- }
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 22) & 0x3ff) << 6)));
break;
}
- for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- p=PushLongPixel(endian,p,&pixel);
- if (x++ < (ssize_t) (number_pixels-1))
+ case 1:
{
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 12) & 0x3ff) << 6)));
+ break;
}
- if (x++ < (ssize_t) number_pixels)
+ case 2:
{
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
- range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 2) & 0x3ff) << 6)));
+ break;
}
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 12:
- {
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
- {
- unsigned short
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=channels;
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(
- (QuantumAny) (pixel >> 4),range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(
- (QuantumAny) (pixel >> 4),range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
}
- if (bit != 0)
- p++;
- break;
+ cbcr[i]=(Quantum) (quantum);
+ n++;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
p+=quantum_info->pad;
- q+=channels;
+ SetPixelRed(image,cbcr[1],q);
+ SetPixelGreen(image,cbcr[0],q);
+ SetPixelBlue(image,cbcr[2],q);
+ q+=GetPixelChannels(image);
+ SetPixelRed(image,cbcr[3],q);
+ SetPixelGreen(image,cbcr[0],q);
+ SetPixelBlue(image,cbcr[2],q);
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
- {
- unsigned short
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->min_is_white != MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 32:
- {
- unsigned int
- pixel;
+static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+ register ssize_t
+ x;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case GrayAlphaQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 1:
- {
- register unsigned char
- pixel;
+ unsigned int
+ pixel;
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
- {
- for (bit=0; bit < 8; bit+=2)
- {
- pixel=(unsigned char)
- (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
- SetPixelRed(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
- (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
- q+=channels;
- }
- p++;
- }
- if ((number_pixels % 4) != 0)
- for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
- {
- pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 :
- 0x01);
- SetPixelRed(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
- (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
- q+=channels;
- }
- if (bit != 0)
- p++;
- break;
- }
- case 4:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ float
pixel;
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) ((*p >> 4) & 0xf);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- pixel=(unsigned char) ((*p) & 0xf);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- p++;
- q+=channels;
- }
- break;
- }
- case 8:
- {
- unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 10:
- {
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 12:
- {
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ register ssize_t
+ x;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- SetPixelGreen(image,GetPixelRed(image,q),q);
- SetPixelBlue(image,GetPixelRed(image,q),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ unsigned int
+ pixel;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case RedQuantum:
- case CyanQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register Quantum
+ black,
+ white;
+
+ black=0;
+ white=QuantumRange;
+ if (quantum_info->min_is_white != MagickFalse)
{
- unsigned int
- pixel;
+ black=QuantumRange;
+ white=0;
+ }
+ for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
+ {
+ for (bit=0; bit < 8; bit++)
+ {
+ SetPixelGray(image,((*p) & (1 << (7-bit))) == 0 ? black : white,q);
+ q+=GetPixelChannels(image);
+ }
+ p++;
+ }
+ for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
+ {
+ SetPixelGray(image,((*p) & (0x01 << (7-bit))) == 0 ? black : white,q);
+ q+=GetPixelChannels(image);
+ }
+ if (bit != 0)
+ p++;
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
+ {
+ pixel=(unsigned char) ((*p >> 4) & 0xf);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ pixel=(unsigned char) ((*p) & 0xf);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
+ {
+ pixel=(unsigned char) (*p++ >> 4);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 8:
+ {
+ unsigned char
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ if (quantum_info->min_is_white != MagickFalse)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGray(image,ScaleCharToQuantum(pixel),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelGray(image,ScaleCharToQuantum(pixel),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
+ if (image->endian == LSBEndian)
{
- double
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
+ range),q);
+ q+=GetPixelChannels(image);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
+ range),q);
+ q+=GetPixelChannels(image);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+ range),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ if (x++ < (ssize_t) (number_pixels-1))
+ {
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
+ range),q);
+ q+=GetPixelChannels(image);
+ }
+ if (x++ < (ssize_t) number_pixels)
+ {
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
+ range),q);
+ q+=GetPixelChannels(image);
+ }
break;
}
- }
- default:
- {
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),
+ q);
+ q+=GetPixelChannels(image);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
+ q);
+ q+=GetPixelChannels(image);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
+ q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ if (x++ < (ssize_t) (number_pixels-1))
+ {
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+ range),q);
+ q+=GetPixelChannels(image);
+ }
+ if (x++ < (ssize_t) number_pixels)
+ {
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
+ range),q);
+ q+=GetPixelChannels(image);
+ }
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case GreenQuantum:
- case MagentaQuantum:
+ case 12:
{
- switch (quantum_info->depth)
- {
- case 8:
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- unsigned char
+ unsigned short
pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
{
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
- break;
- }
- case 16:
- {
- unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
+ if (bit != 0)
+ p++;
break;
}
- case 32:
- {
- unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ if (quantum_info->min_is_white != MagickFalse)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case BlueQuantum:
- case YellowQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ bit=0;
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ {
+ for (bit=0; bit < 8; bit+=2)
+ {
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
+ SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
+ TransparentAlpha : OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
+ }
+ p++;
+ }
+ if ((number_pixels % 4) != 0)
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
{
- unsigned int
- pixel;
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelGray(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
+ SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
+ TransparentAlpha : OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
+ }
+ if (bit != 0)
+ p++;
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned char) ((*p >> 4) & 0xf);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ pixel=(unsigned char) ((*p) & 0xf);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 8:
+ {
+ unsigned char
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelGray(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 12:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
+ float
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case AlphaQuantum:
+ case 64:
{
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
- {
- unsigned short
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned int
+ float
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ double
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case BlackQuantum:
+ }
+}
+
+static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ MagickBooleanType
+ range_exception;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ if (image->storage_class != PseudoClass)
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return;
+ }
+ range_exception=MagickFalse;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
{
- case 8:
- {
- unsigned char
- pixel;
+ for (bit=0; bit < 8; bit++)
+ {
+ if (quantum_info->min_is_white == MagickFalse)
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
+ 0x00 : 0x01);
+ else
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
+ 0x00 : 0x01);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
+ q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ q+=GetPixelChannels(image);
+ }
+ p++;
+ }
+ for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
+ {
+ if (quantum_info->min_is_white == MagickFalse)
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
+ else
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
+ {
+ pixel=(unsigned char) ((*p >> 4) & 0xf);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ q+=GetPixelChannels(image);
+ pixel=(unsigned char) ((*p) & 0xf);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
+ {
+ pixel=(unsigned char) ((*p++ >> 4) & 0xf);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
+ (double) QuantumRange*HalfToSinglePrecision(pixel)),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ float
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned int
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlack(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ }
+ default:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+ if (range_exception != MagickFalse)
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ "InvalidColormapIndex","`%s'",image->filename);
+}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlack(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+static void ImportIndexAlphaQuantum(const Image *image,
+ QuantumInfo *quantum_info,const MagickSizeType number_pixels,
+ const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
+{
+ MagickBooleanType
+ range_exception;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ if (image->storage_class != PseudoClass)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return;
+ }
+ range_exception=MagickFalse;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ {
+ for (bit=0; bit < 8; bit+=2)
+ {
+ if (quantum_info->min_is_white == MagickFalse)
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
+ else
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
+ SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
+ TransparentAlpha : OpaqueAlpha,q);
+ SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
+ q+=GetPixelChannels(image);
}
- default:
+ }
+ if ((number_pixels % 4) != 0)
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
+ {
+ if (quantum_info->min_is_white == MagickFalse)
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
+ else
+ pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
+ SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
+ SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
+ SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
+ TransparentAlpha : OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned char) ((*p >> 4) & 0xf);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ pixel=(unsigned char) ((*p) & 0xf);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
+ (double) QuantumRange*HalfToSinglePrecision(pixel)),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case RGBQuantum:
- case CbYCrQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,
+ ClampToQuantum(pixel),&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 10:
- {
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
- range),q);
- SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
- range),q);
- SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
- range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- if (quantum_info->quantum == 32U)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 12:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
- {
- unsigned short
- pixel;
+ double
+ pixel;
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
- {
- p=PushShortPixel(endian,p,&pixel);
- switch (x % 3)
- {
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
- }
- p=PushShortPixel(endian,p,&pixel);
- switch ((x+1) % 3)
- {
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
- }
- p+=quantum_info->pad;
- }
- for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
- {
- p=PushShortPixel(endian,p,&pixel);
- switch ((x+bit) % 3)
- {
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
- }
- p+=quantum_info->pad;
- }
- if (bit != 0)
- p++;
- break;
- }
- if (quantum_info->quantum == 32U)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
+ &range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
- {
- unsigned short
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ GetPixelIndex(image,q),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+ if (range_exception != MagickFalse)
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ "InvalidColormapIndex","`%s'",image->filename);
+}
+
+static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned int
+ float
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ double
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case RGBAQuantum:
- case RGBOQuantum:
- case CbYCrAQuantum:
+ }
+}
+
+static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- switch (quantum_info->depth)
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
- {
- unsigned char
- pixel;
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 10:
- {
- pixel=0;
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
-
- size_t
- quantum;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
- ssize_t
- n;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ float
+ pixel;
- n=0;
- quantum=0;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- p=PushLongPixel(endian,p,&pixel);
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 22) & 0x3ff) << 6)));
- break;
- }
- case 1:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 12) & 0x3ff) << 6)));
- break;
- }
- case 2:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 2) & 0x3ff) << 6)));
- break;
- }
- }
- switch (i)
- {
- case 0: SetPixelRed(image,(Quantum) quantum,q); break;
- case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
- case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
- case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
- }
- n++;
- }
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
- (pixel << 6)),q);
- q+=channels;
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned short
+ double
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
+ SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
+ q);
+ SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ if (quantum_info->quantum == 32U)
{
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
}
break;
}
- case CMYKQuantum:
+ case 12:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- unsigned char
+ unsigned short
pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ switch (x % 3)
+ {
+ default:
+ case 0:
+ {
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ break;
+ }
+ }
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ switch ((x+1) % 3)
+ {
+ default:
+ case 0:
+ {
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ break;
+ }
+ }
p+=quantum_info->pad;
- q+=channels;
}
- break;
- }
- case 16:
- {
- unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ switch ((x+bit) % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ break;
}
- break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
}
+ if (bit != 0)
+ p++;
break;
}
- case 32:
+ if (quantum_info->quantum == 32U)
{
- unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlack(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlack(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
}
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
+ float
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case CMYKAQuantum:
- case CMYKOQuantum:
+ case 64:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- unsigned char
+ double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 16:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
{
- unsigned short
- pixel;
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (n % 3)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
+ case 0:
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 22) & 0x3ff) << 6)));
+ break;
+ }
+ case 1:
+ {
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 12) & 0x3ff) << 6)));
+ break;
+ }
+ case 2:
+ {
+ quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+ (((pixel >> 2) & 0x3ff) << 6)));
+ break;
+ }
}
- break;
+ switch (i)
+ {
+ case 0: SetPixelRed(image,(Quantum) quantum,q); break;
+ case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
+ case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
+ case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
+ }
+ n++;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 32:
- {
- unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- float
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlack(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
- q+=channels;
+ q+=GetPixelChannels(image);
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlack(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(image->depth);
+ float
+ pixel;
+
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
- case CbYCrYQuantum:
+ case 64:
{
- switch (quantum_info->depth)
- {
- case 10:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- Quantum
- cbcr[4];
-
- pixel=0;
- if (quantum_info->pack == MagickFalse)
- {
- register ssize_t
- i;
-
- size_t
- quantum;
-
- ssize_t
- n;
+ double
+ pixel;
- n=0;
- quantum=0;
- for (x=0; x < (ssize_t) number_pixels; x+=2)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- p=PushLongPixel(endian,p,&pixel);
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 22) & 0x3ff) << 6)));
- break;
- }
- case 1:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 12) & 0x3ff) << 6)));
- break;
- }
- case 2:
- {
- quantum=(size_t) (ScaleShortToQuantum((unsigned short)
- (((pixel >> 2) & 0x3ff) << 6)));
- break;
- }
- }
- cbcr[i]=(Quantum) (quantum);
- n++;
- }
- p+=quantum_info->pad;
- SetPixelRed(image,cbcr[1],q);
- SetPixelGreen(image,cbcr[0],q);
- SetPixelBlue(image,cbcr[2],q);
- q+=channels;
- SetPixelRed(image,cbcr[3],q);
- SetPixelGreen(image,cbcr[0],q);
- SetPixelBlue(image,cbcr[2],q);
- q+=channels;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(image->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
}
break;
}
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
}
break;
}
+ }
+}
+
+MagickExport size_t ImportQuantumPixels(const Image *image,
+ CacheView *image_view,QuantumInfo *quantum_info,
+ const QuantumType quantum_type,const unsigned char *restrict pixels,
+ ExceptionInfo *exception)
+{
+ MagickSizeType
+ number_pixels;
+
+ register const unsigned char
+ *restrict p;
+
+ register ssize_t
+ x;
+
+ register Quantum
+ *restrict q;
+
+ size_t
+ extent;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ assert(quantum_info != (QuantumInfo *) NULL);
+ assert(quantum_info->signature == MagickSignature);
+ if (pixels == (const unsigned char *) NULL)
+ pixels=GetQuantumPixels(quantum_info);
+ x=0;
+ p=pixels;
+ if (image_view == (CacheView *) NULL)
+ {
+ number_pixels=GetImageExtent(image);
+ q=GetAuthenticPixelQueue(image);
+ }
+ else
+ {
+ number_pixels=GetCacheViewExtent(image_view);
+ q=GetCacheViewAuthenticPixelQueue(image_view);
+ }
+ ResetQuantumState(quantum_info);
+ extent=GetQuantumExtent(image,quantum_info,quantum_type);
+ switch (quantum_type)
+ {
+ case AlphaQuantum:
+ {
+ ImportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BGRQuantum:
+ {
+ ImportBGRQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BGRAQuantum:
+ case BGROQuantum:
+ {
+ ImportBGRAQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BlackQuantum:
+ {
+ ImportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ ImportBlueQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case CMYKQuantum:
+ {
+ ImportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case CMYKAQuantum:
+ case CMYKOQuantum:
+ {
+ ImportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case CbYCrYQuantum:
+ {
+ ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case GrayQuantum:
+ {
+ ImportGrayQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case GrayAlphaQuantum:
+ {
+ ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ ImportGreenQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case IndexQuantum:
+ {
+ ImportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case IndexAlphaQuantum:
+ {
+ ImportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ ImportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ ImportRedQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case RGBQuantum:
+ case CbYCrQuantum:
+ {
+ ImportRGBQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
+ case RGBAQuantum:
+ case RGBOQuantum:
+ case CbYCrAQuantum:
+ {
+ ImportRGBAQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
default:
break;
}
quantum=GetPixelRed(image,q);
SetPixelRed(image,GetPixelGreen(image,q),q);
SetPixelGreen(image,quantum,q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
}
if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
for (x=0; x < (ssize_t) number_pixels; x++)
{
SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
}
if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
{
- MagickRealType
- alpha;
+ double
+ gamma,
+ Sa;
register Quantum
*restrict q;
q=GetCacheViewAuthenticPixelQueue(image_view);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- alpha=QuantumScale*GetPixelAlpha(image,q);
- alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
- 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+=channels;
+ register ssize_t
+ i;
+
+ if (GetPixelReadMask(image,q) == 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ Sa=QuantumScale*GetPixelAlpha(image,q);
+ gamma=PerceptibleReciprocal(Sa);
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(gamma*q[i]);
+ }
+ q+=GetPixelChannels(image);
}
}
return(extent);
projects / imagemagick / blobdiff