% MagickCore Pixel Stream Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% March 2000 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2018 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 %
% obtain a copy of the License at %
% %
-% http://www.imagemagick.org/script/license.php %
+% https://www.imagemagick.org/script/license.php %
% %
% Unless required by applicable law or agreed to in writing, software %
% distributed under the License is distributed on an "AS IS" BASIS, %
#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/policy.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
#include "MagickCore/semaphore.h"
}
#endif
\f
+static ssize_t
+ cache_anonymous_memory = (-1);
+\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
%
% The format of the AcquireStreamInfo method is:
%
-% StreamInfo *AcquireStreamInfo(const ImageInfo *image_info)
+% StreamInfo *AcquireStreamInfo(const ImageInfo *image_info,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport StreamInfo *AcquireStreamInfo(const ImageInfo *image_info)
+MagickExport StreamInfo *AcquireStreamInfo(const ImageInfo *image_info,
+ ExceptionInfo *exception)
{
StreamInfo
*stream_info;
- stream_info=(StreamInfo *) AcquireMagickMemory(sizeof(*stream_info));
- 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=(StreamInfo *) AcquireCriticalMemory(sizeof(*stream_info));
+ (void) memset(stream_info,0,sizeof(*stream_info));
+ 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");
stream_info->storage_type=CharPixel;
- stream_info->stream=AcquireImage(image_info);
- stream_info->signature=MagickSignature;
+ stream_info->stream=AcquireImage(image_info,exception);
+ stream_info->signature=MagickCoreSignature;
return(stream_info);
}
\f
{
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;
destroy;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
destroy=MagickFalse;
LockSemaphoreInfo(cache_info->semaphore);
cache_info->reference_count--;
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
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(stream_info != (StreamInfo *) NULL);
- assert(stream_info->signature == MagickSignature);
+ assert(stream_info->signature == MagickCoreSignature);
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)
{
}
if (stream_info->quantum_info != (QuantumInfo *) NULL)
stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
- stream_info->signature=(~MagickSignature);
+ stream_info->signature=(~MagickCoreSignature);
stream_info=(StreamInfo *) RelinquishMagickMemory(stream_info);
return(stream_info);
}
*cache_info;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
return(cache_info->metacontent);
}
\f
*pixels;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
pixels=QueueAuthenticPixelsStream(image,x,y,columns,rows,exception);
*cache_info;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
return(cache_info->pixels);
}
\f
% The format of the GetOneAuthenticPixelFromStream() method is:
%
% MagickBooleanType GetOneAuthenticPixelFromStream(const Image image,
-% const ssize_t x,const ssize_t y,PixelPacket *pixel,
+% const ssize_t x,const ssize_t y,Quantum *pixel,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
*/
static MagickBooleanType GetOneAuthenticPixelFromStream(Image *image,
- const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+ const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
{
register Quantum
- *q;
+ *p;
+
+ register ssize_t
+ i;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- *pixel=image->background_color;
- q=GetAuthenticPixelsStream(image,x,y,1,1,exception);
- if (q != (Quantum *) NULL)
- return(MagickFalse);
- GetPixelPacket(image,q,pixel);
+ assert(image->signature == MagickCoreSignature);
+ (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
+ p=GetAuthenticPixelsStream(image,x,y,1,1,exception);
+ if (p == (Quantum *) NULL)
+ {
+ 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++)
+ {
+ PixelChannel channel = GetPixelChannelChannel(image,i);
+ pixel[channel]=p[i];
+ }
return(MagickTrue);
}
\f
%
% MagickBooleanType GetOneVirtualPixelFromStream(const Image image,
% const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
-% const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+% const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
*/
static MagickBooleanType GetOneVirtualPixelFromStream(const Image *image,
const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
- PixelPacket *pixel,ExceptionInfo *exception)
+ Quantum *pixel,ExceptionInfo *exception)
{
const Quantum
*p;
+ register ssize_t
+ i;
+
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- *pixel=image->background_color;
+ assert(image->signature == MagickCoreSignature);
+ (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
p=GetVirtualPixelStream(image,virtual_pixel_method,x,y,1,1,exception);
if (p == (const Quantum *) NULL)
- return(MagickFalse);
- GetPixelPacket(image,p,pixel);
- if (image->colorspace == CMYKColorspace)
- pixel->black=GetPixelBlack(image,p);
+ {
+ 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++)
+ {
+ PixelChannel channel = GetPixelChannelChannel(image,i);
+ pixel[channel]=p[i];
+ }
return(MagickTrue);
}
\f
MagickPrivate const void *GetStreamInfoClientData(StreamInfo *stream_info)
{
assert(stream_info != (StreamInfo *) NULL);
- assert(stream_info->signature == MagickSignature);
+ assert(stream_info->signature == MagickCoreSignature);
return(stream_info->client_data);
}
\f
% %
% %
% %
-+ G e t V i r t u a l P i x e l s F r o m S t r e a m %
++ G e t V i r t u a l P i x e l s F r o m S t r e a m %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetVirtualPixelsStream() returns the pixels associated with the last
-% call to QueueAuthenticPixelsStream() or GetVirtualPixelStream().
+% GetVirtualPixelsStream() returns the pixels associated with the last call to
+% QueueAuthenticPixelsStream() or GetVirtualPixelStream().
%
% The format of the GetVirtualPixelsStream() method is:
%
*cache_info;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
return(cache_info->pixels);
}
\f
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% 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;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
return(cache_info->metacontent);
}
\f
{
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->length);
- if (cache_info->pixels == (Quantum *) NULL)
+ if (cache_anonymous_memory < 0)
{
- cache_info->mapped=MagickTrue;
- cache_info->pixels=(Quantum *) MapBlob(-1,IOMode,0,(size_t)
- cache_info->length);
+ char
+ *value;
+
+ /*
+ Does the security policy require anonymous mapping for pixel cache?
+ */
+ cache_anonymous_memory=0;
+ value=GetPolicyValue("pixel-cache-memory");
+ if (value == (char *) NULL)
+ value=GetPolicyValue("cache:memory-map");
+ if (LocaleCompare(value,"anonymous") == 0)
+ {
+#if defined(MAGICKCORE_HAVE_MMAP) && defined(MAP_ANONYMOUS)
+ cache_anonymous_memory=1;
+#else
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ MissingDelegateError,"DelegateLibrarySupportNotBuiltIn",
+ "'%s' (policy requires anonymous memory mapping)",
+ cache_info->filename);
+#endif
+ }
+ value=DestroyString(value);
}
+ if (cache_anonymous_memory <= 0)
+ {
+ cache_info->mapped=MagickFalse;
+ cache_info->pixels=(Quantum *) MagickAssumeAligned(
+ AcquireAlignedMemory(1,(size_t) cache_info->length));
+ }
+ else
+ {
+ cache_info->mapped=MagickTrue;
+ cache_info->pixels=(Quantum *) MapBlob(-1,IOMode,0,(size_t)
+ cache_info->length);
+ }
if (cache_info->pixels == (Quantum *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
size_t
length;
+ magick_unreferenced(virtual_pixel_method);
+
/*
Validate pixel cache geometry.
*/
assert(image != (const Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if ((x < 0) || (y < 0) ||
return((Quantum *) NULL);
}
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
/*
Pixels are stored in a temporary buffer until they are synced to the cache.
*/
number_pixels=(MagickSizeType) columns*rows;
length=(size_t) number_pixels*cache_info->number_channels*sizeof(Quantum);
+ if (cache_info->number_channels == 0)
+ length=(size_t) 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;
MagickBooleanType
status;
- (void) CopyMagickString(stream_info->stream->filename,filename,MaxTextExtent);
+ (void) CopyMagickString(stream_info->stream->filename,filename,
+ MagickPathExtent);
status=OpenBlob(image_info,stream_info->stream,WriteBinaryBlobMode,exception);
return(status);
}
CacheInfo
*cache_info;
+ MagickBooleanType
+ status;
+
MagickSizeType
number_pixels;
return((Quantum *) NULL);
}
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
if ((image->storage_class != GetPixelCacheStorageClass(image->cache)) ||
(image->colorspace != GetPixelCacheColorspace(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=(size_t) 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*
Stream image pixels.
*/
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
+ assert(exception->signature == MagickCoreSignature);
read_info=CloneImageInfo(image_info);
read_info->cache=AcquirePixelCache(0);
GetPixelCacheMethods(&cache_methods);
cache_methods.get_virtual_pixel_handler=GetVirtualPixelStream;
+ cache_methods.get_virtual_pixels_handler=GetVirtualPixelsStream;
cache_methods.get_virtual_metacontent_from_handler=
GetVirtualMetacontentFromStream;
- cache_methods.get_virtual_pixels_handler=GetVirtualPixelsStream;
cache_methods.get_authentic_pixels_handler=GetAuthenticPixelsStream;
cache_methods.queue_authentic_pixels_handler=QueueAuthenticPixelsStream;
cache_methods.sync_authentic_pixels_handler=SyncAuthenticPixelsStream;
SetPixelCacheMethods(read_info->cache,&cache_methods);
read_info->stream=stream;
image=ReadImage(read_info,exception);
+ if (image != (Image *) NULL)
+ {
+ InitializePixelChannelMap(image);
+ ResetPixelCacheChannels(image);
+ }
read_info=DestroyImageInfo(read_info);
return(image);
}
% %
% %
% %
++ R e s e t S t r e a m A n o n y m o u s M e m o r y %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% ResetStreamAnonymousMemory() resets the anonymous_memory value.
+%
+% The format of the ResetStreamAnonymousMemory method is:
+%
+% void ResetStreamAnonymousMemory(void)
+%
+*/
+MagickPrivate void ResetStreamAnonymousMemory(void)
+{
+ cache_anonymous_memory=0;
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+ S e t S t r e a m I n f o C l i e n t D a t a %
% %
% %
const void *client_data)
{
assert(stream_info != (StreamInfo *) NULL);
- assert(stream_info->signature == MagickSignature);
+ assert(stream_info->signature == MagickCoreSignature);
stream_info->client_data=client_data;
}
\f
MagickExport void SetStreamInfoMap(StreamInfo *stream_info,const char *map)
{
assert(stream_info != (StreamInfo *) NULL);
- assert(stream_info->signature == MagickSignature);
+ assert(stream_info->signature == MagickCoreSignature);
(void) CloneString(&stream_info->map,map);
}
\f
const StorageType storage_type)
{
assert(stream_info != (StreamInfo *) NULL);
- assert(stream_info->signature == MagickSignature);
+ assert(stream_info->signature == MagickCoreSignature);
stream_info->storage_type=storage_type;
}
\f
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;
}
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
packet_size*=strlen(stream_info->map);
length=packet_size*cache_info->columns*cache_info->rows;
if (image != stream_info->image)
/*
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) memset(stream_info->pixels,0,length);
stream_info->image=image;
write_info=CloneImageInfo(stream_info->image_info);
(void) SetImageInfo(write_info,1,stream_info->exception);
*read_info;
assert(image_info != (const ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(stream_info != (StreamInfo *) NULL);
- assert(stream_info->signature == MagickSignature);
+ assert(stream_info->signature == MagickCoreSignature);
assert(exception != (ExceptionInfo *) NULL);
read_info=CloneImageInfo(image_info);
stream_info->image_info=image_info;
+ stream_info->quantum_info=AcquireQuantumInfo(image_info,(Image *) NULL);
+ if (stream_info->quantum_info == (QuantumInfo *) NULL)
+ {
+ read_info=DestroyImageInfo(read_info);
+ return((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);
length;
assert(stream_info != (StreamInfo *) NULL);
- assert(stream_info->signature == MagickSignature);
+ assert(stream_info->signature == MagickCoreSignature);
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
length=strlen(stream_info->map);
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(MagickFalse);
}
+ (void) memset(quantum_map,0,length*sizeof(*quantum_map));
for (i=0; i < (ssize_t) length; i++)
{
switch (stream_info->map[i])
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
{
p=GetAuthenticPixelQueue(image);
if (p == (const Quantum *) NULL)
- break;
+ break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar((Quantum) 0);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
- p++;
+ *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(image,p)));
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar((Quantum) 0);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
}
case IndexQuantum:
{
- *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
break;
}
default:
}
q++;
}
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
quantum_info->scale+quantum_info->minimum);
*q++=(double) ((QuantumScale*GetPixelRed(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
quantum_info->scale+quantum_info->minimum);
*q++=(double) ((QuantumScale*GetPixelAlpha(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=(double) ((QuantumScale*GetPixelRed(image,p))*
quantum_info->scale+quantum_info->minimum);
*q++=0.0;
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
{
*q++=(double) ((QuantumScale*GetPixelIntensity(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
quantum_info->scale+quantum_info->minimum);
*q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
quantum_info->scale+quantum_info->minimum);
*q++=(double) ((QuantumScale*GetPixelAlpha(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
quantum_info->scale+quantum_info->minimum);
*q++=0.0;
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
}
q++;
}
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
quantum_info->scale+quantum_info->minimum);
*q++=(float) ((QuantumScale*GetPixelRed(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
quantum_info->scale+quantum_info->minimum);
*q++=(float) ((QuantumScale*(Quantum) (GetPixelAlpha(image,p)))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=(float) ((QuantumScale*GetPixelRed(image,p))*
quantum_info->scale+quantum_info->minimum);
*q++=0.0;
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
{
*q++=(float) ((QuantumScale*GetPixelIntensity(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
quantum_info->scale+quantum_info->minimum);
*q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
quantum_info->scale+quantum_info->minimum);
*q++=(float) ((QuantumScale*GetPixelAlpha(image,p))*
quantum_info->scale+quantum_info->minimum);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
quantum_info->scale+quantum_info->minimum);
*q++=0.0;
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
}
q++;
}
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
- case IntegerPixel:
+ case LongPixel:
{
register unsigned int
*q;
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));
- p++;
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ p+=GetPixelChannels(image);
}
break;
}
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));
- p++;
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
+ p+=GetPixelChannels(image);
}
break;
}
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;
- p++;
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=0;
+ p+=GetPixelChannels(image);
}
break;
}
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(
- GetPixelIntensity(image,p));
- p++;
+ *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
+ p+=GetPixelChannels(image);
}
break;
}
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));
- p++;
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ p+=GetPixelChannels(image);
}
break;
}
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)));
- p++;
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
+ p+=GetPixelChannels(image);
}
break;
}
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;
- p++;
+ *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+ *q++=0;
+ p+=GetPixelChannels(image);
}
break;
}
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(ClampToQuantum(GetPixelIntensity(image,p)));
break;
}
default:
- *q=0;
+ break;
}
q++;
}
- p++;
+ p+=GetPixelChannels(image);
}
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);
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));
- p++;
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ p+=GetPixelChannels(image);
}
break;
}
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)));
- p++;
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
}
break;
}
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;
- p++;
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=0U;
+ p+=GetPixelChannels(image);
}
break;
}
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
- p++;
+ *q++=ScaleQuantumToLongLong(ClampToQuantum(
+ GetPixelIntensity(image,p)));
+ p+=GetPixelChannels(image);
}
break;
}
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));
- p++;
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ p+=GetPixelChannels(image);
}
break;
}
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)));
- p++;
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
+ p+=GetPixelChannels(image);
}
break;
}
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;
- p++;
+ *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+ *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+ *q++=0U;
+ p+=GetPixelChannels(image);
}
break;
}
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(ClampToQuantum(
+ GetPixelIntensity(image,p)));
break;
}
default:
- break;
+ *q=0;
}
q++;
}
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=GetPixelBlue(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=GetPixelBlue(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
- *q++=(Quantum) (GetPixelAlpha(image,p));
- p++;
+ *q++=GetPixelAlpha(image,p);
+ p+=GetPixelChannels(image);
}
break;
}
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
*q++=0;
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=GetPixelIntensity(image,p);
- p++;
+ *q++=ClampToQuantum(GetPixelIntensity(image,p));
+ p+=GetPixelChannels(image);
}
break;
}
*q++=GetPixelRed(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=GetPixelRed(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
- *q++=(Quantum) (GetPixelAlpha(image,p));
- p++;
+ *q++=GetPixelAlpha(image,p);
+ p+=GetPixelChannels(image);
}
break;
}
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
*q++=0U;
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
}
case IndexQuantum:
{
- *q=(GetPixelIntensity(image,p));
+ *q=ClampToQuantum(GetPixelIntensity(image,p));
break;
}
default:
}
q++;
}
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(image,p)));
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=0;
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
break;
for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
- p++;
+ *q++=ScaleQuantumToShort(ClampToQuantum(
+ GetPixelIntensity(image,p)));
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(image,p)));
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=0;
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
}
case IndexQuantum:
{
- *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ *q=ScaleQuantumToShort(ClampToQuantum(
+ GetPixelIntensity(image,p)));
break;
}
default:
}
q++;
}
- p++;
+ p+=GetPixelChannels(image);
}
break;
}
stream_handler;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
cache_info=(CacheInfo *) image->cache;
- assert(cache_info->signature == MagickSignature);
+ assert(cache_info->signature == MagickCoreSignature);
stream_handler=GetBlobStreamHandler(image);
if (stream_handler == (StreamHandler) NULL)
{
% The format of the WriteStream() method is:
%
% MagickBooleanType WriteStream(const ImageInfo *image_info,Image *,
-% StreamHandler stream)
+% StreamHandler stream,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o stream: A callback method.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType WriteStream(const ImageInfo *image_info,
- Image *image,StreamHandler stream)
+ Image *image,StreamHandler stream,ExceptionInfo *exception)
{
ImageInfo
*write_info;
status;
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
write_info=CloneImageInfo(image_info);
+ *write_info->magick='\0';
write_info->stream=stream;
- status=WriteImage(write_info,image,&image->exception);
+ status=WriteImage(write_info,image,exception);
write_info=DestroyImageInfo(write_info);
return(status);
}
projects / imagemagick / blobdiff