Changeset 11666 for ImageMagick/trunk/magick

Timestamp:

07/18/08 18:12:16 (7 weeks ago)

Author:

cristy

Message:

 

Location:

ImageMagick/trunk/magick

Files:

• annotate.c (modified) (1 diff)
• draw.c (modified) (8 diffs)

ImageMagick/trunk/magick/annotate.c

@@ -1559 +1559 @@
             *p;
 
-          id=GetCacheViewThreadId();
+          if (status == MagickFalse)
+            continue;
           x_offset=(long) (point.x+0.5);
           y_offset=(long) (point.y+y+0.5);
           if ((y_offset < 0) || (y_offset >= (long) image->rows))
             continue;
+          id=GetCacheViewThreadId();
           q=GetCacheViewPixels(image_view[id],x_offset,y_offset,
             bitmap->bitmap.width,1);

ImageMagick/trunk/magick/draw.c

@@ -947 +947 @@
 */
 
+static ResampleFilter **DestroyResampleFilterThreadSet(ResampleFilter **filter)
+{
+  register long
+    i;
+
+  assert(filter != (ResampleFilter **) NULL);
+  for (i=0; i < (long) GetCacheViewMaximumThreads(); i++)
+    if (filter[i] != (ResampleFilter *) NULL)
+      filter[i]=DestroyResampleFilter(filter[i]);
+  return((ResampleFilter **) RelinquishMagickMemory(filter));
+}
+
+static ResampleFilter **AcquireResampleFilterThreadSet(const Image *image,
+  ExceptionInfo *exception)
+{
+  register long
+    i;
+
+  ResampleFilter
+    **filter;
+
+  filter=(ResampleFilter **) AcquireQuantumMemory(GetCacheViewMaximumThreads(),
+    sizeof(*filter));
+  if (filter == (ResampleFilter **) NULL)
+    return((ResampleFilter **) NULL);
+  (void) ResetMagickMemory(filter,0,GetCacheViewMaximumThreads()*
+    sizeof(*filter));
+  for (i=0; i < (long) GetCacheViewMaximumThreads(); i++)
+  {
+    filter[i]=AcquireResampleFilter(image,exception);
+    if (filter[i] == (ResampleFilter *) NULL)
+      return(DestroyResampleFilterThreadSet(filter));
+  }
+  return(filter);
+}
+
 static SegmentInfo AffineEdge(const Image *image,const AffineMatrix *affine,
   const double y,const SegmentInfo *edge)
@@ -1081 +1117 @@
 
   long
-    x_offset,
     y;
 
-  MagickPixelPacket
-    composite,
-    pixel;
+  MagickBooleanType
+    status;
 
   PointInfo
@@ -1095 +1129 @@
 
   register long
-    i,
-    x;
-
-  register IndexPacket
-    *indexes;
-
-  register PixelPacket
-    *q;
+    i;
 
   ResampleFilter
-    *resample_filter;
+    **resample_filter;
 
   SegmentInfo
-    edge,
-    inverse_edge;
+    edge;
 
   ViewInfo
-    *image_view,
-    *source_view;
+    **image_view,
+    **source_view;
 
   /*
@@ -1157 +1183 @@
   if (SetImageStorageClass(image,DirectClass) == MagickFalse)
     return(MagickFalse);
-  GetMagickPixelPacket(image,&pixel);
-  GetMagickPixelPacket(image,&composite);
+  status=MagickTrue;
   edge.x1=MagickMax(min.x,0.0);
   edge.y1=MagickMax(min.y,0.0);
@@ -1164 +1189 @@
   edge.y2=MagickMin(max.y,(double) image->rows-1.0);
   inverse_affine=InverseAffineMatrix(affine);
-  resample_filter=AcquireResampleFilter(source,&image->exception);
-  image_view=AcquireCacheView(image);
-  source_view=AcquireCacheView(source);
+  resample_filter=AcquireResampleFilterThreadSet(source,&image->exception);
+  image_view=AcquireCacheViewThreadSet(image);
+  source_view=AcquireCacheViewThreadSet(source);
   for (y=(long) (edge.y1+0.5); y <= (long) (edge.y2+0.5); y++)
   {
+    long
+      x_offset;
+
+    MagickPixelPacket
+      composite,
+      pixel;
+
+    PointInfo
+      point;
+
+    register IndexPacket
+      *indexes;
+
+    register long
+      id,
+      x;
+
+    register PixelPacket
+      *q;
+
+    SegmentInfo
+      inverse_edge;
+
+    id=GetCacheViewThreadId();
     inverse_edge=AffineEdge(source,&inverse_affine,(double) y+0.5,&edge);
     if (inverse_edge.x2 < inverse_edge.x1)
       continue;
-    q=GetCacheViewPixels(image_view,(long) (inverse_edge.x1+0.5),y,
+    q=GetCacheViewPixels(image_view[id],(long) (inverse_edge.x1+0.5),y,
       (unsigned long) ((long) (inverse_edge.x2+0.5)-(long)
       (inverse_edge.x1+0.5)+1),1);
     if (q == (PixelPacket *) NULL)
       continue;
-    indexes=GetCacheViewIndexes(image_view);
+    indexes=GetCacheViewIndexes(image_view[id]);
+    GetMagickPixelPacket(image,&pixel);
+    GetMagickPixelPacket(image,&composite);
     x_offset=0;
     for (x=(long) (inverse_edge.x1+0.5); x <= (long) (inverse_edge.x2+0.5); x++)
@@ -1185 +1236 @@
       point.y=(double) x*inverse_affine.rx+y*inverse_affine.sy+
         inverse_affine.ty;
-      pixel=ResamplePixelColor(resample_filter,point.x,point.y);
+      pixel=ResamplePixelColor(resample_filter[id],point.x,point.y);
       SetMagickPixelPacket(image,q,indexes+x_offset,&composite);
       MagickPixelCompositeOver(&pixel,pixel.opacity,&composite,
@@ -1193 +1244 @@
       q++;
     }
-    if (SyncCacheView(image_view) == MagickFalse)
-      break;
+    if (SyncCacheView(image_view[id]) == MagickFalse)
+      status=MagickFalse;
   }
-  resample_filter=DestroyResampleFilter(resample_filter);
-  source_view=DestroyCacheView(source_view);
-  image_view=DestroyCacheView(image_view);
-  return(MagickTrue);
+  resample_filter=DestroyResampleFilterThreadSet(resample_filter);
+  source_view=DestroyCacheViewThreadSet(source_view);
+  image_view=DestroyCacheViewThreadSet(image_view);
+  return(status);
 }
 
@@ -3805 +3856 @@
         if (status == MagickFalse)
           continue;
+        x=start;
         id=GetCacheViewThreadId();
-        x=start;
         q=GetCacheViewPixels(image_view[id],x,y,(unsigned long) (stop-x+1),1);
         if (q == (PixelPacket *) NULL)