rmagick 2.9.1 → 2.9.2

data/ext/RMagick/rmenum.c

@@ -1,6 +1,6 @@
-/* $Id: rmenum.c,v 1.1 2008/12/27 16:49:47 rmagick Exp $ */
+/* $Id: rmenum.c,v 1.3 2009/03/18 22:40:41 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2008 by Timothy P. Hunter
+|                Copyright (C) 2009 by Timothy P. Hunter
 | Name:     rmenum.c
 | Author:   Tim Hunter
 | Purpose:  Enumeration methods
@@ -204,7 +204,7 @@ Enum_type_inspect(VALUE self)
     MagickEnum *magick_enum;
 
     Data_Get_Struct(self, MagickEnum, magick_enum);
-    sprintf(str, "%.32s=%d", rb_id2name(magick_enum->id), magick_enum->val);
+    sprintf(str, "%.48s=%d", rb_id2name(magick_enum->id), magick_enum->val);
 
     return rb_str_new2(str);
 }
@@ -997,6 +997,15 @@ VirtualPixelMethod_name(VirtualPixelMethod method)
 #endif
 #if defined(HAVE_ENUM_VERTICALTILEVIRTUALPIXELMETHOD)
         ENUM_TO_NAME(VerticalTileVirtualPixelMethod)
+#endif
+#if defined(HAVE_ENUM_HORIZONTALTILEEDGEVIRTUALPIXELMETHOD)
+        ENUM_TO_NAME(HorizontalTileEdgeVirtualPixelMethod)
+#endif
+#if defined(HAVE_ENUM_VERTICALTILEEDGEVIRTUALPIXELMETHOD)
+        ENUM_TO_NAME(VerticalTileEdgeVirtualPixelMethod)
+#endif
+#if defined(HAVE_ENUM_CHECKERTILEVIRTUALPIXELMETHOD)
+        ENUM_TO_NAME(CheckerTileVirtualPixelMethod)
 #endif
     }
 

data/ext/RMagick/rmfill.c

@@ -1,6 +1,6 @@
-/* $Id: rmfill.c,v 1.30 2008/09/02 23:40:19 rmagick Exp $ */
+/* $Id: rmfill.c,v 1.32 2009/03/04 00:35:18 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2008 by Timothy P. Hunter
+|                Copyright (C) 2009 by Timothy P. Hunter
 | Name:     rmfill.c
 | Author:   Tim Hunter
 | Purpose:  GradientFill, TextureFill class definitions for RMagick
@@ -86,6 +86,11 @@ point_fill(
     double steps, distance;
     unsigned long x, y;
     MagickRealType red_step, green_step, blue_step;
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    ExceptionInfo exception;
+
+    GetExceptionInfo(&exception);
+#endif
 
     steps = sqrt((double)((image->columns-x0)*(image->columns-x0)
                           + (image->rows-y0)*(image->rows-y0)));
@@ -98,10 +103,13 @@ point_fill(
     {
         PixelPacket *row_pixels;
 
-        if (!(row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1)))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+#if defined(HAVE_QUEUEAUTHENTICPIXELS)
+        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, &exception);
+        CHECK_EXCEPTION()
+#else
+        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
+        rm_check_image_exception(image, RetainOnError);
+#endif
         for (x = 0; x < image->columns; x++)
         {
             distance = sqrt((double)((x-x0)*(x-x0)+(y-y0)*(y-y0)));
@@ -110,11 +118,19 @@ point_fill(
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
         }
-        if (!SyncImagePixels(image))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+        SyncAuthenticPixels(image, &exception);
+        CHECK_EXCEPTION()
+#else
+        SyncImagePixels(image);
+        rm_check_image_exception(image, RetainOnError);
+#endif
     }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    DestroyExceptionInfo(&exception);
+#endif
 }
 
 /*
@@ -133,6 +149,11 @@ vertical_fill(
     unsigned long x, y;
     PixelPacket *master;
     MagickRealType red_step, green_step, blue_step;
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    ExceptionInfo exception;
+
+    GetExceptionInfo(&exception);
+#endif
 
     steps = FMAX(x1, ((long)image->columns)-x1);
 
@@ -166,18 +187,29 @@ vertical_fill(
     {
         PixelPacket *row_pixels;
 
-        if (!(row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1)))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+#if defined(HAVE_QUEUEAUTHENTICPIXELS)
+        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, &exception);
+        CHECK_EXCEPTION()
+#else
+        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
+        rm_check_image_exception(image, RetainOnError);
+#endif
 
         memcpy(row_pixels, master, image->columns * sizeof(PixelPacket));
-        if (!SyncImagePixels(image))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+        SyncAuthenticPixels(image, &exception);
+        CHECK_EXCEPTION()
+#else
+        SyncImagePixels(image);
+        rm_check_image_exception(image, RetainOnError);
+#endif
     }
 
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    DestroyExceptionInfo(&exception);
+#endif
+
     xfree((void *)master);
 }
 
@@ -196,6 +228,11 @@ horizontal_fill(
     unsigned long x, y;
     PixelPacket *master;
     MagickRealType red_step, green_step, blue_step;
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    ExceptionInfo exception;
+
+    GetExceptionInfo(&exception);
+#endif
 
     steps = FMAX(y1, ((long)image->rows)-y1);
 
@@ -227,17 +264,27 @@ horizontal_fill(
     {
         PixelPacket *col_pixels;
 
-        if (!(col_pixels = SetImagePixels(image, (long int)x, 0, 1, image->rows)))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+#if defined(HAVE_QUEUEAUTHENTICPIXELS)
+        col_pixels = QueueAuthenticPixels(image, (long int)x, 0, 1, image->rows, &exception);
+#else
+        col_pixels = SetImagePixels(image, (long int)x, 0, 1, image->rows);
+        rm_check_image_exception(image, RetainOnError);
+#endif
         memcpy(col_pixels, master, image->rows * sizeof(PixelPacket));
-        if (!SyncImagePixels(image))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+        SyncAuthenticPixels(image, &exception);
+        CHECK_EXCEPTION()
+#else
+        SyncImagePixels(image);
+        rm_check_image_exception(image, RetainOnError);
+#endif
     }
 
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    DestroyExceptionInfo(&exception);
+#endif
+
     xfree((PixelPacket *)master);
 }
 
@@ -260,6 +307,11 @@ v_diagonal_fill(
     MagickRealType red_step, green_step, blue_step;
     double m, b, steps = 0.0;
     double d1, d2;
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    ExceptionInfo exception;
+
+    GetExceptionInfo(&exception);
+#endif
 
     // Compute the equation of the line: y=mx+b
     m = ((double)(y2 - y1))/((double)(x2 - x1));
@@ -301,10 +353,13 @@ v_diagonal_fill(
     {
         PixelPacket *row_pixels;
 
-        if (!(row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1)))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+#if defined(HAVE_QUEUEAUTHENTICPIXELS)
+        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, &exception);
+        CHECK_EXCEPTION()
+#else
+        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
+        rm_check_image_exception(image, RetainOnError);
+#endif
         for (x = 0; x < image->columns; x++)
         {
             double distance = (double) abs((int)(y-(m * x + b)));
@@ -313,11 +368,20 @@ v_diagonal_fill(
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
         }
-        if (!SyncImagePixels(image))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+        SyncAuthenticPixels(image, &exception);
+        CHECK_EXCEPTION()
+#else
+        SyncImagePixels(image);
+        rm_check_image_exception(image, RetainOnError);
+#endif
     }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    DestroyExceptionInfo(&exception);
+#endif
+
 }
 
 /*
@@ -339,6 +403,11 @@ h_diagonal_fill(
     double m, b, steps = 0.0;
     MagickRealType red_step, green_step, blue_step;
     double d1, d2;
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    ExceptionInfo exception;
+
+    GetExceptionInfo(&exception);
+#endif
 
     // Compute the equation of the line: y=mx+b
     m = ((double)(y2 - y1))/((double)(x2 - x1));
@@ -382,10 +451,13 @@ h_diagonal_fill(
     {
         PixelPacket *row_pixels;
 
-        if (!(row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1)))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+#if defined(HAVE_QUEUEAUTHENTICPIXELS)
+        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, &exception);
+        CHECK_EXCEPTION()
+#else
+        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
+        rm_check_image_exception(image, RetainOnError);
+#endif
         for (x = 0; x < image->columns; x++)
         {
             double distance = (double) abs((int)(x-((y-b)/m)));
@@ -394,11 +466,19 @@ h_diagonal_fill(
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
         }
-        if (!SyncImagePixels(image))
-        {
-            rm_check_image_exception(image, RetainOnError);
-        }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+        SyncAuthenticPixels(image, &exception);
+        CHECK_EXCEPTION()
+#else
+        SyncImagePixels(image);
+        rm_check_image_exception(image, RetainOnError);
+#endif
     }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
+    DestroyExceptionInfo(&exception);
+#endif
 }
 
 /*

data/ext/RMagick/rmilist.c

@@ -1,6 +1,6 @@
-/* $Id: rmilist.c,v 1.90 2008/11/13 00:03:32 rmagick Exp $ */
+/* $Id: rmilist.c,v 1.91 2009/02/28 23:50:35 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2008 by Timothy P. Hunter
+|                Copyright (C) 2009 by Timothy P. Hunter
 | Name:     rmilist.c
 | Author:   Tim Hunter
 | Purpose:  ImageList class method definitions for RMagick

data/ext/RMagick/rmimage.c

@@ -1,6 +1,6 @@
-/* $Id: rmimage.c,v 1.344 2009/01/17 21:03:46 rmagick Exp $ */
+/* $Id: rmimage.c,v 1.346 2009/03/04 00:35:19 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2008 by Timothy P. Hunter
+|                Copyright (C) 2009 by Timothy P. Hunter
 | Name:     rmimage.c
 | Author:   Tim Hunter
 | Purpose:  Image class method definitions for RMagick
@@ -5281,7 +5281,11 @@ Image_get_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg, VALUE row
     // Cast AcquireImagePixels to get rid of the const qualifier. We're not going
     // to change the pixels but I don't want to make "pixels" const.
     GetExceptionInfo(&exception);
+#if defined(HAVE_GETVIRTUALPIXELS)
+    pixels = GetVirtualPixels(image, x, y, columns, rows, &exception);
+#else
     pixels = AcquireImagePixels(image, x, y, columns, rows, &exception);
+#endif
     CHECK_EXCEPTION()
 
     (void) DestroyExceptionInfo(&exception);
@@ -6431,10 +6435,18 @@ Image_mask(int argc, VALUE *argv, VALUE self)
         }
 
         // The following section is copied from mogrify.c (6.2.8-8)
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+        GetExceptionInfo(&exception);
+#endif
         for (y = 0; y < (long) clip_mask->rows; y++)
         {
+#if defined(HAVE_GETAUTHENTICPIXELS)
+            q = GetAuthenticPixels(clip_mask, 0, y, clip_mask->columns, 1, &exception);
+            rm_check_exception(&exception, clip_mask, DestroyOnError);
+#else
             q = GetImagePixels(clip_mask, 0, y, clip_mask->columns, 1);
             rm_check_image_exception(clip_mask, DestroyOnError);
+#endif
             if (!q)
             {
                 break;
@@ -6450,9 +6462,18 @@ Image_mask(int argc, VALUE *argv, VALUE self)
                 q->blue = q->opacity;
                 q += 1;
             }
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+            SyncAuthenticPixels(clip_mask, &exception);
+            rm_check_exception(&exception, clip_mask, DestroyOnError);
+#else
             SyncImagePixels(clip_mask);
             rm_check_image_exception(clip_mask, DestroyOnError);
+#endif
         }
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+        (void) DestroyExceptionInfo(&exception);
+#endif
 
         SetImageStorageClass(clip_mask, DirectClass);
         rm_check_image_exception(clip_mask, DestroyOnError);
@@ -7518,7 +7539,11 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
     if (!set)
     {
         GetExceptionInfo(&exception);
+#if defined(HAVE_GETVIRTUALPIXELS)
+        old_color = *GetVirtualPixels(image, x, y, 1, 1, &exception);
+#else
         old_color = *AcquireImagePixels(image, x, y, 1, 1, &exception);
+#endif
         CHECK_EXCEPTION()
 
         (void) DestroyExceptionInfo(&exception);
@@ -7526,7 +7551,11 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
         // PseudoClass
         if (image->storage_class == PseudoClass)
         {
+#if defined(HAVE_GETAUTHENTICINDEXQUEUE)
+            IndexPacket *indexes = GetAuthenticIndexQueue(image);
+#else
             IndexPacket *indexes = GetIndexes(image);
+#endif
             old_color = image->colormap[*indexes];
         }
         if (!image->matte)
@@ -7555,8 +7584,19 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
         }
     }
 
+
+#if defined(HAVE_GETAUTHENTICPIXELS) || defined(HAVE_SYNCAUTHENTICPIXELS)
+    GetExceptionInfo(&exception);
+#endif
+
+#if defined(HAVE_GETAUTHENTICPIXELS)
+    pixel = GetAuthenticPixels(image, x, y, 1, 1, &exception);
+    CHECK_EXCEPTION()
+#else
     pixel = GetImagePixels(image, x, y, 1, 1);
     rm_check_image_exception(image, RetainOnError);
+#endif
+
     if (pixel)
     {
         old_color = *pixel;
@@ -7566,8 +7606,18 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
         }
     }
     *pixel = new_color;
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+    SyncAuthenticPixels(image, &exception);
+    CHECK_EXCEPTION()
+#else
     SyncImagePixels(image);
     rm_check_image_exception(image, RetainOnError);
+#endif
+
+#if defined(HAVE_GETAUTHENTICPIXELS) || defined(HAVE_SYNCAUTHENTICPIXELS)
+    (void) DestroyExceptionInfo(&exception);
+#endif
 
     return Pixel_from_PixelPacket(&old_color);
 }
@@ -9755,20 +9805,40 @@ Image_store_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg
 
     // Get a pointer to the pixels. Replace the values with the PixelPackets
     // from the pixels argument.
-    pixels = GetImagePixels(image, x, y, cols, rows);
-    rm_check_image_exception(image, RetainOnError);
-
-    if (pixels)
     {
-        for (n = 0; n < size; n++)
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_GETAUTHENTICPIXELS)
+        ExceptionInfo exception;
+        GetExceptionInfo(&exception);
+#endif
+
+#if defined(HAVE_GETAUTHENTICPIXELS)
+        pixels = GetAuthenticPixels(image, x, y, cols, rows, &exception);
+        CHECK_EXCEPTION()
+#else
+        pixels = GetImagePixels(image, x, y, cols, rows);
+        rm_check_image_exception(image, RetainOnError);
+#endif
+
+        if (pixels)
         {
-            new_pixel = rb_ary_entry(new_pixels, n);
-            Data_Get_Struct(new_pixel, Pixel, pixel);
-            pixels[n] = *pixel;
+            for (n = 0; n < size; n++)
+            {
+                new_pixel = rb_ary_entry(new_pixels, n);
+                Data_Get_Struct(new_pixel, Pixel, pixel);
+                pixels[n] = *pixel;
+            }
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+            SyncAuthenticPixels(image, &exception);
+            CHECK_EXCEPTION()
+#else
+            SyncImagePixels(image);
+            rm_check_image_exception(image, RetainOnError);
+#endif
         }
 
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
+#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_GETAUTHENTICPIXELS)
+        DestroyExceptionInfo(&exception);
+#endif
     }
 
     return self;
@@ -11106,16 +11176,25 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
             opacity = TransparentOpacity;
         }
 
+
+#if defined(HAVE_GETVIRTUALPIXELS)
+        p = GetVirtualPixels(reflection, 0, y, image->columns, 1, &exception);
+#else
         p = AcquireImagePixels(reflection, 0, y, image->columns, 1, &exception);
-        rm_check_exception(&exception, reflection, RetainOnError);
+#endif
+        rm_check_exception(&exception, reflection, DestroyOnError);
         if (!p)
         {
             func = "AcquireImagePixels";
             goto error;
         }
 
+#if defined(HAVE_QUEUEAUTHENTICPIXELS)
+        q = QueueAuthenticPixels(reflection, 0, y, image->columns, 1, &exception);
+#else
         q = SetImagePixels(reflection, 0, y, image->columns, 1);
-        rm_check_image_exception(reflection, DestroyOnError);
+#endif
+        rm_check_exception(&exception, reflection, DestroyOnError);
         if (!q)
         {
             func = "SetImagePixels";
@@ -11129,8 +11208,14 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
             q[x].opacity = max(q[x].opacity, (Quantum)opacity);
         }
 
+
+#if defined(HAVE_SYNCAUTHENTICPIXELS)
+        SyncAuthenticPixels(reflection, &exception);
+        rm_check_exception(&exception, reflection, DestroyOnError);
+#else
         SyncImagePixels(reflection);
         rm_check_image_exception(reflection, DestroyOnError);
+#endif
 
         opacity += step;
     }