#include "MagickCore/option.h"
#include "MagickCore/pixel.h"
#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/pixel-private.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
#include "MagickCore/resource_.h"
%
% The format of the ImportQuantumPixels method is:
%
-% size_t ImportQuantumPixels(Image *image,CacheView *image_view,
-% const QuantumInfo *quantum_info,const QuantumType quantum_type,
+% size_t ImportQuantumPixels(const Image *image,CacheView *image_view,
+% QuantumInfo *quantum_info,const QuantumType quantum_type,
% const unsigned char *pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
return((Quantum) 0);
}
-static inline const unsigned char *PushDoublePixel(
- const QuantumState *quantum_state,const unsigned char *pixels,double *pixel)
+static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
+ const unsigned char *pixels,double *pixel)
{
double
*p;
unsigned char
quantum[8];
- if (quantum_state->endian != LSBEndian)
+ if (quantum_info->endian != LSBEndian)
{
quantum[7]=(*pixels++);
quantum[6]=(*pixels++);
quantum[0]=(*pixels++);
p=(double *) quantum;
*pixel=(*p);
- *pixel-=quantum_state->minimum;
- *pixel*=quantum_state->scale;
+ *pixel-=quantum_info->minimum;
+ *pixel*=quantum_info->scale;
return(pixels);
}
quantum[0]=(*pixels++);
quantum[7]=(*pixels++);
p=(double *) quantum;
*pixel=(*p);
- *pixel-=quantum_state->minimum;
- *pixel*=quantum_state->scale;
+ *pixel-=quantum_info->minimum;
+ *pixel*=quantum_info->scale;
return(pixels);
}
-static inline const unsigned char *PushFloatPixel(
- const QuantumState *quantum_state,const unsigned char *pixels,float *pixel)
+static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info,
+ const unsigned char *pixels,float *pixel)
{
float
*p;
unsigned char
quantum[4];
- if (quantum_state->endian != LSBEndian)
+ if (quantum_info->endian != LSBEndian)
{
quantum[3]=(*pixels++);
quantum[2]=(*pixels++);
quantum[0]=(*pixels++);
p=(float *) quantum;
*pixel=(*p);
- *pixel-=quantum_state->minimum;
- *pixel*=quantum_state->scale;
+ *pixel-=quantum_info->minimum;
+ *pixel*=quantum_info->scale;
return(pixels);
}
quantum[0]=(*pixels++);
quantum[3]=(*pixels++);
p=(float *) quantum;
*pixel=(*p);
- *pixel-=quantum_state->minimum;
- *pixel*=quantum_state->scale;
+ *pixel-=quantum_info->minimum;
+ *pixel*=quantum_info->scale;
return(pixels);
}
-static inline const unsigned char *PushQuantumPixel(QuantumState *quantum_state, const size_t depth,const unsigned char *pixels,unsigned int *quantum)
+static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
+ const unsigned char *pixels,unsigned int *quantum)
{
register ssize_t
i;
quantum_bits;
*quantum=(QuantumAny) 0;
- for (i=(ssize_t) depth; i > 0L; )
+ for (i=(ssize_t) quantum_info->depth; i > 0L; )
{
- if (quantum_state->bits == 0UL)
+ if (quantum_info->state.bits == 0UL)
{
- quantum_state->pixel=(*pixels++);
- quantum_state->bits=8UL;
+ quantum_info->state.pixel=(*pixels++);
+ quantum_info->state.bits=8UL;
}
quantum_bits=(size_t) i;
- if (quantum_bits > quantum_state->bits)
- quantum_bits=quantum_state->bits;
+ if (quantum_bits > quantum_info->state.bits)
+ quantum_bits=quantum_info->state.bits;
i-=(ssize_t) quantum_bits;
- quantum_state->bits-=quantum_bits;
+ quantum_info->state.bits-=quantum_bits;
*quantum=(unsigned int) ((*quantum << quantum_bits) |
- ((quantum_state->pixel >> quantum_state->bits) &~ ((~0UL) <<
+ ((quantum_info->state.pixel >> quantum_info->state.bits) &~ ((~0UL) <<
quantum_bits)));
}
return(pixels);
}
static inline const unsigned char *PushQuantumLongPixel(
- QuantumState *quantum_state,const size_t depth,const unsigned char *pixels,
- unsigned int *quantum)
+ QuantumInfo *quantum_info,const unsigned char *pixels,unsigned int *quantum)
{
register ssize_t
i;
quantum_bits;
*quantum=0UL;
- for (i=(ssize_t) depth; i > 0; )
+ for (i=(ssize_t) quantum_info->depth; i > 0; )
{
- if (quantum_state->bits == 0)
+ if (quantum_info->state.bits == 0)
{
- pixels=PushLongPixel(quantum_state->endian,pixels,
- &quantum_state->pixel);
- quantum_state->bits=32U;
+ pixels=PushLongPixel(quantum_info->endian,pixels,
+ &quantum_info->state.pixel);
+ quantum_info->state.bits=32U;
}
quantum_bits=(size_t) i;
- if (quantum_bits > quantum_state->bits)
- quantum_bits=quantum_state->bits;
- *quantum|=(((quantum_state->pixel >> (32U-quantum_state->bits)) &
- quantum_state->mask[quantum_bits]) << (depth-i));
+ if (quantum_bits > quantum_info->state.bits)
+ quantum_bits=quantum_info->state.bits;
+ *quantum|=(((quantum_info->state.pixel >> (32U-quantum_info->state.bits)) &
+ quantum_info->state.mask[quantum_bits]) << (quantum_info->depth-i));
i-=(ssize_t) quantum_bits;
- quantum_state->bits-=quantum_bits;
+ quantum_info->state.bits-=quantum_bits;
}
return(pixels);
}
-static void ImportAlphaQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
-static void ImportBGRQuantum(const Image *image,const QuantumInfo *quantum_info,
- QuantumState quantum_state,const MagickSizeType number_pixels,
- const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
+static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
}
case 10:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
q);
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
case 12:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
unsigned short
for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
switch (x % 3)
{
default:
break;
}
}
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
switch ((x+1) % 3)
{
default:
}
for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
switch ((x+bit) % 3)
{
default:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
}
-static void ImportBGRAQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
case 0:
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
quantum=(size_t) (ScaleShortToQuantum((unsigned short)
(((pixel >> 22) & 0x3ff) << 6)));
break;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
q);
q+=GetPixelChannels(image);
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
}
-static void ImportBlackQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
+ "ColorSeparatedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
-static void ImportBlueQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
-static void ImportCbYCrYQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 10:
{
case 0:
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
quantum=(size_t) (ScaleShortToQuantum((unsigned short)
(((pixel >> 22) & 0x3ff) << 6)));
break;
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
}
-static void ImportCMYKQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
+ "ColorSeparatedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
}
-static void ImportCMYKAQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
if (image->colorspace != CMYKColorspace)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
+ "ColorSeparatedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlack(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
}
-static void ImportGrayQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 1:
white;
black=0;
- white=(Quantum) QuantumRange;
+ white=QuantumRange;
if (quantum_info->min_is_white != MagickFalse)
{
- black=(Quantum) QuantumRange;
+ black=QuantumRange;
white=0;
}
for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
register unsigned char
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
}
case 10:
{
- range=GetQuantumRange(image->depth);
+ 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(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
range),q);
q+=GetPixelChannels(image);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
if (x++ < (ssize_t) (number_pixels-1))
{
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
}
for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
q);
q+=GetPixelChannels(image);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
if (x++ < (ssize_t) (number_pixels-1))
{
SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
case 12:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
unsigned short
for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
q+=GetPixelChannels(image);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
p+=quantum_info->pad;
}
for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
range),q);
p+=quantum_info->pad;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
-static void ImportGrayAlphaQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 1:
register unsigned char
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
}
case 10:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
case 12:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGray(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGray(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGray(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
-static void ImportGreenQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
-static void ImportIndexQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
MagickBooleanType
range_exception;
if (image->storage_class != PseudoClass)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
+ "ColormappedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
range_exception=MagickFalse;
switch (quantum_info->depth)
{
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
- (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
+ (double) QuantumRange*HalfToSinglePrecision(pixel)),
&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
}
if (range_exception != MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
- "InvalidColormapIndex","`%s'",image->filename);
+ "InvalidColormapIndex","'%s'",image->filename);
}
static void ImportIndexAlphaQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ QuantumInfo *quantum_info,const MagickSizeType number_pixels,
+ const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
MagickBooleanType
range_exception;
if (image->storage_class != PseudoClass)
{
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
+ "ColormappedImageRequired","'%s'",image->filename);
return;
}
- endian=quantum_state.endian;
range_exception=MagickFalse;
switch (quantum_info->depth)
{
register unsigned char
pixel;
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
- (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
+ (double) QuantumRange*HalfToSinglePrecision(pixel)),
&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- 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);
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,
ClampToQuantum(pixel),&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
if (range_exception != MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
- "InvalidColormapIndex","`%s'",image->filename);
+ "InvalidColormapIndex","'%s'",image->filename);
}
-static void ImportOpacityQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelOpacity(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
}
-static void ImportRedQuantum(const Image *image,const QuantumInfo *quantum_info,
- QuantumState quantum_state,const MagickSizeType number_pixels,
- const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
+static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
}
-static void ImportRGBQuantum(const Image *image,const QuantumInfo *quantum_info,
- QuantumState quantum_state,const MagickSizeType number_pixels,
- const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
+static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
}
case 10:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
q);
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
case 12:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
if (quantum_info->pack == MagickFalse)
{
unsigned short
for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
switch (x % 3)
{
default:
break;
}
}
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
switch ((x+1) % 3)
{
default:
}
for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
switch ((x+bit) % 3)
{
default:
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumLongPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
}
-static void ImportRGBAQuantum(const Image *image,
- const QuantumInfo *quantum_info,QuantumState quantum_state,
+static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
- EndianType
- endian;
-
QuantumAny
range;
unsigned int
pixel;
- endian=quantum_state.endian;
switch (quantum_info->depth)
{
case 8:
{
case 0:
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
quantum=(size_t) (ScaleShortToQuantum((unsigned short)
(((pixel >> 22) & 0x3ff) << 6)));
break;
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
q);
q+=GetPixelChannels(image);
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*
HalfToSinglePrecision(pixel)),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
+ p=PushFloatPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelBlue(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
+ p=PushDoublePixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p+=quantum_info->pad;
q+=GetPixelChannels(image);
}
default:
{
- range=GetQuantumRange(image->depth);
+ range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
q+=GetPixelChannels(image);
}
}
}
-MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
- const QuantumInfo *quantum_info,const QuantumType quantum_type,
- const unsigned char *pixels,ExceptionInfo *exception)
+MagickExport size_t ImportQuantumPixels(const Image *image,
+ CacheView *image_view,QuantumInfo *quantum_info,
+ const QuantumType quantum_type,const unsigned char *pixels,
+ ExceptionInfo *exception)
{
MagickSizeType
number_pixels;
- QuantumState
- quantum_state;
-
register const unsigned char
*restrict p;
number_pixels=GetCacheViewExtent(image_view);
q=GetCacheViewAuthenticPixelQueue(image_view);
}
- InitializeQuantumState(quantum_info,image->endian,&quantum_state);
+ ResetQuantumState(quantum_info);
extent=GetQuantumExtent(image,quantum_info,quantum_type);
switch (quantum_type)
{
case AlphaQuantum:
{
- ImportAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case BGRQuantum:
{
- ImportBGRQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportBGRQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case BGRAQuantum:
case BGROQuantum:
{
- ImportBGRAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportBGRAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case BlackQuantum:
{
- ImportBlackQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- ImportBlueQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportBlueQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case CMYKQuantum:
{
- ImportCMYKQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case CMYKAQuantum:
case CMYKOQuantum:
{
- ImportCMYKAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case CbYCrYQuantum:
{
- ImportCbYCrYQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case GrayQuantum:
{
- ImportGrayQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportGrayQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case GrayAlphaQuantum:
{
- ImportGrayAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- ImportGreenQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportGreenQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case IndexQuantum:
{
- ImportIndexQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case IndexAlphaQuantum:
{
- ImportIndexAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,
- q,exception);
+ ImportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case OpacityQuantum:
{
- ImportOpacityQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case RedQuantum:
case CyanQuantum:
{
- ImportRedQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportRedQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case RGBQuantum:
case CbYCrQuantum:
{
- ImportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportRGBQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
case RGBAQuantum:
case RGBOQuantum:
case CbYCrAQuantum:
{
- ImportRGBAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
- exception);
+ ImportRGBAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
default:
}
if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
{
- MagickRealType
+ double
gamma,
Sa;
register ssize_t
i;
+ if (GetPixelMask(image,q) != 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
Sa=QuantumScale*GetPixelAlpha(image,q);
- gamma=1.0/(fabs(Sa) <= MagickEpsilon ? 1.0 : Sa);
+ gamma=MagickEpsilonReciprocal(Sa);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel
channel=GetPixelChannelMapChannel(image,i);
traits=GetPixelChannelMapTraits(image,channel);
- if ((traits & UpdatePixelTrait) != 0)
- q[i]=ClampToQuantum(gamma*q[i]);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(gamma*q[i]);
}
q+=GetPixelChannels(image);
}
projects / imagemagick / blobdiff