Google Git
Sign in
android / platform / external / ImageMagick / b6c094cecfe57a8dc87620ddbcf85f057f94d520 / . / MagickCore / quantum-import.c
blob: 9558d266e963872295ebd72860310bd5f22ce7e0 [file] [log] [blame]
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% QQQ U U AAA N N TTTTT U U M M %
% Q Q U U A A NN N T U U MM MM %
% Q Q U U AAAAA N N N T U U M M M %
% Q QQ U U A A N NN T U U M M %
% QQQQ UUU A A N N T UUU M M %
% %
% IIIII M M PPPP OOO RRRR TTTTT %
% I MM MM P P O O R R T %
% I M M M PPPP O O RRRR T %
% I M M P O O R R T %
% IIIII M M P OOO R R T %
% %
% MagickCore Methods to Import Quantum Pixels %
% %
% Software Design %
% Cristy %
% October 1998 %
% %
% %
% Copyright 1999-2021 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 %
% %
% https://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, %
% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
% See the License for the specific language governing permissions and %
% limitations under the License. %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
/*
Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/property.h"
#include "MagickCore/blob.h"
#include "MagickCore/blob-private.h"
#include "MagickCore/color-private.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-private.h"
#include "MagickCore/cache.h"
#include "MagickCore/constitute.h"
#include "MagickCore/delegate.h"
#include "MagickCore/geometry.h"
#include "MagickCore/list.h"
#include "MagickCore/magick.h"
#include "MagickCore/memory_.h"
#include "MagickCore/monitor.h"
#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"
#include "MagickCore/semaphore.h"
#include "MagickCore/statistic.h"
#include "MagickCore/stream.h"
#include "MagickCore/string_.h"
#include "MagickCore/utility.h"
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% I m p o r t Q u a n t u m P i x e l s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ImportQuantumPixels() transfers one or more pixel components from a user
% supplied buffer into the image pixel cache of an image. The pixels are
% expected in network byte order. It returns MagickTrue if the pixels are
% successfully transferred, otherwise MagickFalse.
%
% The format of the ImportQuantumPixels method is:
%
% size_t ImportQuantumPixels(const Image *image,CacheView *image_view,
% QuantumInfo *quantum_info,const QuantumType quantum_type,
% const unsigned char *magick_restrict pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o image_view: the image cache view.
%
% o quantum_info: the quantum info.
%
% o quantum_type: Declare which pixel components to transfer (red, green,
% blue, opacity, RGB, or RGBA).
%
% o pixels: The pixel components are transferred from this buffer.
%
% o exception: return any errors or warnings in this structure.
%
*/
static inline Quantum PushColormapIndex(const Image *image,const size_t index,
MagickBooleanType *range_exception)
{
if (index < image->colors)
return((Quantum) index);
*range_exception=MagickTrue;
return((Quantum) 0);
}
static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
const unsigned char *magick_restrict pixels,double *pixel)
{
double
*p;
unsigned char
quantum[8];
if (quantum_info->endian == LSBEndian)
{
quantum[0]=(*pixels++);
quantum[1]=(*pixels++);
quantum[2]=(*pixels++);
quantum[3]=(*pixels++);
quantum[4]=(*pixels++);
quantum[5]=(*pixels++);
quantum[6]=(*pixels++);
quantum[7]=(*pixels++);
}
else
{
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;
*pixel*=quantum_info->scale;
return(pixels);
}
static inline float ScaleFloatPixel(const QuantumInfo *quantum_info,
const unsigned char *quantum)
{
double
pixel;
pixel=(double) (*((float *) quantum));
pixel-=quantum_info->minimum;
pixel*=quantum_info->scale;
if (pixel < -FLT_MAX)
return(-FLT_MAX);
if (pixel > FLT_MAX)
return(FLT_MAX);
return(pixel);
}
static inline const unsigned char *PushQuantumFloatPixel(
const QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
float *pixel)
{
unsigned char
quantum[4];
if (quantum_info->endian == LSBEndian)
{
quantum[0]=(*pixels++);
quantum[1]=(*pixels++);
quantum[2]=(*pixels++);
quantum[3]=(*pixels++);
}
else
{
quantum[3]=(*pixels++);
quantum[2]=(*pixels++);
quantum[1]=(*pixels++);
quantum[0]=(*pixels++);
}
*pixel=ScaleFloatPixel(quantum_info,quantum);
return(pixels);
}
static inline const unsigned char *PushQuantumFloat24Pixel(
const QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
float *pixel)
{
unsigned char
quantum[4];
if (quantum_info->endian == LSBEndian)
{
quantum[0]=(*pixels++);
quantum[1]=(*pixels++);
quantum[2]=(*pixels++);
}
else
{
quantum[2]=(*pixels++);
quantum[1]=(*pixels++);
quantum[0]=(*pixels++);
}
if ((quantum[0] | quantum[1] | quantum[2]) == 0U)
quantum[3]=0;
else
{
unsigned char
exponent,
sign_bit;
sign_bit=(quantum[2] & 0x80);
exponent=(quantum[2] & 0x7F);
if (exponent != 0)
exponent=exponent-63+127;
quantum[3]=sign_bit | (exponent >> 1);
quantum[2]=((exponent & 1) << 7) | ((quantum[1] & 0xFE) >> 1);
quantum[1]=((quantum[1] & 0x01) << 7) | ((quantum[0] & 0xFE) >> 1);
quantum[0]=(quantum[0] & 0x01) << 7;
}
*pixel=ScaleFloatPixel(quantum_info,quantum);
return(pixels);
}
static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
const unsigned char *magick_restrict pixels,unsigned int *quantum)
{
ssize_t
i;
size_t
quantum_bits;
*quantum=(QuantumAny) 0;
for (i=(ssize_t) quantum_info->depth; i > 0L; )
{
if (quantum_info->state.bits == 0UL)
{
quantum_info->state.pixel=(*pixels++);
quantum_info->state.bits=8UL;
}
quantum_bits=(size_t) i;
if (quantum_bits > quantum_info->state.bits)
quantum_bits=quantum_info->state.bits;
i-=(ssize_t) quantum_bits;
quantum_info->state.bits-=quantum_bits;
*quantum=(unsigned int) ((*quantum << quantum_bits) |
((quantum_info->state.pixel >> quantum_info->state.bits) &~ ((~0UL) <<
quantum_bits)));
}
return(pixels);
}
static inline const unsigned char *PushQuantumLongPixel(
QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
unsigned int *quantum)
{
ssize_t
i;
size_t
quantum_bits;
*quantum=0UL;
for (i=(ssize_t) quantum_info->depth; i > 0; )
{
if (quantum_info->state.bits == 0)
{
pixels=PushLongPixel(quantum_info->endian,pixels,
&quantum_info->state.pixel);
quantum_info->state.bits=32U;
}
quantum_bits=(size_t) 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_info->state.bits-=quantum_bits;
}
return(pixels);
}
static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
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);
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);
SetPixelAlpha(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);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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 *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
ssize_t
bit;
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);
SetPixelAlpha(image,OpaqueAlpha,q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 10:
{
unsigned int
pixel;
range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
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+=GetPixelChannels(image);
}
break;
}
if (quantum_info->quantum == 32U)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
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);
}
break;
}
case 12:
{
range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
unsigned short
pixel;
for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
{
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;
}
for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
switch ((x+bit) % 3)
{
default:
case 0:
{
SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
break;
}
case 1:
{
SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
break;
}
case 2:
{
SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
q+=GetPixelChannels(image);
break;
}
}
p+=quantum_info->pad;
}
if (bit != 0)
p++;
break;
}
else
{
unsigned int
pixel;
if (quantum_info->quantum == 32U)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
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);
}
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+=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+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
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+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
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);
SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 10:
{
unsigned int
pixel;
pixel=0;
if (quantum_info->pack == MagickFalse)
{
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: SetPixelAlpha(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);
SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
q);
q+=GetPixelChannels(image);
}
break;
}
case 16:
{
unsigned short
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(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;
}
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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
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);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
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;
ssize_t
x;
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:
{
unsigned int
pixel;
pixel=0;
if (quantum_info->pack == MagickFalse)
{
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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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:
{
unsigned int
pixel;
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 *magick_restrict p,
Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
ssize_t
x;
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)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
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+=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);
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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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 *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
unsigned int
pixel;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 10:
{
Quantum
cbcr[4];
pixel=0;
if (quantum_info->pack == MagickFalse)
{
ssize_t
i;
size_t
quantum;
ssize_t
n;
n=0;
quantum=0;
for (x=0; x < (ssize_t) (number_pixels-3); x+=4)
{
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;
}
}
cbcr[i]=(Quantum) (quantum);
n++;
}
p+=quantum_info->pad;
SetPixelRed(image,cbcr[1],q);
SetPixelGreen(image,cbcr[0],q);
SetPixelBlue(image,cbcr[2],q);
q+=GetPixelChannels(image);
SetPixelRed(image,cbcr[3],q);
SetPixelGreen(image,cbcr[0],q);
SetPixelBlue(image,cbcr[2],q);
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
range=GetQuantumRange(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;
}
}
}
static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
ssize_t
x;
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)
{
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+=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+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
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+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
ssize_t
x;
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+=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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
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);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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 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;
ssize_t
x;
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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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 *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
ssize_t
bit;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 1:
{
Quantum
black,
white;
black=(Quantum) 0;
white=QuantumRange;
if (quantum_info->min_is_white != MagickFalse)
{
black=QuantumRange;
white=(Quantum) 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:
{
unsigned char
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;
if (quantum_info->min_is_white != MagickFalse)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
SetPixelGray(image,QuantumRange-ScaleCharToQuantum(pixel),q);
SetPixelAlpha(image,OpaqueAlpha,q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
SetPixelGray(image,ScaleCharToQuantum(pixel),q);
SetPixelAlpha(image,OpaqueAlpha,q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 10:
{
unsigned int
pixel;
pixel=0;
range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
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 >> 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+=GetPixelChannels(image);
}
if (x++ < (ssize_t) (number_pixels-1))
{
p=PushLongPixel(quantum_info->endian,p,&pixel);
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;
}
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+=GetPixelChannels(image);
}
if (x++ < (ssize_t) (number_pixels-1))
{
p=PushLongPixel(quantum_info->endian,p,&pixel);
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 12:
{
range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
unsigned short
pixel;
for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
{
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+=GetPixelChannels(image);
}
for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
if (bit != 0)
p++;
break;
}
else
{
unsigned int
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;
if (quantum_info->min_is_white != MagickFalse)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,QuantumRange-ScaleShortToQuantum(pixel),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(quantum_info->endian,p,&pixel);
SetPixelGray(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
if (quantum_info->format == SignedQuantumFormat)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
pixel=(unsigned short) (((unsigned int) pixel+32768) % 65536);
SetPixelGray(image,ScaleShortToQuantum(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);
SetPixelGray(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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 *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
ssize_t
bit;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
switch (quantum_info->depth)
{
case 1:
{
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)
{
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:
{
unsigned char
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=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:
{
unsigned int
pixel;
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:
{
unsigned int
pixel;
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=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+=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=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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 64:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
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+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
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);
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(quantum_info->endian,p,&pixel);
SetPixelGreen(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);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q,ExceptionInfo *exception)
{
MagickBooleanType
range_exception;
ssize_t
x;
ssize_t
bit;
if (image->storage_class != PseudoClass)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColormappedImageRequired","`%s'",image->filename);
return;
}
range_exception=MagickFalse;
switch (quantum_info->depth)
{
case 1:
{
unsigned char
pixel;
for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
{
for (bit=0; bit < 8; bit++)
{
if (quantum_info->min_is_white == MagickFalse)
pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
0x00 : 0x01);
else
pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
0x00 : 0x01);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
q);
SetPixelViaPixelInfo(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);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=GetPixelChannels(image);
}
break;
}
case 4:
{
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);
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);
SetPixelViaPixelInfo(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);
SetPixelViaPixelInfo(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);
SetPixelViaPixelInfo(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=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,(size_t)
ClampToQuantum((double) QuantumRange*
HalfToSinglePrecision(pixel)),&range_exception),q);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),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);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,(size_t)
ClampToQuantum(pixel),&range_exception),q);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,(size_t)
ClampToQuantum(pixel),&range_exception),q);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),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);
SetPixelIndex(image,PushColormapIndex(image,(size_t)
ClampToQuantum(pixel),&range_exception),q);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
SetPixelViaPixelInfo(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);
}
static void ImportIndexAlphaQuantum(const Image *image,
QuantumInfo *quantum_info,const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,Quantum *magick_restrict q,
ExceptionInfo *exception)
{
MagickBooleanType
range_exception;
QuantumAny
range;
ssize_t
x;
ssize_t
bit;
if (image->storage_class != PseudoClass)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColormappedImageRequired","`%s'",image->filename);
return;
}
range_exception=MagickFalse;
switch (quantum_info->depth)
{
case 1:
{
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);
}
}
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:
{
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);
SetPixelViaPixelInfo(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);
SetPixelViaPixelInfo(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)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,(size_t)
ClampToQuantum((double) QuantumRange*
HalfToSinglePrecision(pixel)),&range_exception),q);
SetPixelViaPixelInfo(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+=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);
SetPixelViaPixelInfo(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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,(size_t)
ClampToQuantum(pixel),&range_exception),q);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,(size_t)
ClampToQuantum(pixel),&range_exception),q);
SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
SetPixelViaPixelInfo(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)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,(size_t)
ClampToQuantum(pixel),&range_exception),q);
SetPixelViaPixelInfo(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;
}
}
default:
{
unsigned int
pixel;
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);
SetPixelViaPixelInfo(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 *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
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);
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);
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);
SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
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+=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+=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+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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)
{
double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
ssize_t
bit;
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);
SetPixelAlpha(image,OpaqueAlpha,q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 10:
{
unsigned int
pixel;
range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
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+=GetPixelChannels(image);
}
break;
}
if (quantum_info->quantum == 32U)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
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;
}
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 12:
{
range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
unsigned short
pixel;
for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
{
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;
}
for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
{
p=PushShortPixel(quantum_info->endian,p,&pixel);
switch ((x+bit) % 3)
{
default:
case 0:
{
SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
break;
}
case 1:
{
SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
break;
}
case 2:
{
SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
q+=GetPixelChannels(image);
break;
}
}
p+=quantum_info->pad;
}
if (bit != 0)
p++;
break;
}
else
{
unsigned int
pixel;
if (quantum_info->quantum == 32U)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
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;
}
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;
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;
}
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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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 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+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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 *magick_restrict p,
Quantum *magick_restrict q)
{
QuantumAny
range;
ssize_t
x;
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);
SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
case 10:
{
unsigned int
pixel;
pixel=0;
if (quantum_info->pack == MagickFalse)
{
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: SetPixelAlpha(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);
SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
q);
q+=GetPixelChannels(image);
}
break;
}
case 16:
{
unsigned short
pixel;
if (quantum_info->format == FloatingPointQuantumFormat)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushShortPixel(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;
}
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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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 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);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
default:
{
unsigned int
pixel;
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;
}
}
}
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;
ssize_t
x;
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:
{
unsigned int
pixel;
pixel=0;
if (quantum_info->pack == MagickFalse)
{
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 24:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
}
case 32:
{
if (quantum_info->format == FloatingPointQuantumFormat)
{
float
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p=PushQuantumFloatPixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
break;
}
else
{
unsigned int
pixel;
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:
{
unsigned int
pixel;
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 *magick_restrict pixels,
ExceptionInfo *exception)
{
MagickSizeType
number_pixels;
const unsigned char
*magick_restrict p;
ssize_t
x;
Quantum
*magick_restrict q;
size_t
extent;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(quantum_info != (QuantumInfo *) NULL);
assert(quantum_info->signature == MagickCoreSignature);
if (pixels == (const unsigned char *) NULL)
pixels=(const unsigned char *) 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);
break;
}
case BGRQuantum:
{
ImportBGRQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case BGRAQuantum:
{
ImportBGRAQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case BGROQuantum:
{
ImportBGROQuantum(image,quantum_info,number_pixels,p,q);
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);
break;
}
case CMYKQuantum:
{
ImportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case CMYKAQuantum:
{
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);
break;
}
case GrayQuantum:
{
ImportGrayQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case GrayAlphaQuantum:
{
ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
ImportGreenQuantum(image,quantum_info,number_pixels,p,q);
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);
break;
}
case RedQuantum:
case CyanQuantum:
{
ImportRedQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case RGBQuantum:
case CbYCrQuantum:
{
ImportRGBQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case RGBAQuantum:
case CbYCrAQuantum:
{
ImportRGBAQuantum(image,quantum_info,number_pixels,p,q);
break;
}
case RGBOQuantum:
{
ImportRGBOQuantum(image,quantum_info,number_pixels,p,q);
break;
}
default:
break;
}
if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
{
Quantum
quantum;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=GetCacheViewAuthenticPixelQueue(image_view);
for (x=0; x < (ssize_t) number_pixels; x++)
{
quantum=GetPixelRed(image,q);
SetPixelRed(image,GetPixelGreen(image,q),q);
SetPixelGreen(image,quantum,q);
q+=GetPixelChannels(image);
}
}
if (quantum_info->alpha_type == AssociatedQuantumAlpha)
{
double
gamma,
Sa;
/*
Disassociate alpha.
*/
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
q=GetCacheViewAuthenticPixelQueue(image_view);
for (x=0; x < (ssize_t) number_pixels; x++)
{
ssize_t
i;
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 ((channel == AlphaPixelChannel) ||
((traits & UpdatePixelTrait) == 0))
continue;
q[i]=ClampToQuantum(gamma*q[i]);
}
q+=GetPixelChannels(image);
}
}
return(extent);
}