(no commit message)

diff --git a/MagickCore/attribute.c b/MagickCore/attribute.c
index d782aad5411ed6e8b389b313efe2abeefbc544ca..8c81776aa59479d1e74c558e131e76365b07c213 100644 (file)
--- a/MagickCore/attribute.c
+++ b/MagickCore/attribute.c
@@ -169,8 +169,7 @@ MagickExport RectangleInfo GetImageBoundingBox(const Image *image,
   GetPixelInfo(image,&zero);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -389,8 +388,7 @@ MagickExport size_t GetImageDepth(const Image *image,ExceptionInfo *exception)
       }
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -454,8 +452,7 @@ MagickExport size_t GetImageDepth(const Image *image,ExceptionInfo *exception)
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -939,8 +936,7 @@ MagickExport MagickBooleanType SetImageDepth(Image *image,
 
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (i=0; i < (ssize_t) image->colors; i++)
       {
@@ -948,7 +944,8 @@ MagickExport MagickBooleanType SetImageDepth(Image *image,
           image->colormap[i].red=(double) ScaleAnyToQuantum(ScaleQuantumToAny(
             ClampToQuantum(image->colormap[i].red),range),range);
         if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
-          image->colormap[i].green=(double) ScaleAnyToQuantum(ScaleQuantumToAny(            ClampToQuantum(image->colormap[i].green),range),range);
+          image->colormap[i].green=(double) ScaleAnyToQuantum(ScaleQuantumToAny(
+            ClampToQuantum(image->colormap[i].green),range),range);
         if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
           image->colormap[i].blue=(double) ScaleAnyToQuantum(ScaleQuantumToAny(
             ClampToQuantum(image->colormap[i].blue),range),range);
@@ -983,8 +980,7 @@ MagickExport MagickBooleanType SetImageDepth(Image *image,
           range);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -1048,8 +1044,7 @@ MagickExport MagickBooleanType SetImageDepth(Image *image,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/cache.c b/MagickCore/cache.c
index 249db2d0a1c33b0dfb48f5bc38a383774b7f47da..1e27902c85fb783812ef774f29d1a28d972972ee 100644 (file)
--- a/MagickCore/cache.c
+++ b/MagickCore/cache.c
@@ -4899,8 +4899,7 @@ static MagickBooleanType SetCacheAlphaChannel(Image *image,const Quantum alpha,
   image_view=AcquireVirtualCacheView(image,exception);  /* must be virtual */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/channel.c b/MagickCore/channel.c
index 1ca7f64883b37c025ed5642b9c31a89c221d0ed9..8e98f50b6b15bcbd8bcd44e4a10d613d18237797 100644 (file)
--- a/MagickCore/channel.c
+++ b/MagickCore/channel.c
@@ -51,6 +51,7 @@
 #include "MagickCore/pixel-accessor.h"
 #include "MagickCore/resource_.h"
 #include "MagickCore/string-private.h"
+#include "MagickCore/thread-private.h"
 #include "MagickCore/token.h"
 #include "MagickCore/utility.h"
 #include "MagickCore/version.h"
@@ -140,8 +141,7 @@ static MagickBooleanType ChannelImage(Image *destination_image,
   width=MagickMin(source_image->columns,destination_image->columns);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=0; y < (ssize_t) height; y++)
   {
@@ -656,8 +656,7 @@ MagickExport Image *SeparateImage(const Image *image,
   separate_view=AcquireAuthenticCacheView(separate_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/colormap.c b/MagickCore/colormap.c
index 50c6621f029bddd94e62c27fc8659049b3f175e4..efa835868c2c290be397c3760825e595934bb1b1 100644 (file)
--- a/MagickCore/colormap.c
+++ b/MagickCore/colormap.c
@@ -65,6 +65,7 @@
 #include "MagickCore/resource_.h"
 #include "MagickCore/semaphore.h"
 #include "MagickCore/string_.h"
+#include "MagickCore/thread-private.h"
 #include "MagickCore/token.h"
 #include "MagickCore/utility.h"
 #include "MagickCore/xml-tree.h"
@@ -205,8 +206,7 @@ MagickExport MagickBooleanType CycleColormapImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -331,8 +331,7 @@ MagickExport MagickBooleanType SortColormapByIntensity(Image *image,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if (image->colors > 256) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentUno(image->colors,256)
 #endif
   for (i=0; i < (ssize_t) image->colors; i++)
     image->colormap[i].alpha=(double) i;

diff --git a/MagickCore/colorspace.c b/MagickCore/colorspace.c
index 120443bb61923fe243eef274dd2f73dddb8ca6a9..04c766f4ac87ed625b227eeef87d15c9ddce1fa7 100644 (file)
--- a/MagickCore/colorspace.c
+++ b/MagickCore/colorspace.c
@@ -245,8 +245,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -306,8 +305,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -364,8 +362,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -430,8 +427,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -496,8 +492,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -562,8 +557,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -670,8 +664,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
         0.002/film_gamma);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
         logmap[i]=ScaleMapToQuantum((MagickRealType) (MaxMap*(reference_white+
@@ -680,8 +673,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -757,8 +749,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       primary_info.z=(double) (MaxMap+1.0)/2.0;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -784,8 +775,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -819,8 +809,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       primary_info.z=(double) (MaxMap+1.0)/2.0;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -845,8 +834,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -878,8 +866,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       primary_info.z=(double) (MaxMap+1.0)/2.0;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -903,8 +890,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -939,8 +925,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -1011,8 +996,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       primary_info.z=(double) (MaxMap+1.0)/2.0;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -1044,8 +1028,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       primary_info.z=(double) (MaxMap+1.0)/2.0;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -1077,8 +1060,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       primary_info.z=(double) (MaxMap+1.0)/2.0;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -1101,8 +1083,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -1133,8 +1114,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -1750,8 +1730,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -1811,8 +1790,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -1869,8 +1847,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -1937,8 +1914,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -2005,8 +1981,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -2073,8 +2048,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -2190,8 +2164,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -2274,8 +2247,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2311,8 +2283,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2346,8 +2317,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2378,8 +2348,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2414,8 +2383,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2444,8 +2412,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2479,8 +2446,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2516,8 +2482,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2551,8 +2516,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2579,8 +2543,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) \
-        if (MaxMap > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(MaxMap,256)
 #endif
       for (i=0; i <= (ssize_t) MaxMap; i++)
       {
@@ -2611,8 +2574,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -2717,8 +2679,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (i=0; i < (ssize_t) image->colors; i++)
       {

diff --git a/MagickCore/compare.c b/MagickCore/compare.c
index 756a3b099e203131f52ef23e528b98503fc84b1d..9bcddf444d12b9ccfe342d708be2d43be95dc1c4 100644 (file)
--- a/MagickCore/compare.c
+++ b/MagickCore/compare.c
@@ -64,6 +64,7 @@
 #include "MagickCore/resource_.h"
 #include "MagickCore/string_.h"
 #include "MagickCore/statistic.h"
+#include "MagickCore/thread-private.h"
 #include "MagickCore/transform.h"
 #include "MagickCore/utility.h"
 #include "MagickCore/version.h"
@@ -178,8 +179,7 @@ MagickExport Image *CompareImages(Image *image,const Image *reconstruct_image,
   highlight_view=AcquireAuthenticCacheView(highlight_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -328,8 +328,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
   reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -454,8 +453,7 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
   reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -556,8 +554,7 @@ static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image,
   reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -752,8 +749,7 @@ static MagickBooleanType GetMeanSquaredDistortion(const Image *image,
   reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -988,8 +984,7 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
   reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1599,8 +1594,7 @@ MagickExport Image *SimilarityImage(Image *image,const Image *reference,
   similarity_view=AcquireAuthenticCacheView(similarity_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) (image->rows-reference->rows+1); y++)
   {

diff --git a/MagickCore/composite.c b/MagickCore/composite.c
index 56db25eba22aede9fcf1ae4fe34df0ea5c7f8bb5..f32a298b91d365ac7ebc332e4af1325ee16edde8 100644 (file)
--- a/MagickCore/composite.c
+++ b/MagickCore/composite.c
@@ -335,8 +335,7 @@ static MagickBooleanType CompositeOverImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -610,8 +609,7 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((composite_image->rows*composite_image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) composite_image->rows; y++)
       {
@@ -1168,8 +1166,7 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2368,8 +2365,7 @@ MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) texture_image->rows)
       {
@@ -2419,8 +2415,7 @@ MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/decorate.c b/MagickCore/decorate.c
index e202a51edd56e87f5574b3ffe9abaeb96655f638..8d972358855bc052b23c53ae4aa85ed7a8ace90d 100644 (file)
--- a/MagickCore/decorate.c
+++ b/MagickCore/decorate.c
@@ -385,8 +385,7 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT) 
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -691,8 +690,7 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) 
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((raise_info->height*raise_info->width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) raise_info->height; y++)
   {
@@ -798,8 +796,7 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
   }
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=(ssize_t) raise_info->height; y < (ssize_t) (image->rows-raise_info->height); y++)
   {
@@ -882,8 +879,7 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
   }
 #if defined(MAGICKCORE_OPENMP_SUPPORT) 
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=(ssize_t) (image->rows-raise_info->height); y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/distort.c b/MagickCore/distort.c
index d99b7952daf3f3450acfbb71da3d7be52f52f6fd..decc96d9dd2b3c42e5b00dbf2afb775f5ebefb76 100644 (file)
--- a/MagickCore/distort.c
+++ b/MagickCore/distort.c
@@ -2314,8 +2314,7 @@ MagickExport Image *DistortImage(const Image *image,DistortImageMethod method,
     distort_view=AcquireAuthenticCacheView(distort_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(progress,status) \
-      if ((distort_image->rows*distort_image->columns) > 8192) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentDos(image->columns,image->rows,64)
 #endif
     for (j=0; j < (ssize_t) distort_image->rows; j++)
     {
@@ -3040,8 +3039,7 @@ MagickExport Image *SparseColorImage(const Image *image,
     sparse_view=AcquireAuthenticCacheView(sparse_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(progress,status) \
-      if ((sparse_image->rows*sparse_image->columns) > 8192) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentDos(image->columns,image->rows,64)
 #endif
     for (j=0; j < (ssize_t) sparse_image->rows; j++)
     {

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index f874ab5e4bf904d6c057d466eab164e92b93a8c9..79f1e767244e717a83f681c9aabe4aab63577926 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -1169,8 +1169,7 @@ MagickExport MagickBooleanType DrawAffineImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=start; y <= stop; y++)
   {
@@ -3262,8 +3261,7 @@ MagickExport MagickBooleanType DrawGradientImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=bounding_box.y; y < (ssize_t) bounding_box.height; y++)
   {
@@ -3876,8 +3874,7 @@ static MagickBooleanType DrawPolygonPrimitive(Image *image,
       stop=(ssize_t) floor(bounds.y2+0.5);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(status) \
-        if ((height*width) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(width,height,64)
 #endif
       for (y=start; y <= stop; y++)
       {
@@ -3940,8 +3937,7 @@ static MagickBooleanType DrawPolygonPrimitive(Image *image,
   stop=(ssize_t) floor(bounds.y2+0.5);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=start; y <= stop; y++)
   {

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index 984a25477f100999907f692d45fd3b09f8a949de..4017d1e733f7e04fb0b4a24f39a6b3a9ec5bfcd6 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -295,8 +295,7 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
   blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((blur_image->rows*blur_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) blur_image->rows; y++)
   {
@@ -623,8 +622,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
   sharp_view=AcquireAuthenticCacheView(sharp_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((sharp_image->rows*sharp_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) sharp_image->rows; y++)
   {
@@ -954,8 +952,7 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
   blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1085,8 +1082,7 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
   blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((blur_image->rows*blur_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (x=0; x < (ssize_t) blur_image->columns; x++)
   {
@@ -1297,8 +1293,7 @@ static void Hull(const ssize_t x_offset,const ssize_t y_offset,
   r=p+(y_offset*(columns+2)+x_offset);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) \
-    if ((rows*columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(columns,rows,64)
 #endif
   for (y=0; y < (ssize_t) rows; y++)
   {
@@ -1335,8 +1330,7 @@ static void Hull(const ssize_t x_offset,const ssize_t y_offset,
   s=q-(y_offset*(columns+2)+x_offset);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) \
-    if ((rows*columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(columns,rows,64)
 #endif
   for (y=0; y < (ssize_t) rows; y++)
   {
@@ -1962,8 +1956,7 @@ MagickExport Image *MotionBlurImage(const Image *image,const double radius,
   blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2741,8 +2734,7 @@ MagickExport Image *RadialBlurImage(const Image *image,const double angle,
   blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3037,8 +3029,7 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
   blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3292,8 +3283,7 @@ MagickExport Image *ShadeImage(const Image *image,const MagickBooleanType gray,
   shade_view=AcquireAuthenticCacheView(shade_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3621,8 +3611,7 @@ MagickExport Image *SpreadImage(const Image *image,const double radius,
   spread_view=AcquireAuthenticCacheView(spread_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,8) shared(progress,status) \
-    if (((image->rows*image->columns) > 8192) && (key == ~0UL)) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3762,8 +3751,7 @@ MagickExport Image *UnsharpMaskImage(const Image *image,const double radius,
   unsharp_view=AcquireAuthenticCacheView(unsharp_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/enhance.c b/MagickCore/enhance.c
index cb0104a8215fa54b226bcd34408407254d8a0d29..78ee0e444c203d00a7b15e2a58714b95b5868502 100644 (file)
--- a/MagickCore/enhance.c
+++ b/MagickCore/enhance.c
@@ -344,8 +344,7 @@ MagickExport MagickBooleanType ClutImage(Image *image,const Image *clut_image,
   clut_view=AcquireVirtualCacheView(clut_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) \
-    if (MaxMap > 256) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentUno(MaxMap,256)
 #endif
   for (i=0; i <= (ssize_t) MaxMap; i++)
   {
@@ -358,8 +357,7 @@ MagickExport MagickBooleanType ClutImage(Image *image,const Image *clut_image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -709,8 +707,7 @@ MagickExport MagickBooleanType ColorDecisionListImage(Image *image,
       image->filename);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) \
-    if (MaxMap > 256) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentUno(MaxMap,256)
 #endif
   for (i=0; i <= (ssize_t) MaxMap; i++)
   {
@@ -731,8 +728,7 @@ MagickExport MagickBooleanType ColorDecisionListImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(progress,status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (i=0; i < (ssize_t) image->colors; i++)
       {
@@ -760,8 +756,7 @@ MagickExport MagickBooleanType ColorDecisionListImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -917,8 +912,7 @@ MagickExport MagickBooleanType ContrastImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1105,8 +1099,7 @@ MagickExport MagickBooleanType ContrastStretchImage(Image *image,
   number_channels=GetPixelChannels(image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if (MaxMap > 256) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentUno(MaxMap,256)
 #endif
   for (i=0; i < (ssize_t) number_channels; i++)
   {
@@ -1144,8 +1137,7 @@ MagickExport MagickBooleanType ContrastStretchImage(Image *image,
   number_channels=GetPixelChannels(image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if (MaxMap > 256) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentUno(MaxMap,256)
 #endif
   for (i=0; i < (ssize_t) number_channels; i++)
   {
@@ -1177,8 +1169,7 @@ MagickExport MagickBooleanType ContrastStretchImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(progress,status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (j=0; j < (ssize_t) image->colors; j++)
       {
@@ -1220,8 +1211,7 @@ MagickExport MagickBooleanType ContrastStretchImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1374,8 +1364,7 @@ MagickExport Image *EnhanceImage(const Image *image,ExceptionInfo *exception)
   enhance_view=AcquireAuthenticCacheView(enhance_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1607,8 +1596,7 @@ MagickExport MagickBooleanType EqualizeImage(Image *image,
   number_channels=GetPixelChannels(image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if (MaxMap > 256) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentUno(MaxMap,256)
 #endif
   for (i=0; i < (ssize_t) number_channels; i++)
   {
@@ -1630,8 +1618,7 @@ MagickExport MagickBooleanType EqualizeImage(Image *image,
   number_channels=GetPixelChannels(image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if (MaxMap > 256) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentUno(MaxMap,256)
 #endif
   for (i=0; i < (ssize_t) number_channels; i++)
   {
@@ -1661,8 +1648,7 @@ MagickExport MagickBooleanType EqualizeImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(progress,status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (j=0; j < (ssize_t) image->colors; j++)
       {
@@ -1707,8 +1693,7 @@ MagickExport MagickBooleanType EqualizeImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1847,8 +1832,7 @@ MagickExport MagickBooleanType GammaImage(Image *image,const double gamma,
   if (gamma != 0.0)
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && (MaxMap > 256)
     #pragma omp parallel for \
-      if (MaxMap > 256) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentUno(MaxMap,256)
 #endif
     for (i=0; i <= (ssize_t) MaxMap; i++)
       gamma_map[i]=ScaleMapToQuantum((MagickRealType) (MaxMap*pow((double) i/
@@ -1860,8 +1844,7 @@ MagickExport MagickBooleanType GammaImage(Image *image,const double gamma,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(progress,status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (i=0; i < (ssize_t) image->colors; i++)
       {
@@ -1887,8 +1870,7 @@ MagickExport MagickBooleanType GammaImage(Image *image,const double gamma,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2058,8 +2040,7 @@ MagickExport MagickBooleanType HaldClutImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2240,8 +2221,7 @@ MagickExport MagickBooleanType LevelImage(Image *image,const double black_point,
   if (image->storage_class == PseudoClass)
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(progress,status) \
-      if (image->colors > 256) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentUno(image->colors,256)
 #endif
     for (i=0; i < (ssize_t) image->colors; i++)
     {
@@ -2269,8 +2249,7 @@ MagickExport MagickBooleanType LevelImage(Image *image,const double black_point,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2410,8 +2389,7 @@ MagickExport MagickBooleanType LevelizeImage(Image *image,
   if (image->storage_class == PseudoClass)
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(progress,status) \
-      if (image->colors > 256) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentUno(image->colors,256)
 #endif
     for (i=0; i < (ssize_t) image->colors; i++)
     {
@@ -2439,8 +2417,7 @@ MagickExport MagickBooleanType LevelizeImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2925,8 +2902,7 @@ MagickExport MagickBooleanType ModulateImage(Image *image,const char *modulate,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(progress,status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (i=0; i < (ssize_t) image->colors; i++)
         switch (colorspace)
@@ -2963,8 +2939,7 @@ MagickExport MagickBooleanType ModulateImage(Image *image,const char *modulate,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3097,8 +3072,7 @@ MagickExport MagickBooleanType NegateImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(progress,status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (i=0; i < (ssize_t) image->colors; i++)
       {
@@ -3127,8 +3101,7 @@ MagickExport MagickBooleanType NegateImage(Image *image,
     {
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(progress,status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -3202,8 +3175,7 @@ MagickExport MagickBooleanType NegateImage(Image *image,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3383,8 +3355,7 @@ MagickExport MagickBooleanType SigmoidalContrastImage(Image *image,
   (void) ResetMagickMemory(sigmoidal_map,0,(MaxMap+1)*sizeof(*sigmoidal_map));
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if (MaxMap > 256) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentUno(MaxMap,256)
 #endif
   for (i=0; i <= (ssize_t) MaxMap; i++)
   {
@@ -3448,8 +3419,7 @@ MagickExport MagickBooleanType SigmoidalContrastImage(Image *image,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(progress,status) \
-        if (image->colors > 256) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentUno(image->colors,256)
 #endif
       for (i=0; i < (ssize_t) image->colors; i++)
       {
@@ -3475,8 +3445,7 @@ MagickExport MagickBooleanType SigmoidalContrastImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/feature.c b/MagickCore/feature.c
index eb32c4607a81d12e434199e700e27f86d58ece2e..7afadb7d028f3d26641648176746a485b4037a1d 100644 (file)
--- a/MagickCore/feature.c
+++ b/MagickCore/feature.c
@@ -224,8 +224,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
   image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -596,8 +595,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((number_grays*number_grays) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(number_grays,number_grays,64)
 #endif
   for (i=0; i < 4; i++)
   {
@@ -782,8 +780,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((number_grays*number_grays) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(number_grays,number_grays,64)
 #endif
   for (i=0; i < 4; i++)
   {
@@ -859,8 +856,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((number_grays*number_grays) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(number_grays,number_grays,64)
 #endif
   for (i=0; i < 4; i++)
   {
@@ -981,8 +977,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
   (void) ResetMagickMemory(&sum_squares,0,sizeof(sum_squares));
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((number_grays*number_grays) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(number_grays,number_grays,64)
 #endif
   for (i=0; i < 4; i++)
   {
@@ -1134,8 +1129,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((number_grays*number_grays) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(number_grays,number_grays,64)
 #endif
   for (i=0; i < 4; i++)
   {

diff --git a/MagickCore/fx.c b/MagickCore/fx.c
index 4037b2e608e507c30b43c5f120f8754c8c7f6a7c..fd40d79e665deaa6f296646c65cf93c62ae185f1 100644 (file)
--- a/MagickCore/fx.c
+++ b/MagickCore/fx.c
@@ -312,8 +312,7 @@ MagickExport Image *AddNoiseImage(const Image *image,const NoiseType noise_type,
   key=GetRandomSecretKey(random_info[0]);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if (((image->rows*image->columns) > 8192) && (key == ~0UL)) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -480,8 +479,7 @@ MagickExport Image *BlueShiftImage(const Image *image,const double factor,
   shift_view=AcquireAuthenticCacheView(shift_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -744,8 +742,7 @@ MagickExport Image *ColorizeImage(const Image *image,const char *blend,
   colorize_view=AcquireAuthenticCacheView(colorize_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -952,8 +949,7 @@ MagickExport Image *ColorMatrixImage(const Image *image,
   color_view=AcquireAuthenticCacheView(color_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3048,8 +3044,7 @@ MagickExport Image *FxImage(const Image *image,const char *expression,
   fx_view=AcquireAuthenticCacheView(fx_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) fx_image->rows; y++)
   {
@@ -3248,8 +3243,7 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
   implode_view=AcquireAuthenticCacheView(implode_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3494,8 +3488,7 @@ MagickExport Image *MorphImages(const Image *image,
       morph_view=AcquireAuthenticCacheView(morph_images,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((morph_image->rows*morph_image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) morph_images->rows; y++)
       {
@@ -4151,8 +4144,7 @@ MagickExport Image *SepiaToneImage(const Image *image,const double threshold,
   sepia_view=AcquireAuthenticCacheView(sepia_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -4443,8 +4435,7 @@ MagickExport Image *SketchImage(const Image *image,const double radius,
   random_view=AcquireAuthenticCacheView(random_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if (((image->rows*image->columns) > 8192) && (key == ~0UL)) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
 #endif
   for (y=0; y < (ssize_t) random_image->rows; y++)
   {
@@ -4618,8 +4609,7 @@ MagickExport MagickBooleanType SolarizeImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -5104,8 +5094,7 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
   swirl_view=AcquireAuthenticCacheView(swirl_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -5339,8 +5328,7 @@ MagickExport Image *TintImage(const Image *image,const char *blend,
   tint_view=AcquireAuthenticCacheView(tint_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -5644,8 +5632,7 @@ MagickExport Image *WaveImage(const Image *image,const double amplitude,
     BackgroundVirtualPixelMethod);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) wave_image->rows; y++)
   {

diff --git a/MagickCore/image-view.c b/MagickCore/image-view.c
index b0e0699520daf46dbe480ff14a6c051f9ac90093..3a456351de8979db4ad720d7a60461f43c51f044 100644 (file)
--- a/MagickCore/image-view.c
+++ b/MagickCore/image-view.c
@@ -1,4 +1,4 @@
-      /*
+/*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
 %                                                                             %
@@ -244,8 +244,7 @@ MagickExport MagickBooleanType DuplexTransferImageViewIterator(
   width=source->extent.width-source->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
@@ -557,8 +556,7 @@ MagickExport MagickBooleanType GetImageViewIterator(ImageView *source,
   width=source->extent.width-source->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((width*height) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
@@ -906,8 +904,7 @@ MagickExport MagickBooleanType SetImageViewIterator(ImageView *destination,
   width=destination->extent.width-destination->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)
   {
@@ -1035,8 +1032,7 @@ MagickExport MagickBooleanType TransferImageViewIterator(ImageView *source,
   width=source->extent.width-source->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
@@ -1167,8 +1163,7 @@ MagickExport MagickBooleanType UpdateImageViewIterator(ImageView *source,
   width=source->extent.width-source->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {

diff --git a/MagickCore/image.c b/MagickCore/image.c
index 6682bc0c3fe152bbca1841e2b1b29b49456e2781..843228d94f2342514756eb2f2253862d4c910b01 100644 (file)
--- a/MagickCore/image.c
+++ b/MagickCore/image.c
@@ -536,8 +536,7 @@ MagickExport Image *AppendImages(const Image *images,
     image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static) shared(status) \
-      if ((image->rows*image->columns) > 8192) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentDos(image->columns,image->rows,64)
 #endif
     for (y=0; y < (ssize_t) image->rows; y++)
     {
@@ -1645,8 +1644,7 @@ MagickExport MagickBooleanType IsHighDynamicRangeImage(const Image *image,
   image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1901,8 +1899,7 @@ MagickExport Image *NewMagickImage(const ImageInfo *image_info,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2174,8 +2171,7 @@ MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -2254,8 +2250,7 @@ MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -2443,8 +2438,7 @@ MagickExport MagickBooleanType SetImageColor(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3098,8 +3092,7 @@ MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3754,8 +3747,7 @@ MagickExport MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(range_exception,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/morphology.c b/MagickCore/morphology.c
index 5bb357089ecd0c8840ab26dc0c062bd2f26c5510..0434e21eacfedb63be0704ae815b467523fdf9bb 100644 (file)
--- a/MagickCore/morphology.c
+++ b/MagickCore/morphology.c
@@ -78,6 +78,7 @@
 #include "MagickCore/statistic.h"
 #include "MagickCore/string_.h"
 #include "MagickCore/string-private.h"
+#include "MagickCore/thread-private.h"
 #include "MagickCore/token.h"
 #include "MagickCore/utility.h"
 #include "MagickCore/utility-private.h"
@@ -2588,8 +2589,7 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
 
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(progress,status) \
-      if ((image->rows*image->columns) > 8192) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentDos(image->columns,image->rows,64)
 #endif
     for (x=0; x < (ssize_t) image->columns; x++)
     {
@@ -2766,8 +2766,7 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/paint.c b/MagickCore/paint.c
index a70d1fa8bc25362ab9ba5dd32147e6edb97e9ccc..af0d010cf3396929e7b544c7af560d8e373e1ad4 100644 (file)
--- a/MagickCore/paint.c
+++ b/MagickCore/paint.c
@@ -592,8 +592,7 @@ MagickExport Image *OilPaintImage(const Image *image,const double radius,
   paint_view=AcquireAuthenticCacheView(paint_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -794,8 +793,7 @@ MagickExport MagickBooleanType OpaquePaintImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -922,8 +920,7 @@ MagickExport MagickBooleanType TransparentPaintImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1050,8 +1047,7 @@ MagickExport MagickBooleanType TransparentPaintImageChroma(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/prepress.c b/MagickCore/prepress.c
index 2817407fc5aea8570134cc6dc286843d11fda3f6..2b022bf617478e4983889e278911eb71ec0789a1 100644 (file)
--- a/MagickCore/prepress.c
+++ b/MagickCore/prepress.c
@@ -54,6 +54,7 @@
 #include "MagickCore/semaphore.h"
 #include "MagickCore/splay-tree.h"
 #include "MagickCore/string_.h"
+#include "MagickCore/thread-private.h"
 \f
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -112,8 +113,7 @@ MagickExport double GetImageTotalInkDensity(Image *image,
   image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/profile.c b/MagickCore/profile.c
index 59ff358a87e70a68ecc0e121ad8e3996da975c5e..b075d8ac9ed9ed65cef6b321b0e4c404aa22a4ca 100644 (file)
--- a/MagickCore/profile.c
+++ b/MagickCore/profile.c
@@ -6042,8 +6042,7 @@ MagickExport MagickBooleanType ProfileImage(Image *image,const char *name,
             image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
             #pragma omp parallel for schedule(static,4) shared(status) \
-              if ((image->rows*image->columns) > 8192) \
-                num_threads(GetMagickResourceLimit(ThreadResource))
+              IsConcurrentDos(image->columns,image->rows,64)
 #endif
             for (y=0; y < (ssize_t) image->rows; y++)
             {

diff --git a/MagickCore/quantize.c b/MagickCore/quantize.c
index 09b8e480a41159cff67bc789cddb8a91479f4e92..c141df0f3a15b5989d5e9646257c3c4e613c3157 100644 (file)
--- a/MagickCore/quantize.c
+++ b/MagickCore/quantize.c
@@ -543,8 +543,7 @@ static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -2381,8 +2380,7 @@ MagickExport MagickBooleanType PosterizeImage(Image *image,const size_t levels,
   if (image->storage_class == PseudoClass)
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(progress,status) \
-      if (image->colors > 256) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentUno(image->colors,256)
 #endif
     for (i=0; i < (ssize_t) image->colors; i++)
     {
@@ -2410,8 +2408,7 @@ MagickExport MagickBooleanType PosterizeImage(Image *image,const size_t levels,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -3308,8 +3305,7 @@ static MagickBooleanType SetGrayscaleImage(Image *image,
       image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -3387,8 +3383,7 @@ static MagickBooleanType SetGrayscaleImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/resize.c b/MagickCore/resize.c
index 469c98c552daf9a4c98614b3b0bd6006bf08c8ad..b02e0ca36cd63c1b68dcea0cabc64f0829dbeae0 100644 (file)
--- a/MagickCore/resize.c
+++ b/MagickCore/resize.c
@@ -1594,8 +1594,7 @@ MagickExport Image *InterpolativeResizeImage(const Image *image,
   scale.y=(double) image->rows/resize_image->rows;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((resize_image->rows*resize_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) resize_image->rows; y++)
   {
@@ -2204,8 +2203,7 @@ static MagickBooleanType HorizontalFilter(const ResizeFilter *resize_filter,
   resize_view=AcquireAuthenticCacheView(resize_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((resize_image->rows*resize_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (x=0; x < (ssize_t) resize_image->columns; x++)
   {
@@ -2423,8 +2421,7 @@ static MagickBooleanType VerticalFilter(const ResizeFilter *resize_filter,
   resize_view=AcquireAuthenticCacheView(resize_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) resize_image->rows; y++)
   {
@@ -2779,8 +2776,7 @@ MagickExport Image *SampleImage(const Image *image,const size_t columns,
   sample_view=AcquireAuthenticCacheView(sample_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((sample_image->rows*sample_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) sample_image->rows; y++)
   {

diff --git a/MagickCore/segment.c b/MagickCore/segment.c
index 7df551d921df0324870b4c2a2002674d4b32d548..9314e7a51cb360a054058b32bfe190e04943e670 100644 (file)
--- a/MagickCore/segment.c
+++ b/MagickCore/segment.c
@@ -102,6 +102,7 @@
 #include "MagickCore/resource_.h"
 #include "MagickCore/segment.h"
 #include "MagickCore/string_.h"
+#include "MagickCore/thread-private.h"
 \f
 /*
   Define declarations.
@@ -532,8 +533,7 @@ static MagickBooleanType Classify(Image *image,short **extrema,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/shear.c b/MagickCore/shear.c
index 30a2aa805d5b5dbd345a6b8718457f6d50cec7e9..f1b91deb65f5ce98f133123d209b6f70cbc53031 100644 (file)
--- a/MagickCore/shear.c
+++ b/MagickCore/shear.c
@@ -573,8 +573,7 @@ static void RadonProjection(RadonInfo *source_cells,
   }
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) \
-    if ((p->width*p->height) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(p->width,p->height,64)
 #endif
   for (x=0; x < (ssize_t) p->width; x++)
   {
@@ -655,8 +654,7 @@ static MagickBooleanType RadonTransform(const Image *image,
   image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -706,8 +704,7 @@ static MagickBooleanType RadonTransform(const Image *image,
   (void) ResetRadonCells(source_cells);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1030,8 +1027,7 @@ MagickExport Image *IntegralRotateImage(const Image *image,size_t rotations,
       GetPixelCacheTileSize(image,&tile_width,&tile_height);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(progress,status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (tile_y=0; tile_y < (ssize_t) image->rows; tile_y+=(ssize_t) tile_height)
       {
@@ -1156,8 +1152,7 @@ MagickExport Image *IntegralRotateImage(const Image *image,size_t rotations,
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(progress,status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -1254,8 +1249,7 @@ MagickExport Image *IntegralRotateImage(const Image *image,size_t rotations,
       GetPixelCacheTileSize(image,&tile_width,&tile_height);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(progress,status) \
-        if ((image->rows*image->columns) > 8192) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentDos(image->columns,image->rows,64)
 #endif
       for (tile_y=0; tile_y < (ssize_t) image->rows; tile_y+=(ssize_t) tile_height)
       {
@@ -1458,8 +1452,7 @@ static MagickBooleanType XShearImage(Image *image,const MagickRealType degrees,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=0; y < (ssize_t) height; y++)
   {
@@ -1675,8 +1668,7 @@ static MagickBooleanType YShearImage(Image *image,const MagickRealType degrees,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (x=0; x < (ssize_t) width; x++)
   {

diff --git a/MagickCore/statistic.c b/MagickCore/statistic.c
index c22e2d296cdb243211bdccfa870357eae047018e..327d26024c505d0057bd812f0824f39d39714b75 100644 (file)
--- a/MagickCore/statistic.c
+++ b/MagickCore/statistic.c
@@ -506,8 +506,7 @@ MagickExport Image *EvaluateImages(const Image *images,
     {
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(progress,status) \
-        if (((evaluate_image->rows*evaluate_image->columns) > 8192) && (key == ~0UL)) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentTres(images->columns,images->rows,key == ~0UL,64)
 #endif
       for (y=0; y < (ssize_t) evaluate_image->rows; y++)
       {
@@ -615,8 +614,7 @@ MagickExport Image *EvaluateImages(const Image *images,
     {
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static) shared(progress,status) \
-        if (((evaluate_image->rows*evaluate_image->columns) > 8192) && (key == ~0UL)) \
-          num_threads(GetMagickResourceLimit(ThreadResource))
+        IsConcurrentTres(images->columns,images->rows,key == ~0UL,64)
 #endif
       for (y=0; y < (ssize_t) evaluate_image->rows; y++)
       {
@@ -822,8 +820,7 @@ MagickExport MagickBooleanType EvaluateImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if (((image->rows*image->columns) > 8192) && (key == ~0UL)) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1056,8 +1053,7 @@ MagickExport MagickBooleanType FunctionImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1321,8 +1317,7 @@ MagickExport MagickBooleanType GetImageKurtosis(const Image *image,
   image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1451,8 +1446,7 @@ MagickExport MagickBooleanType GetImageRange(const Image *image,double *minima,
   image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2274,8 +2268,7 @@ MagickExport Image *StatisticImage(const Image *image,const StatisticType type,
   statistic_view=AcquireAuthenticCacheView(statistic_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((statistic_image->rows*statistic_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) statistic_image->rows; y++)
   {

diff --git a/MagickCore/threshold.c b/MagickCore/threshold.c
index ebc3754881bcb0d10a4bd133609b4bef305d9107..d4d19ad4e2eb1581d16a22d92c0a991a2d1629c1 100644 (file)
--- a/MagickCore/threshold.c
+++ b/MagickCore/threshold.c
@@ -206,8 +206,7 @@ MagickExport Image *AdaptiveThresholdImage(const Image *image,
   threshold_view=AcquireAuthenticCacheView(threshold_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -394,8 +393,7 @@ MagickExport MagickBooleanType BilevelImage(Image *image,const double threshold,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,8) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -562,8 +560,7 @@ MagickExport MagickBooleanType BlackThresholdImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,8) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -706,8 +703,7 @@ MagickExport MagickBooleanType ClampImage(Image *image,ExceptionInfo *exception)
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,8) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1331,8 +1327,7 @@ MagickExport MagickBooleanType OrderedPosterizeImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,8) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1512,8 +1507,7 @@ MagickExport MagickBooleanType RandomThresholdImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,8) shared(progress,status) \
-    if (((image->rows*image->columns) > 8192) && (key == ~0UL)) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -1696,8 +1690,7 @@ MagickExport MagickBooleanType WhiteThresholdImage(Image *image,
   image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,8) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/transform.c b/MagickCore/transform.c
index 9bb966d515b822c06b6bf2197fcea79b28ff1dd0..95c20231cf8c7832d97eb41a8a32d9769ed14eb8 100644 (file)
--- a/MagickCore/transform.c
+++ b/MagickCore/transform.c
@@ -161,8 +161,7 @@ MagickExport Image *ChopImage(const Image *image,const RectangleInfo *chop_info,
   chop_view=AcquireAuthenticCacheView(chop_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((extent.y*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) extent.y; y++)
   {
@@ -233,8 +232,7 @@ MagickExport Image *ChopImage(const Image *image,const RectangleInfo *chop_info,
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) (image->rows-(extent.y+extent.height)); y++)
   {
@@ -590,8 +588,7 @@ MagickExport Image *CropImage(const Image *image,const RectangleInfo *geometry,
   crop_view=AcquireAuthenticCacheView(crop_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((crop_image->rows*crop_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) crop_image->rows; y++)
   {
@@ -953,8 +950,7 @@ MagickExport Image *ExcerptImage(const Image *image,
   excerpt_view=AcquireAuthenticCacheView(excerpt_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((excerpt_image->rows*excerpt_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) excerpt_image->rows; y++)
   {
@@ -1162,8 +1158,7 @@ MagickExport Image *FlipImage(const Image *image,ExceptionInfo *exception)
   flip_view=AcquireAuthenticCacheView(flip_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((flip_image->rows*flip_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) flip_image->rows; y++)
   {
@@ -1310,8 +1305,7 @@ MagickExport Image *FlopImage(const Image *image,ExceptionInfo *exception)
   flop_view=AcquireAuthenticCacheView(flop_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((flop_image->rows*flop_image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) flop_image->rows; y++)
   {
@@ -1441,8 +1435,7 @@ static inline MagickBooleanType CopyImageRegion(Image *destination,
   destination_view=AcquireAuthenticCacheView(destination,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(status) \
-    if ((rows*columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(columns,rows,64)
 #endif
   for (y=0; y < (ssize_t) rows; y++)
   {
@@ -1771,8 +1764,7 @@ MagickExport Image *SpliceImage(const Image *image,
   splice_view=AcquireAuthenticCacheView(splice_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((splice_geometry.y*splice_geometry.x) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) splice_geometry.y; y++)
   {
@@ -1877,8 +1869,7 @@ MagickExport Image *SpliceImage(const Image *image,
   }
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((splice_geometry.y*splice_geometry.x) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=(ssize_t) (splice_geometry.y+splice_geometry.height);
        y < (ssize_t) splice_image->rows; y++)
@@ -2230,8 +2221,7 @@ MagickExport Image *TransposeImage(const Image *image,ExceptionInfo *exception)
   transpose_view=AcquireAuthenticCacheView(transpose_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2381,8 +2371,7 @@ MagickExport Image *TransverseImage(const Image *image,ExceptionInfo *exception)
   transverse_view=AcquireAuthenticCacheView(transverse_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
-    if ((image->rows*image->columns) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {

diff --git a/MagickCore/version.h b/MagickCore/version.h
index edeaebf397cd5932919699a72bcc90469cfa8dbe..874f4cf8889ebbdf53a62827caeea74a27ff1836 100644 (file)
--- a/MagickCore/version.h
+++ b/MagickCore/version.h
@@ -34,7 +34,7 @@ extern "C" {
 #define MagickLibAddendum  "-0"
 #define MagickLibInterface  7
 #define MagickLibMinInterface  7
-#define MagickReleaseDate  "2012-04-25"
+#define MagickReleaseDate  "2012-05-06"
 #define MagickChangeDate   "20110801"
 #define MagickAuthoritativeURL  "http://www.imagemagick.org"
 #if defined(MAGICKCORE_OPENMP_SUPPORT)

diff --git a/MagickWand/wand-view.c b/MagickWand/wand-view.c
index 434a4d9c79fc78848f6f3a1ea84ddaed7c25e727..69d69c1df714c74ab33b20d2ea4ebba0cb6bf4ec 100644 (file)
--- a/MagickWand/wand-view.c
+++ b/MagickWand/wand-view.c
@@ -292,8 +292,7 @@ WandExport MagickBooleanType DuplexTransferWandViewIterator(WandView *source,
   width=source->extent.width-source->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
@@ -546,8 +545,7 @@ WandExport MagickBooleanType GetWandViewIterator(WandView *source,
   width=source->extent.width-source->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
@@ -950,8 +948,7 @@ WandExport MagickBooleanType SetWandViewIterator(WandView *destination,
   width=destination->extent.width-destination->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)
   {
@@ -1088,8 +1085,7 @@ WandExport MagickBooleanType TransferWandViewIterator(WandView *source,
   width=source->extent.width-source->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
@@ -1243,8 +1239,7 @@ WandExport MagickBooleanType UpdateWandViewIterator(WandView *source,
   width=source->extent.width-source->extent.x;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static) shared(progress,status) \
-    if ((height*width) > 8192) \
-      num_threads(GetMagickResourceLimit(ThreadResource))
+    IsConcurrentDos(width,height,64)
 #endif
   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {

diff --git a/coders/hald.c b/coders/hald.c
index dfc2942d70edf501410746fc709ffb523899bb98..7c333c2b335c530c502dd7295f94a44fbdc2654f 100644 (file)
--- a/coders/hald.c
+++ b/coders/hald.c
@@ -127,7 +127,7 @@ static Image *ReadHALDImage(const ImageInfo *image_info,
   image->rows=(size_t) (level*cube_size);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,8) shared(status) \
-    IsConcurrent(image->columns,image->rows)
+    IsConcurrentDos(image->columns,image->rows,64)
 #endif
   for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) level)
   {

diff --git a/coders/sfw.c b/coders/sfw.c
index d23bf4727ee521a47a2c570c34b0e9a210a86995..7d092d2906e24274456f2697d2ee22f5e79bcdee 100644 (file)
--- a/coders/sfw.c
+++ b/coders/sfw.c
@@ -121,7 +121,7 @@ static MagickBooleanType IsSFW(const unsigned char *magick,const size_t length)
 */
 
 static unsigned char *SFWScan(unsigned char *p,const unsigned char *q,
-  const unsigned char *target,const int length)
+  const unsigned char *target,const size_t length)
 {
   register ssize_t
     i;
@@ -132,10 +132,10 @@ static unsigned char *SFWScan(unsigned char *p,const unsigned char *q,
       continue;
     if (length == 1)
       return(p);
-    for (i=1; i < length; i++)
+    for (i=1; i < (ssize_t) length; i++)
       if (*(p+i) != *(target+i))
         break;
-    if (i == length)
+    if (i == (ssize_t) length)
       return(p);
   }
   return((unsigned char *) NULL);
@@ -207,6 +207,7 @@ static Image *ReadSFWImage(const ImageInfo *image_info,ExceptionInfo *exception)
 
   Image
     *flipped_image,
+    *jpeg_image,
     *image;
 
   ImageInfo
@@ -252,15 +253,17 @@ static Image *ReadSFWImage(const ImageInfo *image_info,ExceptionInfo *exception)
   /*
     Read image into a buffer.
   */
+  if (GetBlobSize(image) != (size_t) GetBlobSize(image))
+    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
   buffer=(unsigned char *) AcquireQuantumMemory((size_t) GetBlobSize(image),
     sizeof(*buffer));
   if (buffer == (unsigned char *) NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
   count=ReadBlob(image,(size_t) GetBlobSize(image),buffer);
-  if ((count == 0) || (LocaleNCompare((char *) buffer,"SFW",3) != 0))
+  if ((count != (ssize_t) GetBlobSize(image)) ||
+      (LocaleNCompare((char *) buffer,"SFW",3) != 0))
     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
   (void) CloseBlob(image);
-  image=DestroyImage(image);
   /*
     Find the start of the JFIF data
   */
@@ -338,11 +341,18 @@ static Image *ReadSFWImage(const ImageInfo *image_info,ExceptionInfo *exception)
   /*
     Read JPEG image.
   */
-  image=ReadImage(read_info,exception);
+  jpeg_image=ReadImage(read_info,exception);
   (void) RelinquishUniqueFileResource(read_info->filename);
   read_info=DestroyImageInfo(read_info);
-  if (image == (Image *) NULL)
-    return(GetFirstImageInList(image));
+  if (jpeg_image == (Image *) NULL)
+    {
+      image=DestroyImageList(image);
+      return(jpeg_image);
+    }
+  (void) CopyMagickString(jpeg_image->filename,image->filename,MaxTextExtent);
+  (void) CopyMagickString(jpeg_image->magick,image->magick,MaxTextExtent);
+  image=DestroyImageList(image);
+  image=jpeg_image;
   /*
     Correct image orientation.
   */

diff --git a/config/ImageMagick.rdf b/config/ImageMagick.rdf
index 4741b650aec481d98734093f6e6a4f74bf5f7636..82e963e784908f375f9caf640a777a23f127872f 100644 (file)
--- a/config/ImageMagick.rdf
+++ b/config/ImageMagick.rdf
@@ -5,7 +5,7 @@
     <name>ImageMagick</name>
     <shortdesc xml:lang="en">ImageMagick: convert, edit, and compose images.</shortdesc>
     <homepage rdf:resource="http://www.imagemagick.org/"/>
-    <created>2012-04-25</created>
+    <created>2012-05-06</created>
 
     <description xml:lang="en">
 ImageMagick® is a software suite to create, edit, compose, or convert bitmap images. It can read and write images in a variety of formats (over 100) including DPX, EXR, GIF, JPEG, JPEG-2000, PDF, PhotoCD, PNG, Postscript, SVG, and TIFF. Use ImageMagick to resize, flip, mirror, rotate, distort, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and Bézier curves.
@@ -57,7 +57,7 @@ Examples of ImageMagick Usage shows how to use ImageMagick from the command-line
     <release>
       <Version>
           <name>stable</name>
-          <created>2012-04-25</created>
+          <created>2012-05-06</created>
           <revision>7.0.0</revision>
           <patch-level>-0</patch-level>
       </Version>

diff --git a/config/configure.xml b/config/configure.xml
index 9ba5afc51ff01a1215d02b39756b564c1c55f1c6..d3921084a6c15e9cb462c1a749387e09fe437480 100644 (file)
--- a/config/configure.xml
+++ b/config/configure.xml
@@ -11,7 +11,7 @@
   <configure name="LIB_VERSION" value="0x700"/>
   <configure name="LIB_VERSION_NUMBER" value="7,0,0,0"/>
   <configure name="SVN_REVISION" value="7561" />
-  <configure name="RELEASE_DATE" value="2012-04-25"/>
+  <configure name="RELEASE_DATE" value="2012-05-06"/>
   <configure name="CONFIGURE" value="./configure "/>
   <configure name="PREFIX" value="/usr/local"/>
   <configure name="EXEC-PREFIX" value="/usr/local"/>

diff --git a/filters/analyze.c b/filters/analyze.c
index 1ed2bed6e6a42ab7507a4176f3afd406fdf6887d..91235c311ddaf5f01c01e97fa22e51ff662ee7c2 100644 (file)
--- a/filters/analyze.c
+++ b/filters/analyze.c
@@ -146,8 +146,7 @@ ModuleExport size_t analyzeImage(Image **images,const int argc,
     image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(status) \
-      if ((image->rows*image->columns) > 8192) \
-        num_threads(GetMagickResourceLimit(ThreadResource))
+      IsConcurrentDos(image->columns,image->rows,64)
 #endif
     for (y=0; y < (ssize_t) image->rows; y++)
     {