|
|
/* |
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
|
|
% % |
|
|
% % |
|
|
% % |
|
|
% 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-2016 ImageMagick Studio LLC, a non-profit organization % |
|
|
% dedicated to making software imaging solutions freely available. % |
|
|
% % |
|
|
% You may not use this file except in compliance with the License. You may % |
|
|
% obtain a copy of the License at % |
|
|
% % |
|
|
% http://www.imagemagick.org/script/license.php % |
|
|
% % |
|
|
% 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++); |
|
|
p=(double *) quantum; |
|
|
*pixel=(*p); |
|
|
*pixel-=quantum_info->minimum; |
|
|
*pixel*=quantum_info->scale; |
|
|
return(pixels); |
|
|
} |
|
|
quantum[7]=(*pixels++); |
|
|
quantum[6]=(*pixels++); |
|
|
quantum[5]=(*pixels++); |
|
|
quantum[4]=(*pixels++); |
|
|
quantum[3]=(*pixels++); |
|
|
quantum[2]=(*pixels++); |
|
|
quantum[1]=(*pixels++); |
|
|
quantum[0]=(*pixels++); |
|
|
p=(double *) quantum; |
|
|
*pixel=(*p); |
|
|
*pixel-=quantum_info->minimum; |
|
|
*pixel*=quantum_info->scale; |
|
|
return(pixels); |
|
|
} |
|
|
|
|
|
static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info, |
|
|
const unsigned char *magick_restrict pixels,float *pixel) |
|
|
{ |
|
|
float |
|
|
*p; |
|
|
|
|
|
unsigned char |
|
|
quantum[4]; |
|
|
|
|
|
if (quantum_info->endian == LSBEndian) |
|
|
{ |
|
|
quantum[0]=(*pixels++); |
|
|
quantum[1]=(*pixels++); |
|
|
quantum[2]=(*pixels++); |
|
|
quantum[3]=(*pixels++); |
|
|
p=(float *) quantum; |
|
|
*pixel=(*p); |
|
|
*pixel-=quantum_info->minimum; |
|
|
*pixel*=quantum_info->scale; |
|
|
return(pixels); |
|
|
} |
|
|
quantum[3]=(*pixels++); |
|
|
quantum[2]=(*pixels++); |
|
|
quantum[1]=(*pixels++); |
|
|
quantum[0]=(*pixels++); |
|
|
p=(float *) quantum; |
|
|
*pixel=(*p); |
|
|
*pixel-=quantum_info->minimum; |
|
|
*pixel*=quantum_info->scale; |
|
|
return(pixels); |
|
|
} |
|
|
|
|
|
static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info, |
|
|
const unsigned char *magick_restrict pixels,unsigned int *quantum) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
register 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) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
register 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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelAlpha(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
ssize_t |
|
|
bit; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
SetPixelAlpha(image,OpaqueAlpha,q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 10: |
|
|
{ |
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
if (quantum_info->pack == MagickFalse) |
|
|
{ |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(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; |
|
|
} |
|
|
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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p+=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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelAlpha(image,ScaleCharToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 10: |
|
|
{ |
|
|
pixel=0; |
|
|
if (quantum_info->pack == MagickFalse) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
size_t |
|
|
quantum; |
|
|
|
|
|
ssize_t |
|
|
n; |
|
|
|
|
|
n=0; |
|
|
quantum=0; |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
for (i=0; i < 4; i++) |
|
|
{ |
|
|
switch (n % 3) |
|
|
{ |
|
|
case 0: |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 22) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
case 1: |
|
|
{ |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 12) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
case 2: |
|
|
{ |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 2) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
} |
|
|
switch (i) |
|
|
{ |
|
|
case 0: SetPixelRed(image,(Quantum) quantum,q); break; |
|
|
case 1: SetPixelGreen(image,(Quantum) quantum,q); break; |
|
|
case 2: SetPixelBlue(image,(Quantum) quantum,q); break; |
|
|
case 3: 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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelAlpha(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelOpacity(image,ScaleCharToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 10: |
|
|
{ |
|
|
pixel=0; |
|
|
if (quantum_info->pack == MagickFalse) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
size_t |
|
|
quantum; |
|
|
|
|
|
ssize_t |
|
|
n; |
|
|
|
|
|
n=0; |
|
|
quantum=0; |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
for (i=0; i < 4; i++) |
|
|
{ |
|
|
switch (n % 3) |
|
|
{ |
|
|
case 0: |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 22) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
case 1: |
|
|
{ |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 12) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
case 2: |
|
|
{ |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 2) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
} |
|
|
switch (i) |
|
|
{ |
|
|
case 0: SetPixelRed(image,(Quantum) quantum,q); break; |
|
|
case 1: SetPixelGreen(image,(Quantum) quantum,q); break; |
|
|
case 2: SetPixelBlue(image,(Quantum) quantum,q); break; |
|
|
case 3: SetPixelOpacity(image,(Quantum) quantum,q); break; |
|
|
} |
|
|
n++; |
|
|
} |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)), |
|
|
q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)), |
|
|
q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)), |
|
|
q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 16: |
|
|
{ |
|
|
unsigned short |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleShortToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleLongToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 64: |
|
|
{ |
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
double |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
default: |
|
|
{ |
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info, |
|
|
const MagickSizeType number_pixels,const unsigned char *magick_restrict p, |
|
|
Quantum *magick_restrict q,ExceptionInfo *exception) |
|
|
{ |
|
|
QuantumAny |
|
|
range; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (image->colorspace != CMYKColorspace) |
|
|
{ |
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError, |
|
|
"ColorSeparatedImageRequired","`%s'",image->filename); |
|
|
return; |
|
|
} |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlack(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p+=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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register 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) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
size_t |
|
|
quantum; |
|
|
|
|
|
ssize_t |
|
|
n; |
|
|
|
|
|
n=0; |
|
|
quantum=0; |
|
|
for (x=0; x < (ssize_t) number_pixels; 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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (image->colorspace != CMYKColorspace) |
|
|
{ |
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError, |
|
|
"ColorSeparatedImageRequired","`%s'",image->filename); |
|
|
return; |
|
|
} |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlack(image,ScaleCharToQuantum(pixel),q); |
|
|
p+=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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlack(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlack(image,ScaleLongToQuantum(pixel),q); |
|
|
p+=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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (image->colorspace != CMYKColorspace) |
|
|
{ |
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError, |
|
|
"ColorSeparatedImageRequired","`%s'",image->filename); |
|
|
return; |
|
|
} |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlack(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlack(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelAlpha(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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=PushDoublePixel(quantum_info,p,&pixel); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
default: |
|
|
{ |
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (image->colorspace != CMYKColorspace) |
|
|
{ |
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError, |
|
|
"ColorSeparatedImageRequired","`%s'",image->filename); |
|
|
return; |
|
|
} |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlack(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelOpacity(image,ScaleCharToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 16: |
|
|
{ |
|
|
unsigned short |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlack(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlack(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleShortToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlack(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlack(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleLongToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 64: |
|
|
{ |
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
double |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelBlack(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
default: |
|
|
{ |
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info, |
|
|
const MagickSizeType number_pixels,const unsigned char *magick_restrict p, |
|
|
Quantum *magick_restrict q) |
|
|
{ |
|
|
QuantumAny |
|
|
range; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
ssize_t |
|
|
bit; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
pixel=0; |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 1: |
|
|
{ |
|
|
register Quantum |
|
|
black, |
|
|
white; |
|
|
|
|
|
black=0; |
|
|
white=QuantumRange; |
|
|
if (quantum_info->min_is_white != MagickFalse) |
|
|
{ |
|
|
black=QuantumRange; |
|
|
white=0; |
|
|
} |
|
|
for (x=0; x < ((ssize_t) number_pixels-7); x+=8) |
|
|
{ |
|
|
for (bit=0; bit < 8; bit++) |
|
|
{ |
|
|
SetPixelGray(image,((*p) & (1 << (7-bit))) == 0 ? black : white,q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
p++; |
|
|
} |
|
|
for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++) |
|
|
{ |
|
|
SetPixelGray(image,((*p) & (0x01 << (7-bit))) == 0 ? black : white,q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
if (bit != 0) |
|
|
p++; |
|
|
break; |
|
|
} |
|
|
case 4: |
|
|
{ |
|
|
register unsigned char |
|
|
pixel; |
|
|
|
|
|
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,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: |
|
|
{ |
|
|
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); |
|
|
} |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
if (x++ < (ssize_t) (number_pixels-1)) |
|
|
{ |
|
|
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff, |
|
|
range),q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
if (x++ < (ssize_t) number_pixels) |
|
|
{ |
|
|
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff, |
|
|
range),q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
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); |
|
|
} |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
if (x++ < (ssize_t) (number_pixels-1)) |
|
|
{ |
|
|
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff, |
|
|
range),q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
if (x++ < (ssize_t) number_pixels) |
|
|
{ |
|
|
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff, |
|
|
range),q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 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; |
|
|
} |
|
|
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,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; |
|
|
} |
|
|
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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGray(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
ssize_t |
|
|
bit; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 1: |
|
|
{ |
|
|
register unsigned char |
|
|
pixel; |
|
|
|
|
|
bit=0; |
|
|
for (x=((ssize_t) number_pixels-3); x > 0; x-=4) |
|
|
{ |
|
|
for (bit=0; bit < 8; bit+=2) |
|
|
{ |
|
|
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: |
|
|
{ |
|
|
register 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: |
|
|
{ |
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 12: |
|
|
{ |
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 16: |
|
|
{ |
|
|
unsigned short |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGray(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelAlpha(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
ssize_t |
|
|
bit; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (image->storage_class != PseudoClass) |
|
|
{ |
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError, |
|
|
"ColormappedImageRequired","`%s'",image->filename); |
|
|
return; |
|
|
} |
|
|
range_exception=MagickFalse; |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 1: |
|
|
{ |
|
|
register unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=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: |
|
|
{ |
|
|
register unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < ((ssize_t) number_pixels-1); x+=2) |
|
|
{ |
|
|
pixel=(unsigned char) ((*p >> 4) & 0xf); |
|
|
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q); |
|
|
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,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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(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=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,ClampToQuantum(pixel), |
|
|
&range_exception),q); |
|
|
SetPixelViaPixelInfo(image,image->colormap+(ssize_t) |
|
|
GetPixelIndex(image,q),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
default: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
ssize_t |
|
|
bit; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (image->storage_class != PseudoClass) |
|
|
{ |
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError, |
|
|
"ColormappedImageRequired","`%s'",image->filename); |
|
|
return; |
|
|
} |
|
|
range_exception=MagickFalse; |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 1: |
|
|
{ |
|
|
register unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=((ssize_t) number_pixels-3); x > 0; x-=4) |
|
|
{ |
|
|
for (bit=0; bit < 8; bit+=2) |
|
|
{ |
|
|
if (quantum_info->min_is_white == MagickFalse) |
|
|
pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01); |
|
|
else |
|
|
pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01); |
|
|
SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q); |
|
|
SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ? |
|
|
TransparentAlpha : OpaqueAlpha,q); |
|
|
SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
} |
|
|
if ((number_pixels % 4) != 0) |
|
|
for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2) |
|
|
{ |
|
|
if (quantum_info->min_is_white == MagickFalse) |
|
|
pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01); |
|
|
else |
|
|
pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01); |
|
|
SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q); |
|
|
SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q); |
|
|
SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ? |
|
|
TransparentAlpha : OpaqueAlpha,q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 4: |
|
|
{ |
|
|
register unsigned char |
|
|
pixel; |
|
|
|
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
pixel=(unsigned char) ((*p >> 4) & 0xf); |
|
|
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q); |
|
|
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,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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelIndex(image,PushColormapIndex(image, |
|
|
ClampToQuantum(pixel),&range_exception),q); |
|
|
SetPixelViaPixelInfo(image,image->colormap+(ssize_t) |
|
|
GetPixelIndex(image,q),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelAlpha(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
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,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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p+=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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p+=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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
ssize_t |
|
|
bit; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
SetPixelAlpha(image,OpaqueAlpha,q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 10: |
|
|
{ |
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
if (quantum_info->pack == MagickFalse) |
|
|
{ |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(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; |
|
|
} |
|
|
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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleLongToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelAlpha(image,ScaleCharToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 10: |
|
|
{ |
|
|
pixel=0; |
|
|
if (quantum_info->pack == MagickFalse) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
size_t |
|
|
quantum; |
|
|
|
|
|
ssize_t |
|
|
n; |
|
|
|
|
|
n=0; |
|
|
quantum=0; |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
for (i=0; i < 4; i++) |
|
|
{ |
|
|
switch (n % 3) |
|
|
{ |
|
|
case 0: |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 22) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
case 1: |
|
|
{ |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 12) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
case 2: |
|
|
{ |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 2) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
} |
|
|
switch (i) |
|
|
{ |
|
|
case 0: SetPixelRed(image,(Quantum) quantum,q); break; |
|
|
case 1: SetPixelGreen(image,(Quantum) quantum,q); break; |
|
|
case 2: SetPixelBlue(image,(Quantum) quantum,q); break; |
|
|
case 3: 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 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelAlpha(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelAlpha(image,ScaleLongToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 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: |
|
|
{ |
|
|
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; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
assert(image != (Image *) NULL); |
|
|
assert(image->signature == MagickCoreSignature); |
|
|
switch (quantum_info->depth) |
|
|
{ |
|
|
case 8: |
|
|
{ |
|
|
unsigned char |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelRed(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelGreen(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelBlue(image,ScaleCharToQuantum(pixel),q); |
|
|
p=PushCharPixel(p,&pixel); |
|
|
SetPixelOpacity(image,ScaleCharToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 10: |
|
|
{ |
|
|
pixel=0; |
|
|
if (quantum_info->pack == MagickFalse) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
size_t |
|
|
quantum; |
|
|
|
|
|
ssize_t |
|
|
n; |
|
|
|
|
|
n=0; |
|
|
quantum=0; |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
for (i=0; i < 4; i++) |
|
|
{ |
|
|
switch (n % 3) |
|
|
{ |
|
|
case 0: |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 22) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
case 1: |
|
|
{ |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 12) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
case 2: |
|
|
{ |
|
|
quantum=(size_t) (ScaleShortToQuantum((unsigned short) |
|
|
(((pixel >> 2) & 0x3ff) << 6))); |
|
|
break; |
|
|
} |
|
|
} |
|
|
switch (i) |
|
|
{ |
|
|
case 0: SetPixelRed(image,(Quantum) quantum,q); break; |
|
|
case 1: SetPixelGreen(image,(Quantum) quantum,q); break; |
|
|
case 2: SetPixelBlue(image,(Quantum) quantum,q); break; |
|
|
case 3: SetPixelOpacity(image,(Quantum) quantum,q); break; |
|
|
} |
|
|
n++; |
|
|
} |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)), |
|
|
q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)), |
|
|
q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)), |
|
|
q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 16: |
|
|
{ |
|
|
unsigned short |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(QuantumRange* |
|
|
HalfToSinglePrecision(pixel)),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleShortToQuantum(pixel),q); |
|
|
p=PushShortPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleShortToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 32: |
|
|
{ |
|
|
unsigned int |
|
|
pixel; |
|
|
|
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
float |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushFloatPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelRed(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelGreen(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelBlue(image,ScaleLongToQuantum(pixel),q); |
|
|
p=PushLongPixel(quantum_info->endian,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleLongToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 64: |
|
|
{ |
|
|
if (quantum_info->format == FloatingPointQuantumFormat) |
|
|
{ |
|
|
double |
|
|
pixel; |
|
|
|
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ClampToQuantum(pixel),q); |
|
|
p=PushDoublePixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ClampToQuantum(pixel),q); |
|
|
p+=quantum_info->pad; |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
default: |
|
|
{ |
|
|
range=GetQuantumRange(quantum_info->depth); |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
p=PushQuantumPixel(quantum_info,p,&pixel); |
|
|
SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q); |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
MagickExport size_t ImportQuantumPixels(const Image *image, |
|
|
CacheView *image_view,QuantumInfo *quantum_info, |
|
|
const QuantumType quantum_type,const unsigned char *magick_restrict pixels, |
|
|
ExceptionInfo *exception) |
|
|
{ |
|
|
MagickSizeType |
|
|
number_pixels; |
|
|
|
|
|
register const unsigned char |
|
|
*magick_restrict p; |
|
|
|
|
|
register ssize_t |
|
|
x; |
|
|
|
|
|
register 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; |
|
|
|
|
|
register Quantum |
|
|
*magick_restrict q; |
|
|
|
|
|
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 == DisassociatedQuantumAlpha) |
|
|
{ |
|
|
double |
|
|
gamma, |
|
|
Sa; |
|
|
|
|
|
register Quantum |
|
|
*magick_restrict q; |
|
|
|
|
|
/* |
|
|
Disassociate alpha. |
|
|
*/ |
|
|
q=GetAuthenticPixelQueue(image); |
|
|
if (image_view != (CacheView *) NULL) |
|
|
q=GetCacheViewAuthenticPixelQueue(image_view); |
|
|
for (x=0; x < (ssize_t) number_pixels; x++) |
|
|
{ |
|
|
register ssize_t |
|
|
i; |
|
|
|
|
|
if (GetPixelReadMask(image,q) == 0) |
|
|
{ |
|
|
q+=GetPixelChannels(image); |
|
|
continue; |
|
|
} |
|
|
Sa=QuantumScale*GetPixelAlpha(image,q); |
|
|
gamma=PerceptibleReciprocal(Sa); |
|
|
for (i=0; i < (ssize_t) GetPixelChannels(image); i++) |
|
|
{ |
|
|
PixelChannel channel=GetPixelChannelChannel(image,i); |
|
|
PixelTrait traits=GetPixelChannelTraits(image,channel); |
|
|
if ((channel == AlphaPixelChannel) || |
|
|
((traits & UpdatePixelTrait) == 0)) |
|
|
continue; |
|
|
q[i]=ClampToQuantum(gamma*q[i]); |
|
|
} |
|
|
q+=GetPixelChannels(image); |
|
|
} |
|
|
} |
|
|
return(extent); |
|
|
}
|
|
|
|
