% October 2002 %
% %
% %
-% Copyright 1999-2009 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 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 %
MagickExport RectangleInfo GetImageBoundingBox(const Image *image,
ExceptionInfo *exception)
{
- long
- y;
+ CacheView
+ *image_view;
MagickBooleanType
status;
register const PixelPacket
*p;
- CacheView
- *image_view;
+ ssize_t
+ y;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
bounds.width=0;
bounds.height=0;
- bounds.x=(long) image->columns;
- bounds.y=(long) image->rows;
+ bounds.x=(ssize_t) image->columns;
+ bounds.y=(ssize_t) image->rows;
GetMagickPixelPacket(image,&target[0]);
image_view=AcquireCacheView(image);
p=GetCacheViewVirtualPixels(image_view,0,0,1,1,exception);
SetMagickPixelPacket(image,p,GetCacheViewAuthenticIndexQueue(image_view),
&target[0]);
GetMagickPixelPacket(image,&target[1]);
- p=GetCacheViewVirtualPixels(image_view,(long) image->columns-1,0,1,1,
+ p=GetCacheViewVirtualPixels(image_view,(ssize_t) image->columns-1,0,1,1,
exception);
SetMagickPixelPacket(image,p,GetCacheViewAuthenticIndexQueue(image_view),
&target[1]);
GetMagickPixelPacket(image,&target[2]);
- p=GetCacheViewVirtualPixels(image_view,0,(long) image->rows-1,1,1,exception);
+ p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) image->rows-1,1,1,
+ exception);
SetMagickPixelPacket(image,p,GetCacheViewAuthenticIndexQueue(image_view),
&target[2]);
status=MagickTrue;
GetMagickPixelPacket(image,&zero);
-#if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
- #pragma omp parallel for shared(status)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
MagickPixelPacket
pixel;
bounding_box;
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
+ register ssize_t
x;
if (status == MagickFalse)
continue;
-#if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
# pragma omp critical (MagickCore_GetImageBoundingBox)
#endif
bounding_box=bounds;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
pixel=zero;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
SetMagickPixelPacket(image,p,indexes+x,&pixel);
if ((x < bounding_box.x) &&
(IsMagickColorSimilar(&pixel,&target[0]) == MagickFalse))
bounding_box.x=x;
- if ((x > (long) bounding_box.width) &&
+ if ((x > (ssize_t) bounding_box.width) &&
(IsMagickColorSimilar(&pixel,&target[1]) == MagickFalse))
- bounding_box.width=(unsigned long) x;
+ bounding_box.width=(size_t) x;
if ((y < bounding_box.y) &&
(IsMagickColorSimilar(&pixel,&target[0]) == MagickFalse))
bounding_box.y=y;
- if ((y > (long) bounding_box.height) &&
+ if ((y > (ssize_t) bounding_box.height) &&
(IsMagickColorSimilar(&pixel,&target[2]) == MagickFalse))
- bounding_box.height=(unsigned long) y;
+ bounding_box.height=(size_t) y;
p++;
}
-#if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
# pragma omp critical (MagickCore_GetImageBoundingBox)
#endif
{
%
% The format of the GetImageChannelDepth method is:
%
-% unsigned long GetImageDepth(const Image *image,ExceptionInfo *exception)
-% unsigned long GetImageChannelDepth(const Image *image,
+% size_t GetImageDepth(const Image *image,ExceptionInfo *exception)
+% size_t GetImageChannelDepth(const Image *image,
% const ChannelType channel,ExceptionInfo *exception)
%
% A description of each parameter follows:
% o exception: return any errors or warnings in this structure.
%
*/
-
-MagickExport unsigned long GetImageDepth(const Image *image,
- ExceptionInfo *exception)
+MagickExport size_t GetImageDepth(const Image *image,ExceptionInfo *exception)
{
- return(GetImageChannelDepth(image,AllChannels,exception));
+ return(GetImageChannelDepth(image,CompositeChannels,exception));
}
-MagickExport unsigned long GetImageChannelDepth(const Image *image,
+MagickExport size_t GetImageChannelDepth(const Image *image,
const ChannelType channel,ExceptionInfo *exception)
{
- long
- y;
+ CacheView
+ *image_view;
MagickBooleanType
status;
- register long
+ register ssize_t
id;
- unsigned long
+ size_t
*current_depth,
depth,
number_threads;
- CacheView
- *image_view;
+ ssize_t
+ y;
/*
Compute image depth.
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
number_threads=GetOpenMPMaximumThreads();
- current_depth=(unsigned long *) AcquireQuantumMemory(number_threads,
+ current_depth=(size_t *) AcquireQuantumMemory(number_threads,
sizeof(*current_depth));
- if (current_depth == (unsigned long *) NULL)
+ if (current_depth == (size_t *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
status=MagickTrue;
- for (id=0; id < (long) number_threads; id++)
+ for (id=0; id < (ssize_t) number_threads; id++)
current_depth[id]=1;
if ((image->storage_class == PseudoClass) && (image->matte == MagickFalse))
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
+ register ssize_t
i;
p=image->colormap;
-#if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
- #pragma omp parallel for shared(status)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
+ const int
+ id = GetOpenMPThreadId();
+
if (status == MagickFalse)
continue;
- id=GetOpenMPThreadId();
while (current_depth[id] < MAGICKCORE_QUANTUM_DEPTH)
{
MagickStatusType
status=0;
range=GetQuantumRange(current_depth[id]);
if ((channel & RedChannel) != 0)
- status|=p->red != ScaleAnyToQuantum(ScaleQuantumToAny(p->red,
+ status|=GetRedPixelComponent(p) != ScaleAnyToQuantum(ScaleQuantumToAny(GetRedPixelComponent(p),
range),range);
if ((channel & GreenChannel) != 0)
- status|=p->green != ScaleAnyToQuantum(ScaleQuantumToAny(p->green,
+ status|=GetGreenPixelComponent(p) != ScaleAnyToQuantum(ScaleQuantumToAny(GetGreenPixelComponent(p),
range),range);
if ((channel & BlueChannel) != 0)
- status|=p->blue != ScaleAnyToQuantum(ScaleQuantumToAny(p->blue,
+ status|=GetBluePixelComponent(p) != ScaleAnyToQuantum(ScaleQuantumToAny(GetBluePixelComponent(p),
range),range);
if (status == 0)
break;
p++;
}
depth=current_depth[0];
- for (id=1; id < (long) number_threads; id++)
+ for (id=1; id < (ssize_t) number_threads; id++)
if (depth < current_depth[id])
depth=current_depth[id];
- current_depth=(unsigned long *) RelinquishMagickMemory(current_depth);
+ current_depth=(size_t *) RelinquishMagickMemory(current_depth);
return(depth);
}
image_view=AcquireCacheView(image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
- #pragma omp parallel for shared(status)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
+ const int
+ id = GetOpenMPThreadId();
+
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
- id,
+ register ssize_t
x;
if (status == MagickFalse)
continue;
- id=GetOpenMPThreadId();
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
continue;
indexes=GetCacheViewVirtualIndexQueue(image_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
while (current_depth[id] < MAGICKCORE_QUANTUM_DEPTH)
{
status=0;
range=GetQuantumRange(current_depth[id]);
if ((channel & RedChannel) != 0)
- status|=p->red != ScaleAnyToQuantum(ScaleQuantumToAny(p->red,range),
- range);
+ status|=GetRedPixelComponent(p) != ScaleAnyToQuantum(
+ ScaleQuantumToAny(GetRedPixelComponent(p),range),range);
if ((channel & GreenChannel) != 0)
- status|=p->green != ScaleAnyToQuantum(ScaleQuantumToAny(p->green,
- range),range);
+ status|=GetGreenPixelComponent(p) != ScaleAnyToQuantum(
+ ScaleQuantumToAny(GetGreenPixelComponent(p),range),range);
if ((channel & BlueChannel) != 0)
- status|=p->blue != ScaleAnyToQuantum(ScaleQuantumToAny(p->blue,range),
- range);
+ status|=GetBluePixelComponent(p) != ScaleAnyToQuantum(
+ ScaleQuantumToAny(GetBluePixelComponent(p),range),range);
if (((channel & OpacityChannel) != 0) && (image->matte != MagickFalse))
- status|=p->opacity != ScaleAnyToQuantum(ScaleQuantumToAny(p->opacity,
- range),range);
+ status|=GetOpacityPixelComponent(p) != ScaleAnyToQuantum(
+ ScaleQuantumToAny(GetOpacityPixelComponent(p),range),range);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- status|=indexes[x] != ScaleAnyToQuantum(ScaleQuantumToAny(indexes[x],
- range),range);
+ status|=GetIndexPixelComponent(indexes+x) !=
+ ScaleAnyToQuantum(ScaleQuantumToAny(GetIndexPixelComponent(indexes+
+ x),range),range);
if (status == 0)
break;
current_depth[id]++;
}
image_view=DestroyCacheView(image_view);
depth=current_depth[0];
- for (id=1; id < (long) number_threads; id++)
+ for (id=1; id < (ssize_t) number_threads; id++)
if (depth < current_depth[id])
depth=current_depth[id];
- current_depth=(unsigned long *) RelinquishMagickMemory(current_depth);
+ current_depth=(size_t *) RelinquishMagickMemory(current_depth);
return(depth);
}
\f
%
% The format of the GetImageQuantumDepth method is:
%
-% unsigned long GetImageQuantumDepth(const Image *image,
+% size_t GetImageQuantumDepth(const Image *image,
% const MagickBooleanType constrain)
%
% A description of each parameter follows:
return(y);
}
-MagickExport unsigned long GetImageQuantumDepth(const Image *image,
+MagickExport size_t GetImageQuantumDepth(const Image *image,
const MagickBooleanType constrain)
{
- unsigned long
+ size_t
depth;
depth=image->depth;
if (depth <= 64)
depth=64;
if (constrain != MagickFalse)
- depth=(unsigned long) MagickMin((double) depth,(double)
+ depth=(size_t) MagickMin((double) depth,(double)
MAGICKCORE_QUANTUM_DEPTH);
return(depth);
}
MagickExport MagickBooleanType IsGrayImage(const Image *image,
ExceptionInfo *exception)
{
+ CacheView
+ *image_view;
+
ImageType
type;
register const PixelPacket
*p;
+ register ssize_t
+ x;
+
+ ssize_t
+ y;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
if (image->colorspace == CMYKColorspace)
return(MagickFalse);
type=BilevelType;
- switch (image->storage_class)
+ image_view=AcquireCacheView(image);
+ for (y=0; y < (ssize_t) image->rows; y++)
{
- case DirectClass:
- case UndefinedClass:
+ p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
+ if (p == (const PixelPacket *) NULL)
+ break;
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- long
- y;
-
- register long
- x;
-
- CacheView
- *image_view;
-
- image_view=AcquireCacheView(image);
- for (y=0; y < (long) image->rows; y++)
- {
- p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
- if (p == (const PixelPacket *) NULL)
- break;
- for (x=0; x < (long) image->columns; x++)
+ if (IsGrayPixel(p) == MagickFalse)
{
- if (IsGrayPixel(p) == MagickFalse)
- {
- type=UndefinedType;
- break;
- }
- if ((type == BilevelType) && (IsMonochromePixel(p) == MagickFalse))
- type=GrayscaleType;
- p++;
- }
- if (type == UndefinedType)
+ type=UndefinedType;
break;
- }
- image_view=DestroyCacheView(image_view);
- break;
+ }
+ if ((type == BilevelType) && (IsMonochromePixel(p) == MagickFalse))
+ type=GrayscaleType;
+ p++;
}
- case PseudoClass:
- {
- register long
- i;
-
- p=image->colormap;
- for (i=0; i < (long) image->colors; i++)
- {
- if (IsGrayPixel(p) == MagickFalse)
- {
- type=UndefinedType;
- break;
- }
- if ((type == BilevelType) && (IsMonochromePixel(p) == MagickFalse))
- type=GrayscaleType;
- p++;
- }
+ if (type == UndefinedType)
break;
- }
}
+ image_view=DestroyCacheView(image_view);
if (type == UndefinedType)
return(MagickFalse);
((Image *) image)->type=type;
MagickExport MagickBooleanType IsMonochromeImage(const Image *image,
ExceptionInfo *exception)
{
+ CacheView
+ *image_view;
+
ImageType
type;
+ register ssize_t
+ x;
+
register const PixelPacket
*p;
+ ssize_t
+ y;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
if (image->colorspace == CMYKColorspace)
return(MagickFalse);
type=BilevelType;
- switch (image->storage_class)
+ image_view=AcquireCacheView(image);
+ for (y=0; y < (ssize_t) image->rows; y++)
{
- case DirectClass:
- case UndefinedClass:
+ p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
+ if (p == (const PixelPacket *) NULL)
+ break;
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- long
- y;
-
- register long
- x;
-
- CacheView
- *image_view;
-
- image_view=AcquireCacheView(image);
- for (y=0; y < (long) image->rows; y++)
- {
- p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
- if (p == (const PixelPacket *) NULL)
- break;
- for (x=0; x < (long) image->columns; x++)
+ if (IsMonochromePixel(p) == MagickFalse)
{
- if (IsMonochromePixel(p) == MagickFalse)
- {
- type=UndefinedType;
- break;
- }
- p++;
- }
- if (type == UndefinedType)
+ type=UndefinedType;
break;
- }
- image_view=DestroyCacheView(image_view);
- if (y == (long) image->rows)
- ((Image *) image)->type=BilevelType;
- break;
+ }
+ p++;
}
- case PseudoClass:
- {
- register long
- i;
-
- p=image->colormap;
- for (i=0; i < (long) image->colors; i++)
- {
- if (IsMonochromePixel(p) == MagickFalse)
- {
- type=UndefinedType;
- break;
- }
- p++;
- }
+ if (type == UndefinedType)
break;
- }
}
+ image_view=DestroyCacheView(image_view);
if (type == UndefinedType)
return(MagickFalse);
((Image *) image)->type=type;
MagickExport MagickBooleanType IsOpaqueImage(const Image *image,
ExceptionInfo *exception)
{
- long
- y;
+ CacheView
+ *image_view;
register const PixelPacket
*p;
- register long
+ register ssize_t
x;
- CacheView
- *image_view;
+ ssize_t
+ y;
/*
Determine if image is opaque.
if (image->matte == MagickFalse)
return(MagickTrue);
image_view=AcquireCacheView(image);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- if (p->opacity != OpaqueOpacity)
+ if (GetOpacityPixelComponent(p) != OpaqueOpacity)
break;
p++;
}
- if (x < (long) image->columns)
+ if (x < (ssize_t) image->columns)
break;
}
image_view=DestroyCacheView(image_view);
- return(y < (long) image->rows ? MagickFalse : MagickTrue);
+ return(y < (ssize_t) image->rows ? MagickFalse : MagickTrue);
}
\f
/*
%
% The format of the SetImageChannelDepth method is:
%
-% MagickBooleanType SetImageDepth(Image *image,const unsigned long depth)
+% MagickBooleanType SetImageDepth(Image *image,const size_t depth)
% MagickBooleanType SetImageChannelDepth(Image *image,
-% const ChannelType channel,const unsigned long depth)
+% const ChannelType channel,const size_t depth)
%
% A description of each parameter follows:
%
% o depth: the image depth.
%
*/
-
MagickExport MagickBooleanType SetImageDepth(Image *image,
- const unsigned long depth)
+ const size_t depth)
{
- return(SetImageChannelDepth(image,AllChannels,depth));
+ return(SetImageChannelDepth(image,CompositeChannels,depth));
}
MagickExport MagickBooleanType SetImageChannelDepth(Image *image,
- const ChannelType channel,const unsigned long depth)
+ const ChannelType channel,const size_t depth)
{
+ CacheView
+ *image_view;
+
ExceptionInfo
*exception;
- long
- y;
-
MagickBooleanType
status;
QuantumAny
range;
- CacheView
- *image_view;
+ ssize_t
+ y;
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(image->signature == MagickSignature);
- if (GetImageDepth(image,&image->exception) <= (unsigned long)
+ if (GetImageDepth(image,&image->exception) <= (size_t)
MagickMin((double) depth,(double) MAGICKCORE_QUANTUM_DEPTH))
{
image->depth=depth;
range=GetQuantumRange(depth);
exception=(&image->exception);
image_view=AcquireCacheView(image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
- #pragma omp parallel for shared(status)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register IndexPacket
- *__restrict indexes;
+ *restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
continue;
}
indexes=GetCacheViewAuthenticIndexQueue(image_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if ((channel & RedChannel) != 0)
- q->red=ScaleAnyToQuantum(ScaleQuantumToAny(q->red,range),range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(ScaleQuantumToAny(
+ GetRedPixelComponent(q),range),range));
if ((channel & GreenChannel) != 0)
- q->green=ScaleAnyToQuantum(ScaleQuantumToAny(q->green,range),range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(ScaleQuantumToAny(
+ GetGreenPixelComponent(q),range),range));
if ((channel & BlueChannel) != 0)
- q->blue=ScaleAnyToQuantum(ScaleQuantumToAny(q->blue,range),range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(ScaleQuantumToAny(
+ GetBluePixelComponent(q),range),range));
if (((channel & OpacityChannel) != 0) && (image->matte != MagickFalse))
- q->opacity=ScaleAnyToQuantum(ScaleQuantumToAny(q->opacity,range),range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(ScaleQuantumToAny(
+ GetOpacityPixelComponent(q),range),range));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- indexes[x]=ScaleAnyToQuantum(ScaleQuantumToAny(indexes[x],range),range);
+ SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(ScaleQuantumToAny(
+ GetIndexPixelComponent(indexes+x),range),range));
q++;
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
image_view=DestroyCacheView(image_view);
if (image->storage_class == PseudoClass)
{
- QuantumAny
- range;
-
- register long
+ register ssize_t
i;
register PixelPacket
- *__restrict p;
+ *restrict p;
p=image->colormap;
- range=GetQuantumRange(depth);
-#if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
- #pragma omp parallel for shared(status)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
if ((channel & RedChannel) != 0)
- p->red=ScaleAnyToQuantum(ScaleQuantumToAny(p->red,range),range);
+ GetRedPixelComponent(p)=ScaleAnyToQuantum(ScaleQuantumToAny(GetRedPixelComponent(p),range),range);
if ((channel & GreenChannel) != 0)
- p->green=ScaleAnyToQuantum(ScaleQuantumToAny(p->green,range),range);
+ GetGreenPixelComponent(p)=ScaleAnyToQuantum(ScaleQuantumToAny(GetGreenPixelComponent(p),range),range);
if ((channel & BlueChannel) != 0)
- p->blue=ScaleAnyToQuantum(ScaleQuantumToAny(p->blue,range),range);
+ GetBluePixelComponent(p)=ScaleAnyToQuantum(ScaleQuantumToAny(GetBluePixelComponent(p),range),range);
if ((channel & OpacityChannel) != 0)
- p->opacity=ScaleAnyToQuantum(ScaleQuantumToAny(p->opacity,range),
+ GetOpacityPixelComponent(p)=ScaleAnyToQuantum(ScaleQuantumToAny(GetOpacityPixelComponent(p),range),
range);
p++;
}
projects / imagemagick / blobdiff