q=GetAuthenticPixelsStream(image,x,y,1,1,exception);
if (q != (Quantum *) NULL)
{
- pixel[RedPixelChannel]=image->background_color.red;
- pixel[GreenPixelChannel]=image->background_color.green;
- pixel[BluePixelChannel]=image->background_color.blue;
- pixel[AlphaPixelChannel]=image->background_color.alpha;
+ pixel[RedPixelChannel]=ClampToQuantum(image->background_color.red);
+ pixel[GreenPixelChannel]=ClampToQuantum(image->background_color.green);
+ pixel[BluePixelChannel]=ClampToQuantum(image->background_color.blue);
+ pixel[BlackPixelChannel]=ClampToQuantum(image->background_color.black);
+ pixel[AlphaPixelChannel]=ClampToQuantum(image->background_color.alpha);
return(MagickFalse);
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
p=GetVirtualPixelStream(image,virtual_pixel_method,x,y,1,1,exception);
if (p == (const Quantum *) NULL)
{
- pixel[RedPixelChannel]=image->background_color.red;
- pixel[GreenPixelChannel]=image->background_color.green;
- pixel[BluePixelChannel]=image->background_color.blue;
- pixel[AlphaPixelChannel]=image->background_color.alpha;
+ pixel[RedPixelChannel]=ClampToQuantum(image->background_color.red);
+ pixel[GreenPixelChannel]=ClampToQuantum(image->background_color.green);
+ pixel[BluePixelChannel]=ClampToQuantum(image->background_color.blue);
+ pixel[BlackPixelChannel]=ClampToQuantum(image->background_color.black);
+ pixel[AlphaPixelChannel]=ClampToQuantum(image->background_color.alpha);
return(MagickFalse);
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
if (cache_info->pixels == (Quantum *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",
+ ResourceLimitError,"MemoryAllocationFailed","'%s'",
cache_info->filename);
return(MagickFalse);
}
(columns == 0) || (rows == 0))
{
(void) ThrowMagickException(exception,GetMagickModule(),StreamError,
- "ImageDoesNotContainTheStreamGeometry","`%s'",image->filename);
+ "ImageDoesNotContainTheStreamGeometry","'%s'",image->filename);
return((Quantum *) NULL);
}
cache_info=(CacheInfo *) image->cache;
(columns == 0) || (rows == 0))
{
(void) ThrowMagickException(exception,GetMagickModule(),StreamError,
- "ImageDoesNotContainTheStreamGeometry","`%s'",image->filename);
+ "ImageDoesNotContainTheStreamGeometry","'%s'",image->filename);
return((Quantum *) NULL);
}
stream_handler=GetBlobStreamHandler(image);
if (stream_handler == (StreamHandler) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),StreamError,
- "NoStreamHandlerIsDefined","`%s'",image->filename);
+ "NoStreamHandlerIsDefined","'%s'",image->filename);
return((Quantum *) NULL);
}
cache_info=(CacheInfo *) image->cache;
stream_info=(StreamInfo *) image->client_data;
switch (stream_info->storage_type)
{
- default: packet_size=sizeof(char); break;
- case CharPixel: packet_size=sizeof(char); break;
+ default: packet_size=sizeof(unsigned char); break;
+ case CharPixel: packet_size=sizeof(unsigned char); break;
case DoublePixel: packet_size=sizeof(double); break;
case FloatPixel: packet_size=sizeof(float); break;
- case IntegerPixel: packet_size=sizeof(int); break;
- case LongPixel: packet_size=sizeof(ssize_t); break;
+ case LongPixel: packet_size=sizeof(unsigned int); break;
+ case LongLongPixel: packet_size=sizeof(MagickSizeType); break;
case QuantumPixel: packet_size=sizeof(Quantum); break;
case ShortPixel: packet_size=sizeof(unsigned short); break;
}
if (quantum_map == (QuantumType *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
+ ResourceLimitError,"MemoryAllocationFailed","'%s'",image->filename);
return(MagickFalse);
}
for (i=0; i < (ssize_t) length; i++)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",stream_info->map);
+ "ColorSeparatedImageRequired","'%s'",stream_info->map);
return(MagickFalse);
}
case 'g':
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",stream_info->map);
+ "ColorSeparatedImageRequired","'%s'",stream_info->map);
return(MagickFalse);
}
case 'M':
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",stream_info->map);
+ "ColorSeparatedImageRequired","'%s'",stream_info->map);
return(MagickFalse);
}
case 'o':
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",stream_info->map);
+ "ColorSeparatedImageRequired","'%s'",stream_info->map);
return(MagickFalse);
}
default:
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",stream_info->map);
+ "UnrecognizedPixelMap","'%s'",stream_info->map);
return(MagickFalse);
}
}
q=(unsigned char *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
- break;
+ break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
q=(double *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
q=(float *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- case IntegerPixel:
+ case LongPixel:
{
register unsigned int
*q;
q=(unsigned int *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); 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));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=0U;
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=0;
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(
- GetPixelIntensity(image,p));
+ *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); 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((Quantum)
- (GetPixelAlpha(image,p)));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=0U;
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=0;
p++;
}
break;
}
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
case RedQuantum:
case CyanQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
+ *q=ScaleQuantumToLong(GetPixelRed(image,p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q=ScaleQuantumToLong(GetPixelGreen(image,p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q=ScaleQuantumToLong(GetPixelBlue(image,p));
break;
}
case AlphaQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
+ *q=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
break;
}
case OpacityQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
+ *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=(unsigned int) ScaleQuantumToLong(GetPixelBlack(image,p));
+ *q=ScaleQuantumToLong(GetPixelBlack(image,p));
break;
}
case IndexQuantum:
{
- *q=(unsigned int)
- ScaleQuantumToLong(GetPixelIntensity(image,p));
+ *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
break;
}
default:
- *q=0;
+ break;
}
q++;
}
}
break;
}
- case LongPixel:
+ case LongLongPixel:
{
- register size_t
+ register MagickSizeType
*q;
- q=(size_t *) stream_info->pixels;
+ q=(MagickSizeType *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=0;
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=0U;
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ *q++=ScaleQuantumToLongLong(
+ GetPixelIntensity(image,p));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetPixelRed(image,p));
- *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
- *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- *q++=0;
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=0U;
p++;
}
break;
}
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q=ScaleQuantumToLongLong(GetPixelRed(image,p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q=ScaleQuantumToLongLong(GetPixelGreen(image,p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q=ScaleQuantumToLongLong(GetPixelBlue(image,p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
+ *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToLong(GetPixelBlack(image,p));
+ *q=ScaleQuantumToLongLong(GetPixelBlack(image,p));
break;
}
case IndexQuantum:
{
- *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ *q=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
break;
}
default:
- break;
+ *q=0;
}
q++;
}
q=(Quantum *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
*q++=GetPixelBlue(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
- *q++=(Quantum) (GetPixelAlpha(image,p));
+ *q++=GetPixelAlpha(image,p);
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
*q++=GetPixelRed(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
- *q++=(Quantum) (GetPixelAlpha(image,p));
+ *q++=GetPixelAlpha(image,p);
p++;
}
break;
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
case IndexQuantum:
{
- *q=(GetPixelIntensity(image,p));
+ *q=GetPixelIntensity(image,p);
break;
}
default:
q=(unsigned short *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetAuthenticPixelQueue(image);
+ p=GetVirtualPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",stream_info->map);
+ "UnrecognizedPixelMap","'%s'",stream_info->map);
break;
}
}
if (stream_handler == (StreamHandler) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),StreamError,
- "NoStreamHandlerIsDefined","`%s'",image->filename);
+ "NoStreamHandlerIsDefined","'%s'",image->filename);
return(MagickFalse);
}
length=stream_handler(image,cache_info->pixels,(size_t) cache_info->columns);