% 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-2017 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 %
% obtain a copy of the License at %
% %
-% http://www.imagemagick.org/script/license.php %
+% https://www.imagemagick.org/script/license.php %
% %
% Unless required by applicable law or agreed to in writing, software %
% distributed under the License is distributed on an "AS IS" BASIS, %
%
% size_t ImportQuantumPixels(const Image *image,CacheView *image_view,
% QuantumInfo *quantum_info,const QuantumType quantum_type,
-% const unsigned char *pixels,ExceptionInfo *exception)
+% const unsigned char *magick_restrict pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
}
static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
- const unsigned char *pixels,double *pixel)
+ const unsigned char *magick_restrict pixels,double *pixel)
{
double
*p;
unsigned char
quantum[8];
- if (quantum_info->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_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_info->minimum;
}
static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info,
- const unsigned char *pixels,float *pixel)
+ const unsigned char *magick_restrict pixels,float *pixel)
{
float
*p;
unsigned char
quantum[4];
- if (quantum_info->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_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_info->minimum;
}
static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
- const unsigned char *pixels,unsigned int *quantum)
+ const unsigned char *magick_restrict pixels,unsigned int *quantum)
{
register ssize_t
i;
}
static inline const unsigned char *PushQuantumLongPixel(
- QuantumInfo *quantum_info,const unsigned char *pixels,unsigned int *quantum)
+ QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
+ unsigned int *quantum)
{
register ssize_t
i;
}
static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
+static void ImportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
+ 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);
+ SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
+ {
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (n % 3)
+ {
+ case 0:
+ {
+ p=PushLongPixel(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;
+ }
+ }
+ 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: SetPixelOpacity(image,(Quantum) quantum,q); 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);
+ SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(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);
+ SetPixelOpacity(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=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);
+ SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ float
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushFloatPixel(quantum_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);
+ SetPixelOpacity(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);
+ 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);
+ SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ double
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushDoublePixel(quantum_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);
+ 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);
+ 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);
+ SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","'%s'",image->filename);
+ "ColorSeparatedImageRequired","`%s'",image->filename);
return;
}
switch (quantum_info->depth)
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 10:
n=0;
quantum=0;
- for (x=0; x < (ssize_t) number_pixels; x+=2)
+ for (x=0; x < (ssize_t) number_pixels; x+=4)
{
for (i=0; i < 4; i++)
{
}
static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","'%s'",image->filename);
+ "ColorSeparatedImageRequired","`%s'",image->filename);
return;
}
switch (quantum_info->depth)
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","'%s'",image->filename);
+ "ColorSeparatedImageRequired","`%s'",image->filename);
return;
}
switch (quantum_info->depth)
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
+static void ImportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_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);
+ 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);
+ 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(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);
+ SetPixelOpacity(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);
+ 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);
+ SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ float
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushFloatPixel(quantum_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);
+ SetPixelOpacity(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);
+ SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ 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)
+ {
+ double
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ 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);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ 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);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(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)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
+ pixel=0;
switch (quantum_info->depth)
{
case 1:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- SetPixelGray(image,ScaleCharToQuantum(pixel),q);
+ SetPixelGray(image,QuantumRange-ScaleCharToQuantum(pixel),q);
SetPixelAlpha(image,OpaqueAlpha,q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
- if (image->endian != LSBEndian)
+ if (image->endian == LSBEndian)
{
for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
p=PushLongPixel(quantum_info->endian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+ 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 >> 22) & 0x3ff,
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
p=PushLongPixel(quantum_info->endian,p,&pixel);
if (x++ < (ssize_t) (number_pixels-1))
{
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
range),q);
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
p=PushLongPixel(quantum_info->endian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
+ 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 >> 2) & 0x3ff,range),
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
q);
p+=quantum_info->pad;
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);
+ 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);
+ SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
+ range),q);
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGray(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
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)
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGray(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
MagickBooleanType
range_exception;
if (image->storage_class != PseudoClass)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","'%s'",image->filename);
+ "ColormappedImageRequired","`%s'",image->filename);
return;
}
range_exception=MagickFalse;
0x00 : 0x01);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=GetPixelChannels(image);
}
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)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=GetPixelChannels(image);
}
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(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)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p++;
q+=GetPixelChannels(image);
{
pixel=(unsigned char) ((*p++ >> 4) & 0xf);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=GetPixelChannels(image);
}
{
p=PushCharPixel(p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
- (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
+ (double) QuantumRange*HalfToSinglePrecision(pixel)),
&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
{
p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
{
p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
if (range_exception != MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
- "InvalidColormapIndex","'%s'",image->filename);
+ "InvalidColormapIndex","`%s'",image->filename);
}
static void ImportIndexAlphaQuantum(const Image *image,
QuantumInfo *quantum_info,const MagickSizeType number_pixels,
- const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
+ const unsigned char *magick_restrict p,Quantum *magick_restrict q,
+ ExceptionInfo *exception)
{
MagickBooleanType
range_exception;
if (image->storage_class != PseudoClass)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","'%s'",image->filename);
+ "ColormappedImageRequired","`%s'",image->filename);
return;
}
range_exception=MagickFalse;
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
pixel=(unsigned char) ((*p) & 0xf);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
{
p=PushCharPixel(p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushCharPixel(p,&pixel);
SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
- (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
+ (double) QuantumRange*HalfToSinglePrecision(pixel)),
&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(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)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
{
p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(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)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
{
p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
- SetPixelInfoPixel(image,image->colormap+(ssize_t)
+ SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
}
if (range_exception != MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
- "InvalidColormapIndex","'%s'",image->filename);
+ "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)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelOpacity(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelOpacity(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
}
+
static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
{
QuantumAny
range;
unsigned int
pixel;
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 8:
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p=PushShortPixel(quantum_info->endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
+static void ImportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickCoreSignature);
+ 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);
+ SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
+ {
+ register ssize_t
+ i;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ n=0;
+ quantum=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (n % 3)
+ {
+ case 0:
+ {
+ p=PushLongPixel(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;
+ }
+ }
+ 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: SetPixelOpacity(image,(Quantum) quantum,q); 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);
+ SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(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);
+ SetPixelOpacity(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);
+ 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);
+ SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ float
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushFloatPixel(quantum_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);
+ SetPixelOpacity(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);
+ SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ double
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushDoublePixel(quantum_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);
+ 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);
+ 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);
+ SetPixelOpacity(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 *pixels,
+ const QuantumType quantum_type,const unsigned char *magick_restrict pixels,
ExceptionInfo *exception)
{
MagickSizeType
number_pixels;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
size_t
extent;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(quantum_info != (QuantumInfo *) NULL);
- assert(quantum_info->signature == MagickSignature);
+ assert(quantum_info->signature == MagickCoreSignature);
if (pixels == (const unsigned char *) NULL)
- pixels=GetQuantumPixels(quantum_info);
+ pixels=(const unsigned char *) GetQuantumPixels(quantum_info);
x=0;
p=pixels;
if (image_view == (CacheView *) NULL)
{
case AlphaQuantum:
{
- ImportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportAlphaQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case BGRQuantum:
{
- ImportBGRQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportBGRQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case BGRAQuantum:
+ {
+ ImportBGRAQuantum(image,quantum_info,number_pixels,p,q);
+ break;
+ }
case BGROQuantum:
{
- ImportBGRAQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportBGROQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case BlackQuantum:
case BlueQuantum:
case YellowQuantum:
{
- ImportBlueQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportBlueQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case CMYKQuantum:
break;
}
case CMYKAQuantum:
- case CMYKOQuantum:
{
ImportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
+ case CMYKOQuantum:
+ {
+ ImportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
case CbYCrYQuantum:
{
- ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case GrayQuantum:
{
- ImportGrayQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportGrayQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case GrayAlphaQuantum:
{
- ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- ImportGreenQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportGreenQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case IndexQuantum:
}
case OpacityQuantum:
{
- ImportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportOpacityQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case RedQuantum:
case CyanQuantum:
{
- ImportRedQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportRedQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case RGBQuantum:
case CbYCrQuantum:
{
- ImportRGBQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportRGBQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case RGBAQuantum:
- case RGBOQuantum:
case CbYCrAQuantum:
{
- ImportRGBAQuantum(image,quantum_info,number_pixels,p,q,exception);
+ ImportRGBAQuantum(image,quantum_info,number_pixels,p,q);
+ break;
+ }
+ case RGBOQuantum:
+ {
+ ImportRGBOQuantum(image,quantum_info,number_pixels,p,q);
break;
}
default:
quantum;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q+=GetPixelChannels(image);
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
- {
- register Quantum
- *restrict q;
-
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
- }
- }
if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
{
- MagickRealType
+ double
gamma,
Sa;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Disassociate alpha.
register ssize_t
i;
- if (GetPixelMask(image,q) != 0)
+ if (GetPixelWriteMask(image,q) == 0)
{
q+=GetPixelChannels(image);
continue;
}
Sa=QuantumScale*GetPixelAlpha(image,q);
- gamma=MagickEpsilonReciprocal(Sa);
+ gamma=PerceptibleReciprocal(Sa);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- PixelChannel
- channel;
-
- PixelTrait
- traits;
-
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
- if ((traits & UpdatePixelTrait) == 0)
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((channel == AlphaPixelChannel) ||
+ ((traits & UpdatePixelTrait) == 0))
continue;
q[i]=ClampToQuantum(gamma*q[i]);
}
projects / imagemagick / blobdiff