return(pixels);
}
+static void ExportRGBQuantum(Image *image,const QuantumInfo *quantum_info,
+ QuantumState quantum_state,const MagickSizeType number_pixels,
+ const Quantum *restrict p,unsigned char *restrict q)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register size_t
+ x;
+
+ ssize_t
+ bit;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) (
+ ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
+ ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
+ ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ switch (x % 3)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ p+=GetPixelChannels(image);
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ switch ((x+1) % 3)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ p+=GetPixelChannels(image);
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q+=quantum_info->pad;
+ }
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ switch ((x+bit) % 3)
+ {
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
+ }
+ case 1:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ p+=GetPixelChannels(image);
+ break;
+ }
+ }
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q+=quantum_info->pad;
+ }
+ if (bit != 0)
+ p+=GetPixelChannels(image);
+ break;
+ }
+ if (quantum_info->quantum == 32UL)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register unsigned int
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
const QuantumInfo *quantum_info,const QuantumType quantum_type,
unsigned char *pixels,ExceptionInfo *exception)
case RGBQuantum:
case CbYCrQuantum:
{
- switch (quantum_info->depth)
- {
- case 8:
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 10:
- {
- register unsigned int
- pixel;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) (
- ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
- ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
- ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 12:
- {
- register unsigned int
- pixel;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
- {
- switch (x % 3)
- {
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
- }
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- switch ((x+1) % 3)
- {
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
- }
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
- {
- switch ((x+bit) % 3)
- {
- default:
- case 0:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelRed(image,p),range);
- break;
- }
- case 1:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelGreen(image,p),range);
- break;
- }
- case 2:
- {
- pixel=(unsigned int) ScaleQuantumToAny(
- GetPixelBlue(image,p),range);
- p+=channels;
- break;
- }
- }
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- if (bit != 0)
- p+=channels;
- break;
- }
- if (quantum_info->quantum == 32UL)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
+ ExportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q);
break;
}
case RGBAQuantum:
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(QuantumState *quantum_state, const size_t depth,const unsigned char *pixels,unsigned int *quantum)
{
register ssize_t
i;
}
static inline const unsigned char *PushQuantumLongPixel(
- QuantumState *quantum_state,const size_t depth,
- const unsigned char *pixels,unsigned int *quantum)
+ QuantumState *quantum_state,const size_t depth,const unsigned char *pixels,
+ unsigned int *quantum)
{
register ssize_t
i;
return(pixels);
}
+static void ImportRGBQuantum(Image *image,const QuantumInfo *quantum_info,
+ QuantumState quantum_state,const MagickSizeType number_pixels,
+ const unsigned char *restrict p,Quantum *restrict q)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register size_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ endian=quantum_state.endian;
+ 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(image->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
+ SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
+ q);
+ SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ if (quantum_info->quantum == 32U)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 12:
+ {
+ range=GetQuantumRange(image->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ unsigned short
+ pixel;
+
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ switch (x % 3)
+ {
+ default:
+ case 0:
+ {
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ break;
+ }
+ }
+ p=PushShortPixel(endian,p,&pixel);
+ switch ((x+1) % 3)
+ {
+ default:
+ case 0:
+ {
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=GetPixelChannels(image);
+ break;
+ }
+ }
+ p+=quantum_info->pad;
+ }
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ switch ((x+bit) % 3)
+ {
+ default:
+ case 0:
+ {
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 1:
+ {
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
+ range),q);
+ q+=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_state,image->depth,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p+=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_state,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(&quantum_state,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p+=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_state,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(&quantum_state,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(image->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
const QuantumInfo *quantum_info,const QuantumType quantum_type,
const unsigned char *pixels,ExceptionInfo *exception)
case RGBQuantum:
case CbYCrQuantum:
{
- 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+=channels;
- }
- break;
- }
- case 10:
- {
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
- range),q);
- SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
- range),q);
- SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
- range),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- if (quantum_info->quantum == 32U)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- case 12:
- {
- range=GetQuantumRange(image->depth);
- if (quantum_info->pack == MagickFalse)
- {
- unsigned short
- pixel;
-
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
- {
- p=PushShortPixel(endian,p,&pixel);
- switch (x % 3)
- {
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
- }
- p=PushShortPixel(endian,p,&pixel);
- switch ((x+1) % 3)
- {
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
- }
- p+=quantum_info->pad;
- }
- for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
- {
- p=PushShortPixel(endian,p,&pixel);
- switch ((x+bit) % 3)
- {
- default:
- case 0:
- {
- SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 1:
- {
- SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
- (pixel >> 4),range),q);
- q+=channels;
- break;
- }
- }
- p+=quantum_info->pad;
- }
- if (bit != 0)
- p++;
- break;
- }
- if (quantum_info->quantum == 32U)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- case 16:
- {
- unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*HalfToSinglePrecision(pixel)),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushShortPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- 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_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushFloatPixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushLongPixel(endian,p,&pixel);
- SetPixelRed(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
- p=PushLongPixel(endian,p,&pixel);
- SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelRed(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelGreen(image,ClampToQuantum(pixel),q);
- p=PushDoublePixel(&quantum_state,p,&pixel);
- SetPixelBlue(image,ClampToQuantum(pixel),q);
- p+=quantum_info->pad;
- q+=channels;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(image->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
- p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
- q+=channels;
- }
- break;
- }
- }
+ ImportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q);
break;
}
case RGBAQuantum:
projects / imagemagick / commitdiff