#include "magick/exception-private.h"
#include "magick/geometry.h"
#include "magick/memory_.h"
+#include "magick/pixel.h"
#include "magick/quantum.h"
#include "magick/quantum-private.h"
#include "magick/semaphore.h"
RectangleInfo
extract_info;
- long
+ ssize_t
y;
ExceptionInfo
const void
*client_data;
- unsigned long
+ size_t
signature;
};
\f
#endif
static const PixelPacket
- *GetVirtualPixelStream(const Image *,const VirtualPixelMethod,const long,
- const long,const unsigned long,const unsigned long,ExceptionInfo *);
+ *GetVirtualPixelStream(const Image *,const VirtualPixelMethod,const ssize_t,
+ const ssize_t,const size_t,const size_t,ExceptionInfo *);
static MagickBooleanType
StreamImagePixels(const StreamInfo *,const Image *,ExceptionInfo *),
SyncAuthenticPixelsStream(Image *,ExceptionInfo *);
static PixelPacket
- *QueueAuthenticPixelsStream(Image *,const long,const long,const unsigned long,
- const unsigned long,ExceptionInfo *);
+ *QueueAuthenticPixelsStream(Image *,const ssize_t,const ssize_t,const size_t,
+ const size_t,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
StreamInfo
*stream_info;
- stream_info=(StreamInfo *) AcquireMagickMemory(sizeof(*stream_info));
+ stream_info=(StreamInfo *) AcquireAlignedMemory(1,sizeof(*stream_info));
if (stream_info == (StreamInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(stream_info,0,sizeof(*stream_info));
cache_info=(CacheInfo *) image->cache;
assert(cache_info->signature == MagickSignature);
destroy=MagickFalse;
- (void) LockSemaphoreInfo(cache_info->semaphore);
+ LockSemaphoreInfo(cache_info->semaphore);
cache_info->reference_count--;
if (cache_info->reference_count == 0)
destroy=MagickTrue;
- (void) UnlockSemaphoreInfo(cache_info->semaphore);
+ UnlockSemaphoreInfo(cache_info->semaphore);
if (destroy == MagickFalse)
return;
RelinquishStreamPixels(cache_info);
%
% The format of the GetAuthenticPixelsStream() method is:
%
-% PixelPacket *GetAuthenticPixelsStream(Image *image,const long x,
-% const long y,const unsigned long columns,const unsigned long rows,
+% PixelPacket *GetAuthenticPixelsStream(Image *image,const ssize_t x,
+% const ssize_t y,const size_t columns,const size_t rows,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
% o exception: return any errors or warnings in this structure.
%
*/
-static PixelPacket *GetAuthenticPixelsStream(Image *image,const long x,
- const long y,const unsigned long columns,const unsigned long rows,
+static PixelPacket *GetAuthenticPixelsStream(Image *image,const ssize_t x,
+ const ssize_t y,const size_t columns,const size_t rows,
ExceptionInfo *exception)
{
PixelPacket
% The format of the GetOneAuthenticPixelFromStream() method is:
%
% MagickBooleanType GetOneAuthenticPixelFromStream(const Image image,
-% const long x,const long y,PixelPacket *pixel,ExceptionInfo *exception)
+% const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
*/
static MagickBooleanType GetOneAuthenticPixelFromStream(Image *image,
- const long x,const long y,PixelPacket *pixel,ExceptionInfo *exception)
+ const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
{
register PixelPacket
*pixels;
% The format of the GetOneVirtualPixelFromStream() method is:
%
% MagickBooleanType GetOneVirtualPixelFromStream(const Image image,
-% const VirtualPixelMethod virtual_pixel_method,const long x,
-% const long y,PixelPacket *pixel,ExceptionInfo *exception)
+% const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
+% const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
*/
static MagickBooleanType GetOneVirtualPixelFromStream(const Image *image,
- const VirtualPixelMethod virtual_pixel_method,const long x,const long y,
+ const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
PixelPacket *pixel,ExceptionInfo *exception)
{
const PixelPacket
% The format of the GetVirtualPixelStream() method is:
%
% const PixelPacket *GetVirtualPixelStream(const Image *image,
-% const VirtualPixelMethod virtual_pixel_method,const long x,
-% const long y,const unsigned long columns,const unsigned long rows,
+% const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
+% const ssize_t y,const size_t columns,const size_t rows,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
}
static const PixelPacket *GetVirtualPixelStream(const Image *image,
- const VirtualPixelMethod magick_unused(virtual_pixel_method),const long x,
- const long y,const unsigned long columns,const unsigned long rows,
+ const VirtualPixelMethod magick_unused(virtual_pixel_method),const ssize_t x,
+ const ssize_t y,const size_t columns,const size_t rows,
ExceptionInfo *exception)
{
CacheInfo
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- if ((x < 0) || (y < 0) || ((x+(long) columns) > (long) image->columns) ||
- ((y+(long) rows) > (long) image->rows) || (columns == 0) || (rows == 0))
+ if ((x < 0) || (y < 0) ||
+ ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
+ ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
+ (columns == 0) || (rows == 0))
{
(void) ThrowMagickException(exception,GetMagickModule(),StreamError,
"ImageDoesNotContainTheStreamGeometry","`%s'",image->filename);
%
% The format of the QueueAuthenticPixelsStream() method is:
%
-% PixelPacket *QueueAuthenticPixelsStream(Image *image,const long x,
-% const long y,const unsigned long columns,const unsigned long rows,
+% PixelPacket *QueueAuthenticPixelsStream(Image *image,const ssize_t x,
+% const ssize_t y,const size_t columns,const size_t rows,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
% pixels.
%
*/
-static PixelPacket *QueueAuthenticPixelsStream(Image *image,const long x,
- const long y,const unsigned long columns,const unsigned long rows,
+static PixelPacket *QueueAuthenticPixelsStream(Image *image,const ssize_t x,
+ const ssize_t y,const size_t columns,const size_t rows,
ExceptionInfo *exception)
{
CacheInfo
Validate pixel cache geometry.
*/
assert(image != (Image *) NULL);
- if ((x < 0) || (y < 0) || ((x+(long) columns) > (long) image->columns) ||
- ((y+(long) rows) > (long) image->rows) || (columns == 0) || (rows == 0))
+ if ((x < 0) || (y < 0) || ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
+ ((y+(ssize_t) rows) > (ssize_t) image->rows) || (columns == 0) || (rows == 0))
{
(void) ThrowMagickException(exception,GetMagickModule(),StreamError,
"ImageDoesNotContainTheStreamGeometry","`%s'",image->filename);
static size_t WriteStreamImage(const Image *image,const void *pixels,
const size_t columns)
{
+ CacheInfo
+ *cache_info;
+
RectangleInfo
extract_info;
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(long); break;
+ case LongPixel: packet_size=sizeof(ssize_t); 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);
packet_size*=strlen(stream_info->map);
- length=packet_size*image->columns;
+ length=packet_size*cache_info->columns*cache_info->rows;
if (image != stream_info->image)
{
ImageInfo
*/
stream_info->pixels=(unsigned char *) ResizeQuantumMemory(
stream_info->pixels,length,sizeof(*stream_info->pixels));
- if (pixels == (unsigned char *) NULL)
+ if (stream_info->pixels == (unsigned char *) NULL)
return(0);
stream_info->image=image;
write_info=CloneImageInfo(stream_info->image_info);
- (void) SetImageInfo(write_info,MagickFalse,stream_info->exception);
+ (void) SetImageInfo(write_info,1,stream_info->exception);
if (write_info->extract != (char *) NULL)
(void) ParseAbsoluteGeometry(write_info->extract,
&stream_info->extract_info);
return(count == 0 ? 0 : columns);
}
if ((stream_info->y < extract_info.y) ||
- (stream_info->y >= (long) (extract_info.y+extract_info.height)))
+ (stream_info->y >= (ssize_t) (extract_info.y+extract_info.height)))
{
stream_info->y++;
return(columns);
*/
(void) StreamImagePixels(stream_info,image,stream_info->exception);
length=packet_size*extract_info.width;
- count=WriteBlob(stream_info->stream,length,stream_info->pixels+
- packet_size*extract_info.x);
+ count=WriteBlob(stream_info->stream,length,stream_info->pixels+packet_size*
+ extract_info.x);
stream_info->y++;
return(count == 0 ? 0 : columns);
}
QuantumType
*quantum_map;
- register long
+ register ssize_t
i,
x;
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(MagickFalse);
}
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (stream_info->map[i])
{
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(p->blue);
- *q++=ScaleQuantumToChar(p->green);
- *q++=ScaleQuantumToChar(p->red);
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(p->blue);
- *q++=ScaleQuantumToChar(p->green);
- *q++=ScaleQuantumToChar(p->red);
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(p->blue);
- *q++=ScaleQuantumToChar(p->green);
- *q++=ScaleQuantumToChar(p->red);
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
*q++=ScaleQuantumToChar((Quantum) 0);
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));
p++;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(p->red);
- *q++=ScaleQuantumToChar(p->green);
- *q++=ScaleQuantumToChar(p->blue);
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(p->red);
- *q++=ScaleQuantumToChar(p->green);
- *q++=ScaleQuantumToChar(p->blue);
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(p->red);
- *q++=ScaleQuantumToChar(p->green);
- *q++=ScaleQuantumToChar(p->blue);
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
*q++=ScaleQuantumToChar((Quantum) 0);
p++;
}
if (p == (const PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToChar(p->red);
+ *q=ScaleQuantumToChar(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToChar(p->green);
+ *q=ScaleQuantumToChar(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToChar(p->blue);
+ *q=ScaleQuantumToChar(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
+ *q=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToChar(p->opacity);
+ *q=ScaleQuantumToChar(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*((Quantum) (QuantumRange-p->opacity)))*
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetAlphaPixelComponent(p))*
quantum_info->scale+quantum_info->minimum);
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
*q++=0.0;
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=(double) ((QuantumScale*PixelIntensityToQuantum(p))*
quantum_info->scale+quantum_info->minimum);
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*((Quantum) (QuantumRange-p->opacity)))*
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetAlphaPixelComponent(p))*
quantum_info->scale+quantum_info->minimum);
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(double) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
*q++=0.0;
p++;
}
if (p == (const PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=(double) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
+ *q=(double) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(double) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
+ *q=(double) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(double) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
+ *q=(double) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case AlphaQuantum:
{
- *q=(double) ((QuantumScale*((Quantum) (QuantumRange-
- p->opacity)))*quantum_info->scale+quantum_info->minimum);
+ *q=(double) ((QuantumScale*GetAlphaPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case OpacityQuantum:
{
- *q=(double) ((QuantumScale*p->opacity)*quantum_info->scale+
- quantum_info->minimum);
+ *q=(double) ((QuantumScale*GetOpacityPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case BlackQuantum:
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*(Quantum) (QuantumRange-p->opacity))*
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*(Quantum) (GetAlphaPixelComponent(p)))*
quantum_info->scale+quantum_info->minimum);
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
*q++=0.0;
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=(float) ((QuantumScale*PixelIntensityToQuantum(p))*
quantum_info->scale+quantum_info->minimum);
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*((Quantum) (QuantumRange-p->opacity)))*
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetAlphaPixelComponent(p))*
quantum_info->scale+quantum_info->minimum);
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
- *q++=(float) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
*q++=0.0;
p++;
}
if (p == (const PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=(float) ((QuantumScale*p->red)*quantum_info->scale+
- quantum_info->minimum);
+ *q=(float) ((QuantumScale*GetRedPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(float) ((QuantumScale*p->green)*quantum_info->scale+
- quantum_info->minimum);
+ *q=(float) ((QuantumScale*GetGreenPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(float) ((QuantumScale*p->blue)*quantum_info->scale+
- quantum_info->minimum);
+ *q=(float) ((QuantumScale*GetBluePixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case AlphaQuantum:
{
- *q=(float) ((QuantumScale*((Quantum) (QuantumRange-
- p->opacity)))*quantum_info->scale+quantum_info->minimum);
+ *q=(float) ((QuantumScale*GetAlphaPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case OpacityQuantum:
{
- *q=(float) ((QuantumScale*p->opacity)*quantum_info->scale+
- quantum_info->minimum);
+ *q=(float) ((QuantumScale*GetOpacityPixelComponent(p))*
+ quantum_info->scale+quantum_info->minimum);
break;
}
case BlackQuantum:
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(p->blue);
- *q++=(unsigned int) ScaleQuantumToLong(p->green);
- *q++=(unsigned int) ScaleQuantumToLong(p->red);
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(p->blue);
- *q++=(unsigned int) ScaleQuantumToLong(p->green);
- *q++=(unsigned int) ScaleQuantumToLong(p->red);
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
- p->opacity));
+ GetOpacityPixelComponent(p)));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(p->blue);
- *q++=(unsigned int) ScaleQuantumToLong(p->green);
- *q++=(unsigned int) ScaleQuantumToLong(p->red);
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=0U;
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=(unsigned int) ScaleQuantumToLong(
PixelIntensityToQuantum(p));
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(p->red);
- *q++=(unsigned int) ScaleQuantumToLong(p->green);
- *q++=(unsigned int) ScaleQuantumToLong(p->blue);
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(p->red);
- *q++=(unsigned int) ScaleQuantumToLong(p->green);
- *q++=(unsigned int) ScaleQuantumToLong(p->blue);
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=(unsigned int) ScaleQuantumToLong((Quantum)
- (QuantumRange-p->opacity));
+ (GetAlphaPixelComponent(p)));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(p->red);
- *q++=(unsigned int) ScaleQuantumToLong(p->green);
- *q++=(unsigned int) ScaleQuantumToLong(p->blue);
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=0U;
p++;
}
if (p == (const PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(p->red);
+ *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(p->green);
+ *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(p->blue);
+ *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
*q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
- p->opacity));
+ GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(p->opacity);
+ *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
}
case LongPixel:
{
- register unsigned long
+ register size_t
*q;
- q=(unsigned long *) stream_info->pixels;
+ q=(size_t *) stream_info->pixels;
if (LocaleCompare(stream_info->map,"BGR") == 0)
{
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(p->blue);
- *q++=ScaleQuantumToLong(p->green);
- *q++=ScaleQuantumToLong(p->red);
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(p->blue);
- *q++=ScaleQuantumToLong(p->green);
- *q++=ScaleQuantumToLong(p->red);
- *q++=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(p->blue);
- *q++=ScaleQuantumToLong(p->green);
- *q++=ScaleQuantumToLong(p->red);
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=0;
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=ScaleQuantumToLong(PixelIntensityToQuantum(p));
p++;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(p->red);
- *q++=ScaleQuantumToLong(p->green);
- *q++=ScaleQuantumToLong(p->blue);
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(p->red);
- *q++=ScaleQuantumToLong(p->green);
- *q++=ScaleQuantumToLong(p->blue);
- *q++=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(p->red);
- *q++=ScaleQuantumToLong(p->green);
- *q++=ScaleQuantumToLong(p->blue);
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=0;
p++;
}
if (p == (const PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToLong(p->red);
+ *q=ScaleQuantumToLong(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToLong(p->green);
+ *q=ScaleQuantumToLong(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToLong(p->blue);
+ *q=ScaleQuantumToLong(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
+ *q=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToLong(p->opacity);
+ *q=ScaleQuantumToLong(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=p->blue;
- *q++=p->green;
- *q++=p->red;
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=p->blue;
- *q++=p->green;
- *q++=p->red;
- *q++=(Quantum) (QuantumRange-p->opacity);
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=(Quantum) (GetAlphaPixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=p->blue;
- *q++=p->green;
- *q++=p->red;
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
*q++=0;
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=PixelIntensityToQuantum(p);
p++;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=p->red;
- *q++=p->green;
- *q++=p->blue;
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=p->red;
- *q++=p->green;
- *q++=p->blue;
- *q++=(Quantum) (QuantumRange-p->opacity);
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=(Quantum) (GetAlphaPixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=p->red;
- *q++=p->green;
- *q++=p->blue;
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
*q++=0U;
p++;
}
if (p == (const PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=(Quantum) 0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=p->red;
+ *q=GetRedPixelComponent(p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=p->green;
+ *q=GetGreenPixelComponent(p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=p->blue;
+ *q=GetBluePixelComponent(p);
break;
}
case AlphaQuantum:
{
- *q=(Quantum) (QuantumRange-p->opacity);
+ *q=(Quantum) (GetAlphaPixelComponent(p));
break;
}
case OpacityQuantum:
{
- *q=p->opacity;
+ *q=GetOpacityPixelComponent(p);
break;
}
case BlackQuantum:
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(p->blue);
- *q++=ScaleQuantumToShort(p->green);
- *q++=ScaleQuantumToShort(p->red);
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(p->blue);
- *q++=ScaleQuantumToShort(p->green);
- *q++=ScaleQuantumToShort(p->red);
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(p->blue);
- *q++=ScaleQuantumToShort(p->green);
- *q++=ScaleQuantumToShort(p->red);
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
*q++=0;
p++;
}
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
*q++=ScaleQuantumToShort(PixelIntensityToQuantum(p));
p++;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(p->red);
- *q++=ScaleQuantumToShort(p->green);
- *q++=ScaleQuantumToShort(p->blue);
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(p->red);
- *q++=ScaleQuantumToShort(p->green);
- *q++=ScaleQuantumToShort(p->blue);
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
break;
p=GetAuthenticPixelQueue(image);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(p->red);
- *q++=ScaleQuantumToShort(p->green);
- *q++=ScaleQuantumToShort(p->blue);
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
*q++=0;
p++;
}
if (p == (const PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) GetImageExtent(image); x++)
+ for (x=0; x < (ssize_t) GetImageExtent(image); x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToShort(p->red);
+ *q=ScaleQuantumToShort(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToShort(p->green);
+ *q=ScaleQuantumToShort(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToShort(p->blue);
+ *q=ScaleQuantumToShort(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
+ *q=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToShort(p->opacity);
+ *q=ScaleQuantumToShort(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
projects / imagemagick / blobdiff