% MagickCore Pixel Stream Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% March 2000 %
% %
% %
-% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/exception-private.h"
#include "MagickCore/geometry.h"
#include "MagickCore/memory_.h"
+#include "MagickCore/memory-private.h"
#include "MagickCore/pixel.h"
#include "MagickCore/pixel-accessor.h"
#include "MagickCore/quantum.h"
if (stream_info == (StreamInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(stream_info,0,sizeof(*stream_info));
- stream_info->pixels=(unsigned char *) AcquireMagickMemory(
- sizeof(*stream_info->pixels));
+ stream_info->pixels=(unsigned char *) MagickAssumeAligned(
+ AcquireAlignedMemory(1,sizeof(*stream_info->pixels)));
if (stream_info->pixels == (unsigned char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
stream_info->map=ConstantString("RGB");
{
assert(cache_info != (CacheInfo *) NULL);
if (cache_info->mapped == MagickFalse)
- (void) RelinquishMagickMemory(cache_info->pixels);
+ (void) RelinquishAlignedMemory(cache_info->pixels);
else
(void) UnmapBlob(cache_info->pixels,(size_t) cache_info->length);
cache_info->pixels=(Quantum *) NULL;
if (cache_info->nexus_info != (NexusInfo **) NULL)
cache_info->nexus_info=DestroyPixelCacheNexus(cache_info->nexus_info,
cache_info->number_threads);
- if (cache_info->disk_semaphore != (SemaphoreInfo *) NULL)
- DestroySemaphoreInfo(&cache_info->disk_semaphore);
+ if (cache_info->file_semaphore != (SemaphoreInfo *) NULL)
+ RelinquishSemaphoreInfo(&cache_info->file_semaphore);
if (cache_info->semaphore != (SemaphoreInfo *) NULL)
- DestroySemaphoreInfo(&cache_info->semaphore);
+ RelinquishSemaphoreInfo(&cache_info->semaphore);
cache_info=(CacheInfo *) RelinquishMagickMemory(cache_info);
}
\f
if (stream_info->map != (char *) NULL)
stream_info->map=DestroyString(stream_info->map);
if (stream_info->pixels != (unsigned char *) NULL)
- stream_info->pixels=(unsigned char *) RelinquishMagickMemory(
+ stream_info->pixels=(unsigned char *) RelinquishAlignedMemory(
stream_info->pixels);
if (stream_info->stream != (Image *) NULL)
{
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- PixelChannel
- channel;
-
- channel=GetPixelChannelMapChannel(image,i);
+ PixelChannel channel=GetPixelChannelChannel(image,i);
pixel[channel]=q[i];
}
return(MagickTrue);
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- PixelChannel
- channel;
-
- channel=GetPixelChannelMapChannel(image,i);
+ PixelChannel channel=GetPixelChannelChannel(image,i);
pixel[channel]=p[i];
}
return(MagickTrue);
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetVirtualMetacontentFromStream() returns the associated pixel
-% channels corresponding with the last call to QueueAuthenticPixelsStream() or
+% GetVirtualMetacontentFromStream() returns the associated pixel channels
+% corresponding with the last call to QueueAuthenticPixelsStream() or
% GetVirtualPixelStream().
%
% The format of the GetVirtualMetacontentFromStream() method is:
% o image: the image.
%
*/
-static const void *GetVirtualMetacontentFromStream(
- const Image *image)
+static const void *GetVirtualMetacontentFromStream(const Image *image)
{
CacheInfo
*cache_info;
if (cache_info->length != (MagickSizeType) ((size_t) cache_info->length))
return(MagickFalse);
cache_info->mapped=MagickFalse;
- cache_info->pixels=(Quantum *) AcquireMagickMemory((size_t)
+ cache_info->pixels=(Quantum *) AcquireAlignedMemory(1,(size_t)
cache_info->length);
if (cache_info->pixels == (Quantum *) NULL)
{
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;
*/
number_pixels=(MagickSizeType) columns*rows;
length=(size_t) number_pixels*cache_info->number_channels*sizeof(Quantum);
+ if (cache_info->number_channels == 0)
+ length=number_pixels*sizeof(Quantum);
if (cache_info->metacontent_extent != 0)
length+=number_pixels*cache_info->metacontent_extent;
if (cache_info->pixels == (Quantum *) NULL)
}
}
else
- if (cache_info->length != length)
+ if (cache_info->length < length)
{
RelinquishStreamPixels(cache_info);
cache_info->length=length;
CacheInfo
*cache_info;
+ MagickBooleanType
+ status;
+
MagickSizeType
number_pixels;
(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;
cache_info->rows=rows;
number_pixels=(MagickSizeType) columns*rows;
length=(size_t) number_pixels*cache_info->number_channels*sizeof(Quantum);
+ if (cache_info->number_channels == 0)
+ length=number_pixels*sizeof(Quantum);
if (cache_info->metacontent_extent != 0)
length+=number_pixels*cache_info->metacontent_extent;
if (cache_info->pixels == (Quantum *) NULL)
{
- cache_info->pixels=(Quantum *) AcquireMagickMemory(length);
- cache_info->length=(MagickSizeType) length;
+ cache_info->length=length;
+ status=AcquireStreamPixels(cache_info,exception);
+ if (status == MagickFalse)
+ {
+ cache_info->length=0;
+ return((Quantum *) NULL);
+ }
}
else
- if (cache_info->length < (MagickSizeType) length)
+ if (cache_info->length < length)
{
- cache_info->pixels=(Quantum *) ResizeMagickMemory(
- cache_info->pixels,length);
- cache_info->length=(MagickSizeType) length;
+ RelinquishStreamPixels(cache_info);
+ cache_info->length=length;
+ status=AcquireStreamPixels(cache_info,exception);
+ if (status == MagickFalse)
+ {
+ cache_info->length=0;
+ return((Quantum *) NULL);
+ }
}
- if (cache_info->pixels == (void *) NULL)
- return((Quantum *) NULL);
cache_info->metacontent=(void *) NULL;
if (cache_info->metacontent_extent != 0)
cache_info->metacontent=(void *) (cache_info->pixels+number_pixels*
/*
Prepare stream for writing.
*/
- stream_info->pixels=(unsigned char *) ResizeQuantumMemory(
- stream_info->pixels,length,sizeof(*stream_info->pixels));
+ (void) RelinquishAlignedMemory(stream_info->pixels);
+ stream_info->pixels=(unsigned char *) AcquireAlignedMemory(1,length);
if (stream_info->pixels == (unsigned char *) NULL)
return(0);
+ (void) ResetMagickMemory(stream_info->pixels,0,length);
stream_info->image=image;
write_info=CloneImageInfo(stream_info->image_info);
(void) SetImageInfo(write_info,1,stream_info->exception);
assert(exception != (ExceptionInfo *) NULL);
read_info=CloneImageInfo(image_info);
stream_info->image_info=image_info;
+ stream_info->quantum_info=AcquireQuantumInfo(image_info,(Image *) NULL);
stream_info->exception=exception;
read_info->client_data=(void *) stream_info;
image=ReadStream(read_info,&WriteStreamImage,exception);
read_info=DestroyImageInfo(read_info);
+ stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
stream_info->quantum_info=AcquireQuantumInfo(image_info,image);
if (stream_info->quantum_info == (QuantumInfo *) NULL)
image=DestroyImage(image);
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=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(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=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(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=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
q=(unsigned int *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
q=(MagickSizeType *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
q=(Quantum *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
q=(unsigned short *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"BGRP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"I") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGB") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBA") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
if (LocaleCompare(stream_info->map,"RGBP") == 0)
{
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
}
break;
}
- p=GetVirtualPixelQueue(image);
+ p=GetAuthenticPixelQueue(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);