% o exception: return any errors or warnings in this structure.
%
*/
-MagickExport MagickBooleanType ExportImagePixels(const Image *image,
- const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
- const size_t rows,const char *map,const StorageType type,void *pixels,
- ExceptionInfo *exception)
+
+static void ExportCharPixel(const Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ unsigned char *restrict pixels,ExceptionInfo *exception)
{
- QuantumType
- *quantum_map;
+ register const Quantum
+ *restrict p;
register ssize_t
- i,
x;
- register const Quantum
- *p;
-
- size_t
- length;
+ register unsigned char
+ *q;
ssize_t
y;
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- length=strlen(map);
- quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
- if (quantum_map == (QuantumType *) NULL)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
- return(MagickFalse);
- }
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (map[i])
+ q=pixels;
+ if (LocaleCompare(map,"BGR") == 0)
{
- case 'A':
- case 'a':
- {
- quantum_map[i]=AlphaQuantum;
- break;
- }
- case 'B':
- case 'b':
- {
- quantum_map[i]=BlueQuantum;
- break;
- }
- case 'C':
- case 'c':
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=CyanQuantum;
- if (image->colorspace == CMYKColorspace)
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",map);
- return(MagickFalse);
- }
- case 'g':
- case 'G':
- {
- quantum_map[i]=GreenQuantum;
- break;
- }
- case 'I':
- case 'i':
- {
- quantum_map[i]=IndexQuantum;
- break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToChar(GetPixelRed(image,p));
+ p+=GetPixelChannels(image);
+ }
}
- case 'K':
- case 'k':
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=BlackQuantum;
- if (image->colorspace == CMYKColorspace)
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",map);
- return(MagickFalse);
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToChar(GetPixelRed(image,p));
+ *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
+ }
}
- case 'M':
- case 'm':
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=MagentaQuantum;
- if (image->colorspace == CMYKColorspace)
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",map);
- return(MagickFalse);
- }
- case 'o':
- case 'O':
- {
- quantum_map[i]=OpacityQuantum;
- break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToChar(GetPixelRed(image,p));
+ *q++=ScaleQuantumToChar((Quantum) 0);
+ p+=GetPixelChannels(image);
+ }
}
- case 'P':
- case 'p':
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=UndefinedQuantum;
- break;
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ p+=GetPixelChannels(image);
+ }
}
- case 'R':
- case 'r':
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=RedQuantum;
- break;
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToChar(GetPixelRed(image,p));
+ *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
+ p+=GetPixelChannels(image);
+ }
}
- case 'Y':
- case 'y':
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=YellowQuantum;
- if (image->colorspace == CMYKColorspace)
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",map);
- return(MagickFalse);
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToChar(GetPixelRed(image,p));
+ *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
+ }
}
- default:
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",map);
- return(MagickFalse);
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToChar(GetPixelRed(image,p));
+ *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToChar((Quantum) 0);
+ p+=GetPixelChannels(image);
+ }
}
+ return;
}
- }
- switch (type)
+ for (y=0; y < (ssize_t) rows; y++)
{
- case CharPixel:
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- register unsigned char
- *q;
+ register ssize_t
+ i;
- q=(unsigned char *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ *q=0;
+ switch (quantum_map[i])
{
- for (y=0; y < (ssize_t) rows; y++)
+ case RedQuantum:
+ case CyanQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
- *q++=ScaleQuantumToChar(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=ScaleQuantumToChar(GetPixelRed(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case GreenQuantum:
+ case MagentaQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
- *q++=ScaleQuantumToChar(GetPixelRed(image,p));
- *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=ScaleQuantumToChar(GetPixelGreen(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlueQuantum:
+ case YellowQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
- *q++=ScaleQuantumToChar(GetPixelRed(image,p));
- *q++=ScaleQuantumToChar((Quantum) 0);
- p+=GetPixelChannels(image);
- }
+ *q=ScaleQuantumToChar(GetPixelBlue(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case AlphaQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case OpacityQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToChar(GetPixelRed(image,p));
- *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
- *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlackQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToChar(GetPixelRed(image,p));
- *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
- *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
+ if (image->colorspace == CMYKColorspace)
+ *q=ScaleQuantumToChar(GetPixelBlack(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case IndexQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToChar(GetPixelRed(image,p));
- *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
- *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- *q++=ScaleQuantumToChar((Quantum) 0);
- p+=GetPixelChannels(image);
- }
+ *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ break;
}
- break;
+ default:
+ break;
}
+ q++;
+ }
+ p+=GetPixelChannels(image);
+ }
+ }
+}
+
+static void ExportDoublePixel(const Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const Quantum
+ *restrict p;
+
+ register double
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ q=(double *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- *q=0;
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- *q=ScaleQuantumToChar(GetPixelRed(image,p));
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- *q=ScaleQuantumToChar(GetPixelGreen(image,p));
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- *q=ScaleQuantumToChar(GetPixelBlue(image,p));
- break;
- }
- case AlphaQuantum:
- {
- *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
- break;
- }
- case OpacityQuantum:
- {
- *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
- break;
- }
- case BlackQuantum:
- {
- if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToChar(GetPixelBlack(image,p));
- break;
- }
- case IndexQuantum:
- {
- *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
- break;
- }
- default:
- break;
- }
- q++;
- }
+ *q++=(double) (QuantumScale*GetPixelBlue(image,p));
+ *q++=(double) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(double) (QuantumScale*GetPixelRed(image,p));
p+=GetPixelChannels(image);
}
}
- break;
+ return;
}
- case DoublePixel:
+ if (LocaleCompare(map,"BGRA") == 0)
{
- register double
- *q;
-
- q=(double *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(double) (QuantumScale*GetPixelBlue(image,p));
- *q++=(double) (QuantumScale*GetPixelGreen(image,p));
- *q++=(double) (QuantumScale*GetPixelRed(image,p));
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(double) (QuantumScale*GetPixelBlue(image,p));
+ *q++=(double) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(double) (QuantumScale*GetPixelRed(image,p));
+ *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(double) (QuantumScale*GetPixelBlue(image,p));
- *q++=(double) (QuantumScale*GetPixelGreen(image,p));
- *q++=(double) (QuantumScale*GetPixelRed(image,p));
- *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(double) (QuantumScale*GetPixelBlue(image,p));
- *q++=(double) (QuantumScale*GetPixelGreen(image,p));
- *q++=(double) (QuantumScale*GetPixelRed(image,p));
- *q++=0.0;
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(double) (QuantumScale*GetPixelBlue(image,p));
+ *q++=(double) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(double) (QuantumScale*GetPixelRed(image,p));
+ *q++=0.0;
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(double) (QuantumScale*GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
- }
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGB") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(double) (QuantumScale*GetPixelRed(image,p));
- *q++=(double) (QuantumScale*GetPixelGreen(image,p));
- *q++=(double) (QuantumScale*GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(double) (QuantumScale*GetPixelIntensity(image,p));
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(double) (QuantumScale*GetPixelRed(image,p));
- *q++=(double) (QuantumScale*GetPixelGreen(image,p));
- *q++=(double) (QuantumScale*GetPixelBlue(image,p));
- *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(double) (QuantumScale*GetPixelRed(image,p));
- *q++=(double) (QuantumScale*GetPixelGreen(image,p));
- *q++=(double) (QuantumScale*GetPixelBlue(image,p));
- *q++=0.0;
- p+=GetPixelChannels(image);
- }
- }
+ *q++=(double) (QuantumScale*GetPixelRed(image,p));
+ *q++=(double) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(double) (QuantumScale*GetPixelBlue(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=(double) (QuantumScale*GetPixelRed(image,p));
+ *q++=(double) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(double) (QuantumScale*GetPixelBlue(image,p));
+ *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
}
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- *q=0;
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- *q=(double) (QuantumScale*GetPixelRed(image,p));
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- *q=(double) (QuantumScale*GetPixelGreen(image,p));
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- *q=(double) (QuantumScale*GetPixelBlue(image,p));
- break;
- }
- case AlphaQuantum:
- {
- *q=(double) (QuantumScale*GetPixelAlpha(image,p));
- break;
- }
- case OpacityQuantum:
- {
- *q=(double) (QuantumScale*GetPixelAlpha(image,p));
- break;
- }
- case BlackQuantum:
- {
- if (image->colorspace == CMYKColorspace)
- *q=(double) (QuantumScale*
- GetPixelBlack(image,p));
- break;
- }
- case IndexQuantum:
- {
- *q=(double) (QuantumScale*GetPixelIntensity(image,p));
- break;
- }
- default:
- *q=0;
- }
- q++;
- }
+ *q++=(double) (QuantumScale*GetPixelRed(image,p));
+ *q++=(double) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(double) (QuantumScale*GetPixelBlue(image,p));
+ *q++=0.0;
p+=GetPixelChannels(image);
}
}
- break;
+ return;
}
- case FloatPixel:
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- register float
- *q;
+ register ssize_t
+ i;
- q=(float *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ *q=0;
+ switch (quantum_map[i])
{
- for (y=0; y < (ssize_t) rows; y++)
+ case RedQuantum:
+ case CyanQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(float) (QuantumScale*GetPixelBlue(image,p));
- *q++=(float) (QuantumScale*GetPixelGreen(image,p));
- *q++=(float) (QuantumScale*GetPixelRed(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(double) (QuantumScale*GetPixelRed(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case GreenQuantum:
+ case MagentaQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(float) (QuantumScale*GetPixelBlue(image,p));
- *q++=(float) (QuantumScale*GetPixelGreen(image,p));
- *q++=(float) (QuantumScale*GetPixelRed(image,p));
- *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(double) (QuantumScale*GetPixelGreen(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlueQuantum:
+ case YellowQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(float) (QuantumScale*GetPixelBlue(image,p));
- *q++=(float) (QuantumScale*GetPixelGreen(image,p));
- *q++=(float) (QuantumScale*GetPixelRed(image,p));
- *q++=0.0;
- p+=GetPixelChannels(image);
- }
+ *q=(double) (QuantumScale*GetPixelBlue(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case AlphaQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(float) (QuantumScale*GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(double) (QuantumScale*GetPixelAlpha(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case OpacityQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(float) (QuantumScale*GetPixelRed(image,p));
- *q++=(float) (QuantumScale*GetPixelGreen(image,p));
- *q++=(float) (QuantumScale*GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(double) (QuantumScale*GetPixelAlpha(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlackQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(float) (QuantumScale*GetPixelRed(image,p));
- *q++=(float) (QuantumScale*GetPixelGreen(image,p));
- *q++=(float) (QuantumScale*GetPixelBlue(image,p));
- *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
+ if (image->colorspace == CMYKColorspace)
+ *q=(double) (QuantumScale*
+ GetPixelBlack(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case IndexQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(float) (QuantumScale*GetPixelRed(image,p));
- *q++=(float) (QuantumScale*GetPixelGreen(image,p));
- *q++=(float) (QuantumScale*GetPixelBlue(image,p));
- *q++=0.0;
- p+=GetPixelChannels(image);
- }
+ *q=(double) (QuantumScale*GetPixelIntensity(image,p));
+ break;
}
- break;
+ default:
+ *q=0;
}
+ q++;
+ }
+ p+=GetPixelChannels(image);
+ }
+ }
+}
+
+static void ExportFloatPixel(const Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const Quantum
+ *restrict p;
+
+ register float
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ q=(float *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- *q=0;
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- *q=(float) (QuantumScale*GetPixelRed(image,p));
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- *q=(float) (QuantumScale*GetPixelGreen(image,p));
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- *q=(float) (QuantumScale*GetPixelBlue(image,p));
- break;
- }
- case AlphaQuantum:
- {
- *q=(float) (QuantumScale*((Quantum) (GetPixelAlpha(image,p))));
- break;
- }
- case OpacityQuantum:
- {
- *q=(float) (QuantumScale*GetPixelAlpha(image,p));
- break;
- }
- case BlackQuantum:
- {
- if (image->colorspace == CMYKColorspace)
- *q=(float) (QuantumScale* GetPixelBlack(image,p));
- break;
- }
- case IndexQuantum:
- {
- *q=(float) (QuantumScale*GetPixelIntensity(image,p));
- break;
- }
- default:
- *q=0;
- }
- q++;
- }
+ *q++=(float) (QuantumScale*GetPixelBlue(image,p));
+ *q++=(float) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(float) (QuantumScale*GetPixelRed(image,p));
p+=GetPixelChannels(image);
}
}
- break;
+ return;
}
- case IntegerPixel:
+ if (LocaleCompare(map,"BGRA") == 0)
{
- register unsigned int
- *q;
-
- q=(unsigned int *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
- }
- }
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
- }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=0U;
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(float) (QuantumScale*GetPixelBlue(image,p));
+ *q++=(float) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(float) (QuantumScale*GetPixelRed(image,p));
+ *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(unsigned int) ScaleQuantumToLong(
- GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
- }
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGB") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(float) (QuantumScale*GetPixelBlue(image,p));
+ *q++=(float) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(float) (QuantumScale*GetPixelRed(image,p));
+ *q++=0.0;
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=0U;
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(float) (QuantumScale*GetPixelIntensity(image,p));
+ p+=GetPixelChannels(image);
}
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- *q=0;
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- *q=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- *q=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- *q=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- break;
- }
- case AlphaQuantum:
- {
- *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
- break;
- }
- case OpacityQuantum:
- {
- *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
- break;
- }
- case BlackQuantum:
- {
- if (image->colorspace == CMYKColorspace)
- *q=(unsigned int) ScaleQuantumToLong(GetPixelBlack(image,p));
- break;
- }
- case IndexQuantum:
- {
- *q=(unsigned int) ScaleQuantumToLong(
- GetPixelIntensity(image,p));
- break;
- }
- default:
- *q=0;
- }
- q++;
- }
+ *q++=(float) (QuantumScale*GetPixelRed(image,p));
+ *q++=(float) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(float) (QuantumScale*GetPixelBlue(image,p));
p+=GetPixelChannels(image);
}
}
- break;
+ return;
}
- case LongPixel:
+ if (LocaleCompare(map,"RGBA") == 0)
{
- register size_t
- *q;
-
- q=(size_t *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
- }
- }
+ *q++=(float) (QuantumScale*GetPixelRed(image,p));
+ *q++=(float) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(float) (QuantumScale*GetPixelBlue(image,p));
+ *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=(float) (QuantumScale*GetPixelRed(image,p));
+ *q++=(float) (QuantumScale*GetPixelGreen(image,p));
+ *q++=(float) (QuantumScale*GetPixelBlue(image,p));
+ *q++=0.0;
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"BGRA") == 0)
+ }
+ return;
+ }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ *q=0;
+ switch (quantum_map[i])
{
- for (y=0; y < (ssize_t) rows; y++)
+ case RedQuantum:
+ case CyanQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(float) (QuantumScale*GetPixelRed(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case GreenQuantum:
+ case MagentaQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=0;
- p+=GetPixelChannels(image);
- }
+ *q=(float) (QuantumScale*GetPixelGreen(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlueQuantum:
+ case YellowQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(float) (QuantumScale*GetPixelBlue(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case AlphaQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(float) (QuantumScale*((Quantum) (GetPixelAlpha(image,p))));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case OpacityQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(float) (QuantumScale*GetPixelAlpha(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlackQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=0;
- p+=GetPixelChannels(image);
- }
+ if (image->colorspace == CMYKColorspace)
+ *q=(float) (QuantumScale* GetPixelBlack(image,p));
+ break;
}
- break;
+ case IndexQuantum:
+ {
+ *q=(float) (QuantumScale*GetPixelIntensity(image,p));
+ break;
+ }
+ default:
+ *q=0;
}
+ q++;
+ }
+ p+=GetPixelChannels(image);
+ }
+ }
+}
+
+static void ExportIntegerPixel(const Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const Quantum
+ *restrict p;
+
+ register ssize_t
+ x;
+
+ register unsigned int
+ *q;
+
+ ssize_t
+ y;
+
+ q=(unsigned int *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- *q=0;
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- *q=ScaleQuantumToLong(GetPixelRed(image,p));
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- *q=ScaleQuantumToLong(GetPixelGreen(image,p));
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- *q=ScaleQuantumToLong(GetPixelBlue(image,p));
- break;
- }
- case AlphaQuantum:
- {
- *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
- break;
- }
- case OpacityQuantum:
- {
- *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
- break;
- }
- case BlackQuantum:
- {
- if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToLong(GetPixelBlack(image,p));
- break;
- }
- case IndexQuantum:
- {
- *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
- break;
- }
- default:
- break;
- }
- q++;
- }
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
p+=GetPixelChannels(image);
}
}
- break;
+ return;
}
- case QuantumPixel:
+ if (LocaleCompare(map,"BGRA") == 0)
{
- register Quantum
- *q;
-
- q=(Quantum *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=GetPixelBlue(image,p);
- *q++=GetPixelGreen(image,p);
- *q++=GetPixelRed(image,p);
- p+=GetPixelChannels(image);
- }
- }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=GetPixelBlue(image,p);
- *q++=GetPixelGreen(image,p);
- *q++=GetPixelRed(image,p);
- *q++=(Quantum) (GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=GetPixelBlue(image,p);
- *q++=GetPixelGreen(image,p);
- *q++=GetPixelRed(image,p);
- *q++=(Quantum) 0;
- p+=GetPixelChannels(image);
- }
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"I") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=GetPixelIntensity(image,p);
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=0U;
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=GetPixelRed(image,p);
- *q++=GetPixelGreen(image,p);
- *q++=GetPixelBlue(image,p);
- p+=GetPixelChannels(image);
- }
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=GetPixelRed(image,p);
- *q++=GetPixelGreen(image,p);
- *q++=GetPixelBlue(image,p);
- *q++=(Quantum) (GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
- }
- break;
+ *q++=(unsigned int) ScaleQuantumToLong(
+ GetPixelIntensity(image,p));
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBP") == 0)
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=GetPixelRed(image,p);
- *q++=GetPixelGreen(image,p);
- *q++=GetPixelBlue(image,p);
- *q++=(Quantum) 0;
- p+=GetPixelChannels(image);
- }
- }
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
}
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- *q=(Quantum) 0;
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- *q=GetPixelRed(image,p);
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- *q=GetPixelGreen(image,p);
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- *q=GetPixelBlue(image,p);
- break;
- }
- case AlphaQuantum:
- {
- *q=(Quantum) (GetPixelAlpha(image,p));
- break;
- }
- case OpacityQuantum:
- {
- *q=GetPixelAlpha(image,p);
- break;
- }
- case BlackQuantum:
- {
- if (image->colorspace == CMYKColorspace)
- *q=GetPixelBlack(image,p);
- break;
- }
- case IndexQuantum:
- {
- *q=(GetPixelIntensity(image,p));
- break;
- }
- default:
- *q=(Quantum) 0;
- }
- q++;
- }
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=0U;
p+=GetPixelChannels(image);
}
}
- break;
+ return;
}
- case ShortPixel:
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- register unsigned short
- *q;
+ register ssize_t
+ i;
- q=(unsigned short *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ *q=0;
+ switch (quantum_map[i])
{
- for (y=0; y < (ssize_t) rows; y++)
+ case RedQuantum:
+ case CyanQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
- *q++=ScaleQuantumToShort(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case GreenQuantum:
+ case MagentaQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
- *q++=ScaleQuantumToShort(GetPixelRed(image,p));
- *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlueQuantum:
+ case YellowQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
- *q++=ScaleQuantumToShort(GetPixelRed(image,p));
- *q++=0;
- p+=GetPixelChannels(image);
- }
+ *q=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case AlphaQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case OpacityQuantum:
{
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToShort(GetPixelRed(image,p));
- *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
- *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
- }
+ *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
+ break;
+ }
+ case BlackQuantum:
+ {
+ if (image->colorspace == CMYKColorspace)
+ *q=(unsigned int) ScaleQuantumToLong(GetPixelBlack(image,p));
+ break;
+ }
+ case IndexQuantum:
+ {
+ *q=(unsigned int) ScaleQuantumToLong(
+ GetPixelIntensity(image,p));
+ break;
}
+ default:
+ *q=0;
+ }
+ q++;
+ }
+ p+=GetPixelChannels(image);
+ }
+ }
+}
+
+static void ExportLongPixel(const Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const Quantum
+ *restrict p;
+
+ register ssize_t
+ x;
+
+ register unsigned int
+ *q;
+
+ ssize_t
+ y;
+
+ q=(unsigned int *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBA") == 0)
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToShort(GetPixelRed(image,p));
- *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
- *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
- }
- }
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=0;
+ p+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBP") == 0)
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (p == (const Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- *q++=ScaleQuantumToShort(GetPixelRed(image,p));
- *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
- *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- *q++=0;
- p+=GetPixelChannels(image);
- }
- }
+ *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ p+=GetPixelChannels(image);
}
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- *q=0;
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- *q=ScaleQuantumToShort(GetPixelRed(image,p));
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- *q=ScaleQuantumToShort(GetPixelGreen(image,p));
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- *q=ScaleQuantumToShort(GetPixelBlue(image,p));
- break;
- }
- case AlphaQuantum:
- {
- *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
- break;
- }
- case OpacityQuantum:
- {
- *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
- break;
- }
- case BlackQuantum:
- {
- if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToShort(GetPixelBlack(image,p));
- break;
- }
- case IndexQuantum:
- {
- *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
- break;
- }
- default:
- break;
- }
- q++;
- }
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
p+=GetPixelChannels(image);
}
}
- break;
+ return;
}
- default:
+ if (LocaleCompare(map,"RGBP") == 0)
{
- quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",map);
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=0;
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ *q=0;
+ switch (quantum_map[i])
+ {
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ *q=ScaleQuantumToLong(GetPixelRed(image,p));
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ *q=ScaleQuantumToLong(GetPixelGreen(image,p));
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ *q=ScaleQuantumToLong(GetPixelBlue(image,p));
+ break;
+ }
+ case AlphaQuantum:
+ {
+ *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ break;
+ }
+ case OpacityQuantum:
+ {
+ *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ break;
+ }
+ case BlackQuantum:
+ {
+ if (image->colorspace == CMYKColorspace)
+ *q=ScaleQuantumToLong(GetPixelBlack(image,p));
+ break;
+ }
+ case IndexQuantum:
+ {
+ *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ break;
+ }
+ default:
+ break;
+ }
+ q++;
+ }
+ p+=GetPixelChannels(image);
}
}
- quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- return(MagickTrue);
}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% G e t P i x e l I n f o %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% GetPixelInfo() initializes the PixelInfo structure.
-%
-% The format of the GetPixelInfo method is:
-%
-% GetPixelInfo(const Image *image,PixelInfo *pixel)
-%
-% A description of each parameter follows:
-%
-% o image: the image.
-%
-% o pixel: Specifies a pointer to a PixelInfo structure.
-%
-*/
-MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
+
+static void ExportQuantumPixel(const Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ unsigned char *restrict pixels,ExceptionInfo *exception)
{
- pixel->storage_class=DirectClass;
- pixel->colorspace=RGBColorspace;
- pixel->matte=MagickFalse;
- pixel->fuzz=0.0;
- pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
- pixel->red=0.0;
- pixel->green=0.0;
- pixel->blue=0.0;
- pixel->black=0.0;
- pixel->alpha=(MagickRealType) OpaqueAlpha;
- pixel->index=0.0;
- if (image == (const Image *) NULL)
- return;
- pixel->storage_class=image->storage_class;
- pixel->colorspace=image->colorspace;
- pixel->matte=image->matte;
- pixel->depth=image->depth;
- pixel->fuzz=image->fuzz;
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% I m p o r t I m a g e P i x e l s %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% ImportImagePixels() accepts pixel data and stores in the image at the
-% location you specify. The method returns MagickTrue on success otherwise
-% MagickFalse if an error is encountered. The pixel data can be either char,
-% short int, int, ssize_t, float, or double in the order specified by map.
-%
-% Suppose your want to upload the first scanline of a 640x480 image from
-% character data in red-green-blue order:
-%
-% ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
-%
-% The format of the ImportImagePixels method is:
-%
-% MagickBooleanType ImportImagePixels(Image *image,const ssize_t x_offset,
-% const ssize_t y_offset,const size_t columns,
-% const size_t rows,const char *map,const StorageType type,
-% const void *pixels,ExceptionInfo *exception)
-%
-% A description of each parameter follows:
-%
-% o image: the image.
-%
-% o x_offset,y_offset,columns,rows: These values define the perimeter
-% of a region of pixels you want to define.
-%
-% o map: This string reflects the expected ordering of the pixel array.
-% It can be any combination or order of R = red, G = green, B = blue,
-% A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
-% Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
-% P = pad.
-%
-% o type: Define the data type of the pixels. Float and double types are
-% normalized to [0..1] otherwise [0..QuantumRange]. Choose from these
-% types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or
-% DoublePixel.
-%
-% o pixels: This array of values contain the pixel components as defined by
-% map and type. You must preallocate this array where the expected
-% length varies depending on the values of width, height, map, and type.
-%
-% o exception: return any errors or warnings in this structure.
-%
-*/
-MagickExport MagickBooleanType ImportImagePixels(Image *image,
- const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
- const size_t rows,const char *map,const StorageType type,
- const void *pixels,ExceptionInfo *exception)
+ register const Quantum
+ *restrict p;
+
+ register Quantum
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ q=(Quantum *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=GetPixelBlue(image,p);
+ *q++=GetPixelGreen(image,p);
+ *q++=GetPixelRed(image,p);
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=GetPixelBlue(image,p);
+ *q++=GetPixelGreen(image,p);
+ *q++=GetPixelRed(image,p);
+ *q++=(Quantum) (GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=GetPixelBlue(image,p);
+ *q++=GetPixelGreen(image,p);
+ *q++=GetPixelRed(image,p);
+ *q++=(Quantum) 0;
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=GetPixelIntensity(image,p);
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=GetPixelRed(image,p);
+ *q++=GetPixelGreen(image,p);
+ *q++=GetPixelBlue(image,p);
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=GetPixelRed(image,p);
+ *q++=GetPixelGreen(image,p);
+ *q++=GetPixelBlue(image,p);
+ *q++=(Quantum) (GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=GetPixelRed(image,p);
+ *q++=GetPixelGreen(image,p);
+ *q++=GetPixelBlue(image,p);
+ *q++=(Quantum) 0;
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ *q=(Quantum) 0;
+ switch (quantum_map[i])
+ {
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ *q=GetPixelRed(image,p);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ *q=GetPixelGreen(image,p);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ *q=GetPixelBlue(image,p);
+ break;
+ }
+ case AlphaQuantum:
+ {
+ *q=GetPixelAlpha(image,p);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ *q=GetPixelAlpha(image,p);
+ break;
+ }
+ case BlackQuantum:
+ {
+ if (image->colorspace == CMYKColorspace)
+ *q=GetPixelBlack(image,p);
+ break;
+ }
+ case IndexQuantum:
+ {
+ *q=(GetPixelIntensity(image,p));
+ break;
+ }
+ default:
+ {
+ *q=(Quantum) 0;
+ break;
+ }
+ }
+ q++;
+ }
+ p+=GetPixelChannels(image);
+ }
+ }
+}
+
+static void ExportShortPixel(const Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const Quantum
+ *restrict p;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ register unsigned short
+ *q;
+
+ q=(unsigned short *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToShort(GetPixelRed(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToShort(GetPixelRed(image,p));
+ *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToShort(GetPixelRed(image,p));
+ *q++=0;
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToShort(GetPixelRed(image,p));
+ *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToShort(GetPixelRed(image,p));
+ *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ *q++=ScaleQuantumToShort(GetPixelRed(image,p));
+ *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
+ *q++=0;
+ p+=GetPixelChannels(image);
+ }
+ }
+ return;
+ }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (p == (const Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ *q=0;
+ switch (quantum_map[i])
+ {
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ *q=ScaleQuantumToShort(GetPixelRed(image,p));
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ *q=ScaleQuantumToShort(GetPixelGreen(image,p));
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ *q=ScaleQuantumToShort(GetPixelBlue(image,p));
+ break;
+ }
+ case AlphaQuantum:
+ {
+ *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ break;
+ }
+ case OpacityQuantum:
+ {
+ *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ break;
+ }
+ case BlackQuantum:
+ {
+ if (image->colorspace == CMYKColorspace)
+ *q=ScaleQuantumToShort(GetPixelBlack(image,p));
+ break;
+ }
+ case IndexQuantum:
+ {
+ *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ break;
+ }
+ default:
+ break;
+ }
+ q++;
+ }
+ p+=GetPixelChannels(image);
+ }
+ }
+}
+
+MagickExport MagickBooleanType ExportImagePixels(const Image *image,
+ const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
+ const size_t rows,const char *map,const StorageType type,void *pixels,
+ ExceptionInfo *exception)
+{
+ QuantumType
+ *quantum_map;
+
+ register ssize_t
+ i;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ quantum_map=(QuantumType *) AcquireQuantumMemory(strlen(map),
+ sizeof(*quantum_map));
+ if (quantum_map == (QuantumType *) NULL)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
+ return(MagickFalse);
+ }
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ switch (map[i])
+ {
+ case 'A':
+ case 'a':
+ {
+ quantum_map[i]=AlphaQuantum;
+ break;
+ }
+ case 'B':
+ case 'b':
+ {
+ quantum_map[i]=BlueQuantum;
+ break;
+ }
+ case 'C':
+ case 'c':
+ {
+ quantum_map[i]=CyanQuantum;
+ if (image->colorspace == CMYKColorspace)
+ break;
+ quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",map);
+ return(MagickFalse);
+ }
+ case 'g':
+ case 'G':
+ {
+ quantum_map[i]=GreenQuantum;
+ break;
+ }
+ case 'I':
+ case 'i':
+ {
+ quantum_map[i]=IndexQuantum;
+ break;
+ }
+ case 'K':
+ case 'k':
+ {
+ quantum_map[i]=BlackQuantum;
+ if (image->colorspace == CMYKColorspace)
+ break;
+ quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",map);
+ return(MagickFalse);
+ }
+ case 'M':
+ case 'm':
+ {
+ quantum_map[i]=MagentaQuantum;
+ if (image->colorspace == CMYKColorspace)
+ break;
+ quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",map);
+ return(MagickFalse);
+ }
+ case 'o':
+ case 'O':
+ {
+ quantum_map[i]=OpacityQuantum;
+ break;
+ }
+ case 'P':
+ case 'p':
+ {
+ quantum_map[i]=UndefinedQuantum;
+ break;
+ }
+ case 'R':
+ case 'r':
+ {
+ quantum_map[i]=RedQuantum;
+ break;
+ }
+ case 'Y':
+ case 'y':
+ {
+ quantum_map[i]=YellowQuantum;
+ if (image->colorspace == CMYKColorspace)
+ break;
+ quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",map);
+ return(MagickFalse);
+ }
+ default:
+ {
+ quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "UnrecognizedPixelMap","`%s'",map);
+ return(MagickFalse);
+ }
+ }
+ }
+ switch (type)
+ {
+ case CharPixel:
+ {
+ ExportCharPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case DoublePixel:
+ {
+ ExportDoublePixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case FloatPixel:
+ {
+ ExportFloatPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case IntegerPixel:
+ {
+ ExportIntegerPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case LongPixel:
+ {
+ ExportLongPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case QuantumPixel:
+ {
+ ExportQuantumPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case ShortPixel:
+ {
+ ExportShortPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ default:
+ {
+ quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "UnrecognizedPixelMap","`%s'",map);
+ break;
+ }
+ }
+ quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
+ return(MagickTrue);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% G e t P i x e l I n f o %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% GetPixelInfo() initializes the PixelInfo structure.
+%
+% The format of the GetPixelInfo method is:
+%
+% GetPixelInfo(const Image *image,PixelInfo *pixel)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o pixel: Specifies a pointer to a PixelInfo structure.
+%
+*/
+MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
+{
+ pixel->storage_class=DirectClass;
+ pixel->colorspace=RGBColorspace;
+ pixel->matte=MagickFalse;
+ pixel->fuzz=0.0;
+ pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
+ pixel->red=0.0;
+ pixel->green=0.0;
+ pixel->blue=0.0;
+ pixel->black=0.0;
+ pixel->alpha=(MagickRealType) OpaqueAlpha;
+ pixel->index=0.0;
+ if (image == (const Image *) NULL)
+ return;
+ pixel->storage_class=image->storage_class;
+ pixel->colorspace=image->colorspace;
+ pixel->matte=image->matte;
+ pixel->depth=image->depth;
+ pixel->fuzz=image->fuzz;
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% I m p o r t I m a g e P i x e l s %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% ImportImagePixels() accepts pixel data and stores in the image at the
+% location you specify. The method returns MagickTrue on success otherwise
+% MagickFalse if an error is encountered. The pixel data can be either char,
+% short int, int, ssize_t, float, or double in the order specified by map.
+%
+% Suppose your want to upload the first scanline of a 640x480 image from
+% character data in red-green-blue order:
+%
+% ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
+%
+% The format of the ImportImagePixels method is:
+%
+% MagickBooleanType ImportImagePixels(Image *image,const ssize_t x_offset,
+% const ssize_t y_offset,const size_t columns,
+% const size_t rows,const char *map,const StorageType type,
+% const void *pixels,ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o x_offset,y_offset,columns,rows: These values define the perimeter
+% of a region of pixels you want to define.
+%
+% o map: This string reflects the expected ordering of the pixel array.
+% It can be any combination or order of R = red, G = green, B = blue,
+% A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
+% Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
+% P = pad.
+%
+% o type: Define the data type of the pixels. Float and double types are
+% normalized to [0..1] otherwise [0..QuantumRange]. Choose from these
+% types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or
+% DoublePixel.
+%
+% o pixels: This array of values contain the pixel components as defined by
+% map and type. You must preallocate this array where the expected
+% length varies depending on the values of width, height, map, and type.
+%
+% o exception: return any errors or warnings in this structure.
+%
+*/
+
+static void ImportCharPixel(Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ const unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const unsigned char
+ *restrict p;
+
+ register Quantum
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ p=(const unsigned char *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRO") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelGray(image,ScaleCharToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBO") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ switch (quantum_map[i])
+ {
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ SetPixelRed(image,ScaleCharToQuantum(*p),q);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ SetPixelGreen(image,ScaleCharToQuantum(*p),q);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ SetPixelBlue(image,ScaleCharToQuantum(*p),q);
+ break;
+ }
+ case AlphaQuantum:
+ {
+ SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
+ break;
+ }
+ case BlackQuantum:
+ {
+ SetPixelBlack(image,ScaleCharToQuantum(*p),q);
+ break;
+ }
+ case IndexQuantum:
+ {
+ SetPixelGray(image,ScaleCharToQuantum(*p),q);
+ break;
+ }
+ default:
+ break;
+ }
+ p++;
+ }
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+}
+
+static void ImportDoublePixel(Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ const unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const double
+ *restrict p;
+
+ register Quantum
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ p=(const double *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ switch (quantum_map[i])
+ {
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ SetPixelRed(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ SetPixelGreen(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ SetPixelBlue(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case AlphaQuantum:
+ {
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case BlackQuantum:
+ {
+ SetPixelBlack(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case IndexQuantum:
+ {
+ SetPixelGray(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ default:
+ break;
+ }
+ p++;
+ }
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+}
+
+static void ImportFloatPixel(Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ const unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const float
+ *restrict p;
+
+ register Quantum
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ p=(const float *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+ (*p)),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ switch (quantum_map[i])
+ {
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ SetPixelRed(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ SetPixelGreen(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ SetPixelBlue(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case AlphaQuantum:
+ {
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ SetPixelAlpha(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case BlackQuantum:
+ {
+ SetPixelBlack(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ case IndexQuantum:
+ {
+ SetPixelGray(image,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)),q);
+ break;
+ }
+ default:
+ break;
+ }
+ p++;
+ }
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+}
+
+static void ImportIntegerPixel(Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ const unsigned char *restrict pixels,ExceptionInfo *exception)
{
- QuantumType
- *quantum_map;
+ register const unsigned int
+ *restrict p;
register Quantum
*q;
register ssize_t
- i,
x;
- size_t
- length;
-
ssize_t
y;
- /*
- Allocate image structure.
- */
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- length=strlen(map);
- quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
- if (quantum_map == (QuantumType *) NULL)
- ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
- image->filename);
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (map[i])
+ p=(const unsigned int *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
{
- case 'a':
- case 'A':
- {
- quantum_map[i]=AlphaQuantum;
- image->matte=MagickTrue;
- break;
- }
- case 'B':
- case 'b':
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=BlueQuantum;
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- case 'C':
- case 'c':
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=CyanQuantum;
- (void) SetImageColorspace(image,CMYKColorspace,exception);
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- case 'g':
- case 'G':
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=GreenQuantum;
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- case 'K':
- case 'k':
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=BlackQuantum;
- (void) SetImageColorspace(image,CMYKColorspace,exception);
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelGray(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- case 'I':
- case 'i':
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=IndexQuantum;
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- case 'm':
- case 'M':
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=MagentaQuantum;
- (void) SetImageColorspace(image,CMYKColorspace,exception);
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- case 'O':
- case 'o':
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=OpacityQuantum;
- image->matte=MagickTrue;
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- case 'P':
- case 'p':
+ return;
+ }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) strlen(map); i++)
{
- quantum_map[i]=UndefinedQuantum;
- break;
+ switch (quantum_map[i])
+ {
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ SetPixelRed(image,ScaleLongToQuantum(*p),q);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ SetPixelGreen(image,ScaleLongToQuantum(*p),q);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ SetPixelBlue(image,ScaleLongToQuantum(*p),q);
+ break;
+ }
+ case AlphaQuantum:
+ {
+ SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
+ break;
+ }
+ case BlackQuantum:
+ {
+ SetPixelBlack(image,ScaleLongToQuantum(*p),q);
+ break;
+ }
+ case IndexQuantum:
+ {
+ SetPixelGray(image,ScaleLongToQuantum(*p),q);
+ break;
+ }
+ default:
+ break;
+ }
+ p++;
}
- case 'R':
- case 'r':
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+}
+
+static void ImportLongPixel(Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ const unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const unsigned int
+ *restrict p;
+
+ register Quantum
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ p=(const unsigned int *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=RedQuantum;
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- case 'Y':
- case 'y':
+ return;
+ }
+ if (LocaleCompare(map,"BGRA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map[i]=YellowQuantum;
- (void) SetImageColorspace(image,CMYKColorspace,exception);
- break;
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
- default:
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
{
- quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",map);
- return(MagickFalse);
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ p++;
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
}
+ return;
}
- }
- if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
- return(MagickFalse);
- /*
- Transfer the pixels from the pixel datarray to the image.
- */
- switch (type)
- {
- case CharPixel:
+ if (LocaleCompare(map,"I") == 0)
{
- register const unsigned char
- *p;
-
- p=(const unsigned char *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelGray(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"BGRO") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"I") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelGray(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGBO") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- SetPixelRed(image,ScaleCharToQuantum(*p),q);
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- SetPixelGreen(image,ScaleCharToQuantum(*p),q);
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- SetPixelBlue(image,ScaleCharToQuantum(*p),q);
- break;
- }
- case AlphaQuantum:
- {
- SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
- break;
- }
- case OpacityQuantum:
- {
- SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
- break;
- }
- case BlackQuantum:
- {
- SetPixelBlack(image,ScaleCharToQuantum(*p),q);
- break;
- }
- case IndexQuantum:
- {
- SetPixelGray(image,ScaleCharToQuantum(*p),q);
- break;
- }
- default:
- break;
- }
- p++;
- }
+ SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+ p++;
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
- break;
+ return;
}
- case DoublePixel:
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- register const double
- *p;
+ register ssize_t
+ i;
- p=(const double *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ switch (quantum_map[i])
{
- for (y=0; y < (ssize_t) rows; y++)
+ case RedQuantum:
+ case CyanQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelRed(image,ScaleLongToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case GreenQuantum:
+ case MagentaQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelGreen(image,ScaleLongToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlueQuantum:
+ case YellowQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelBlue(image,ScaleLongToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case AlphaQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case OpacityQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlackQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelBlack(image,ScaleLongToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case IndexQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelGray(image,ScaleLongToQuantum(*p),q);
+ break;
}
- break;
+ default:
+ break;
}
+ p++;
+ }
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+}
+
+static void ImportQuantumPixel(Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ const unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const Quantum
+ *restrict p;
+
+ register Quantum
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ p=(const Quantum *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case AlphaQuantum:
- {
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case OpacityQuantum:
- {
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case BlackQuantum:
- {
- SetPixelBlack(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case IndexQuantum:
- {
- SetPixelGray(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- default:
- break;
- }
- p++;
- }
+ SetPixelBlue(image,*p++,q);
+ SetPixelGreen(image,*p++,q);
+ SetPixelRed(image,*p++,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
- break;
+ return;
}
- case FloatPixel:
+ if (LocaleCompare(map,"BGRA") == 0)
{
- register const float
- *p;
-
- p=(const float *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelBlue(image,*p++,q);
+ SetPixelGreen(image,*p++,q);
+ SetPixelRed(image,*p++,q);
+ SetPixelAlpha(image,*p++,q);
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelBlue(image,*p++,q);
+ SetPixelGreen(image,*p++,q);
+ SetPixelRed(image,*p++,q);
+ p++;
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case AlphaQuantum:
- {
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case OpacityQuantum:
- {
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case BlackQuantum:
- {
- SetPixelBlack(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- case IndexQuantum:
- {
- SetPixelGray(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
- break;
- }
- default:
- break;
- }
- p++;
- }
+ SetPixelGray(image,*p++,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
- break;
+ return;
}
- case IntegerPixel:
+ if (LocaleCompare(map,"RGB") == 0)
{
- register const unsigned int
- *p;
-
- p=(const unsigned int *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelRed(image,*p++,q);
+ SetPixelGreen(image,*p++,q);
+ SetPixelBlue(image,*p++,q);
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelGray(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelRed(image,*p++,q);
+ SetPixelGreen(image,*p++,q);
+ SetPixelBlue(image,*p++,q);
+ SetPixelAlpha(image,*p++,q);
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- SetPixelRed(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- SetPixelGreen(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- SetPixelBlue(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case AlphaQuantum:
- {
- SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case OpacityQuantum:
- {
- SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case BlackQuantum:
- {
- SetPixelBlack(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case IndexQuantum:
- {
- SetPixelGray(image,ScaleLongToQuantum(*p),q);
- break;
- }
- default:
- break;
- }
- p++;
- }
+ SetPixelRed(image,*p++,q);
+ SetPixelGreen(image,*p++,q);
+ SetPixelBlue(image,*p++,q);
+ p++;
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
- break;
+ return;
}
- case LongPixel:
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- register const unsigned int
- *p;
+ register ssize_t
+ i;
- p=(const unsigned int *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ switch (quantum_map[i])
{
- for (y=0; y < (ssize_t) rows; y++)
+ case RedQuantum:
+ case CyanQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelRed(image,*p,q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case GreenQuantum:
+ case MagentaQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelGreen(image,*p,q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlueQuantum:
+ case YellowQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelBlue(image,*p,q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case AlphaQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelGray(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelAlpha(image,*p,q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case OpacityQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelAlpha(image,*p,q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlackQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelBlack(image,*p,q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case IndexQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
- SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelGray(image,*p,q);
+ break;
}
- break;
+ default:
+ break;
}
+ p++;
+ }
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+}
+
+static void ImportShortPixel(Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,const size_t columns,const size_t rows,
+ const char *restrict map,const QuantumType *quantum_map,
+ const unsigned char *restrict pixels,ExceptionInfo *exception)
+{
+ register const unsigned short
+ *restrict p;
+
+ register Quantum
+ *q;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
+ p=(const unsigned short *) pixels;
+ if (LocaleCompare(map,"BGR") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- SetPixelRed(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- SetPixelGreen(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- SetPixelBlue(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case AlphaQuantum:
- {
- SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case OpacityQuantum:
- {
- SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case BlackQuantum:
- {
- SetPixelBlack(image,ScaleLongToQuantum(*p),q);
- break;
- }
- case IndexQuantum:
- {
- SetPixelGray(image,ScaleLongToQuantum(*p),q);
- break;
- }
- default:
- break;
- }
- p++;
- }
+ SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
+ SetPixelRed(image,ScaleShortToQuantum(*p++),q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
- break;
+ return;
}
- case QuantumPixel:
+ if (LocaleCompare(map,"BGRA") == 0)
{
- register const Quantum
- *p;
-
- p=(const Quantum *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,*p++,q);
- SetPixelGreen(image,*p++,q);
- SetPixelRed(image,*p++,q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,*p++,q);
- SetPixelGreen(image,*p++,q);
- SetPixelRed(image,*p++,q);
- SetPixelAlpha(image,*p++,q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
+ SetPixelRed(image,ScaleShortToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,*p++,q);
- SetPixelGreen(image,*p++,q);
- SetPixelRed(image,*p++,q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- }
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelGray(image,*p++,q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ }
+ return;
+ }
+ if (LocaleCompare(map,"BGRP") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGB") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,*p++,q);
- SetPixelGreen(image,*p++,q);
- SetPixelBlue(image,*p++,q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
- break;
+ SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
+ SetPixelRed(image,ScaleShortToQuantum(*p++),q);
+ p++;
+ q+=GetPixelChannels(image);
}
- if (LocaleCompare(map,"RGBA") == 0)
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"I") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,*p++,q);
- SetPixelGreen(image,*p++,q);
- SetPixelBlue(image,*p++,q);
- SetPixelAlpha(image,*p++,q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ SetPixelGray(image,ScaleShortToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGB") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (y=0; y < (ssize_t) rows; y++)
- {
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,*p++,q);
- SetPixelGreen(image,*p++,q);
- SetPixelBlue(image,*p++,q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
- }
+ SetPixelRed(image,ScaleShortToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBA") == 0)
+ {
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
break;
+ for (x=0; x < (ssize_t) columns; x++)
+ {
+ SetPixelRed(image,ScaleShortToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
+ SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
+ q+=GetPixelChannels(image);
}
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+ return;
+ }
+ if (LocaleCompare(map,"RGBP") == 0)
+ {
for (y=0; y < (ssize_t) rows; y++)
{
q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
break;
for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- SetPixelRed(image,*p,q);
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- SetPixelGreen(image,*p,q);
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- SetPixelBlue(image,*p,q);
- break;
- }
- case AlphaQuantum:
- {
- SetPixelAlpha(image,*p,q);
- break;
- }
- case OpacityQuantum:
- {
- SetPixelAlpha(image,*p,q);
- break;
- }
- case BlackQuantum:
- {
- SetPixelBlack(image,*p,q);
- break;
- }
- case IndexQuantum:
- {
- SetPixelGray(image,*p,q);
- break;
- }
- default:
- break;
- }
- p++;
- }
+ SetPixelRed(image,ScaleShortToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
+ p++;
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
- break;
+ return;
}
- case ShortPixel:
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) columns; x++)
{
- register const unsigned short
- *p;
+ register ssize_t
+ i;
- p=(const unsigned short *) pixels;
- if (LocaleCompare(map,"BGR") == 0)
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ switch (quantum_map[i])
{
- for (y=0; y < (ssize_t) rows; y++)
+ case RedQuantum:
+ case CyanQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
- SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
- SetPixelRed(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelRed(image,ScaleShortToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case GreenQuantum:
+ case MagentaQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
- SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
- SetPixelRed(image,ScaleShortToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelGreen(image,ScaleShortToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"BGRP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlueQuantum:
+ case YellowQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
- SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
- SetPixelRed(image,ScaleShortToQuantum(*p++),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelBlue(image,ScaleShortToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"I") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case AlphaQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelGray(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGB") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case OpacityQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleShortToQuantum(*p++),q);
- SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
- SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBA") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case BlackQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleShortToQuantum(*p++),q);
- SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
- SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
- SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelBlack(image,ScaleShortToQuantum(*p),q);
+ break;
}
- break;
- }
- if (LocaleCompare(map,"RGBP") == 0)
- {
- for (y=0; y < (ssize_t) rows; y++)
+ case IndexQuantum:
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- SetPixelRed(image,ScaleShortToQuantum(*p++),q);
- SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
- SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
- p++;
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ SetPixelGray(image,ScaleShortToQuantum(*p),q);
+ break;
}
- break;
+ default:
+ break;
}
- for (y=0; y < (ssize_t) rows; y++)
+ p++;
+ }
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ }
+}
+
+MagickExport MagickBooleanType ImportImagePixels(Image *image,
+ const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
+ const size_t rows,const char *map,const StorageType type,
+ const void *pixels,ExceptionInfo *exception)
+{
+ QuantumType
+ *quantum_map;
+
+ register ssize_t
+ i;
+
+ /*
+ Allocate image structure.
+ */
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ quantum_map=(QuantumType *) AcquireQuantumMemory(strlen(map),
+ sizeof(*quantum_map));
+ if (quantum_map == (QuantumType *) NULL)
+ ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
+ image->filename);
+ for (i=0; i < (ssize_t) strlen(map); i++)
+ {
+ switch (map[i])
+ {
+ case 'a':
+ case 'A':
{
- q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
- if (q == (Quantum *) NULL)
- break;
- for (x=0; x < (ssize_t) columns; x++)
- {
- for (i=0; i < (ssize_t) length; i++)
- {
- switch (quantum_map[i])
- {
- case RedQuantum:
- case CyanQuantum:
- {
- SetPixelRed(image,ScaleShortToQuantum(*p),q);
- break;
- }
- case GreenQuantum:
- case MagentaQuantum:
- {
- SetPixelGreen(image,ScaleShortToQuantum(*p),q);
- break;
- }
- case BlueQuantum:
- case YellowQuantum:
- {
- SetPixelBlue(image,ScaleShortToQuantum(*p),q);
- break;
- }
- case AlphaQuantum:
- {
- SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
- break;
- }
- case OpacityQuantum:
- {
- SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
- break;
- }
- case BlackQuantum:
- {
- SetPixelBlack(image,ScaleShortToQuantum(*p),q);
- break;
- }
- case IndexQuantum:
- {
- SetPixelGray(image,ScaleShortToQuantum(*p),q);
- break;
- }
- default:
- break;
- }
- p++;
- }
- q+=GetPixelChannels(image);
- }
- if (SyncAuthenticPixels(image,exception) == MagickFalse)
- break;
+ quantum_map[i]=AlphaQuantum;
+ image->matte=MagickTrue;
+ break;
+ }
+ case 'B':
+ case 'b':
+ {
+ quantum_map[i]=BlueQuantum;
+ break;
+ }
+ case 'C':
+ case 'c':
+ {
+ quantum_map[i]=CyanQuantum;
+ (void) SetImageColorspace(image,CMYKColorspace,exception);
+ break;
+ }
+ case 'g':
+ case 'G':
+ {
+ quantum_map[i]=GreenQuantum;
+ break;
+ }
+ case 'K':
+ case 'k':
+ {
+ quantum_map[i]=BlackQuantum;
+ (void) SetImageColorspace(image,CMYKColorspace,exception);
+ break;
+ }
+ case 'I':
+ case 'i':
+ {
+ quantum_map[i]=IndexQuantum;
+ break;
+ }
+ case 'm':
+ case 'M':
+ {
+ quantum_map[i]=MagentaQuantum;
+ (void) SetImageColorspace(image,CMYKColorspace,exception);
+ break;
+ }
+ case 'O':
+ case 'o':
+ {
+ quantum_map[i]=OpacityQuantum;
+ image->matte=MagickTrue;
+ break;
+ }
+ case 'P':
+ case 'p':
+ {
+ quantum_map[i]=UndefinedQuantum;
+ break;
+ }
+ case 'R':
+ case 'r':
+ {
+ quantum_map[i]=RedQuantum;
+ break;
}
+ case 'Y':
+ case 'y':
+ {
+ quantum_map[i]=YellowQuantum;
+ (void) SetImageColorspace(image,CMYKColorspace,exception);
+ break;
+ }
+ default:
+ {
+ quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "UnrecognizedPixelMap","`%s'",map);
+ return(MagickFalse);
+ }
+ }
+ }
+ if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
+ return(MagickFalse);
+ /*
+ Transfer the pixels from the pixel data to the image.
+ */
+ switch (type)
+ {
+ case CharPixel:
+ {
+ ImportCharPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case DoublePixel:
+ {
+ ImportDoublePixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case FloatPixel:
+ {
+ ImportFloatPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case IntegerPixel:
+ {
+ ImportIntegerPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case LongPixel:
+ {
+ ImportLongPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case QuantumPixel:
+ {
+ ImportQuantumPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
+ break;
+ }
+ case ShortPixel:
+ {
+ ImportShortPixel(image,x_offset,y_offset,columns,rows,map,quantum_map,
+ pixels,exception);
break;
}
default:
projects / imagemagick / commitdiff