rmagick 2.16.0 → 5.1.0

data/ext/RMagick/rmfill.c

@@ -12,6 +12,11 @@
 
 #include "rmagick.h"
 
+static void GradientFill_free(void *fill);
+static size_t GradientFill_memsize(const void *ptr);
+static void TextureFill_free(void *fill_obj);
+static size_t TextureFill_memsize(const void *ptr);
+
 /** Data associated with a GradientFill */
 typedef struct
 {
@@ -19,8 +24,8 @@ typedef struct
     double y1; /**< y position of first point */
     double x2; /**< x position of second point */
     double y2; /**< y position of second point */
-    PixelPacket start_color; /**< the start color */
-    PixelPacket stop_color; /**< the stop color */
+    PixelColor start_color; /**< the start color */
+    PixelColor stop_color; /**< the stop color */
 } rm_GradientFill;
 
 /** Data associated with a TextureFill */
@@ -29,49 +34,76 @@ typedef struct
     Image *texture; /**< the texture */
 } rm_TextureFill;
 
+const rb_data_type_t rm_gradient_fill_data_type = {
+    "Magick::GradientFill",
+    { NULL, GradientFill_free, GradientFill_memsize, },
+    0, 0,
+    RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+const rb_data_type_t rm_texture_fill_data_type = {
+    "Magick::TextureFill",
+    { NULL, TextureFill_free, TextureFill_memsize, },
+    0, 0,
+    RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+
+DEFINE_GVL_STUB2(SyncAuthenticPixels, Image *, ExceptionInfo *);
+
+
 /**
- * Free Fill or Fill subclass object (except for TextureFill).
+ * Free GradientFill or GradientFill subclass object (except for TextureFill).
  *
  * No Ruby usage (internal function)
  *
  * @param fill the fill
  */
-static void free_Fill(void *fill)
+static void
+GradientFill_free(void *fill)
 {
     xfree(fill);
 }
 
+
+/**
+  * Get GradientFill object size.
+  *
+  * No Ruby usage (internal function)
+  *
+  * @param ptr pointer to the GradientFill object
+  */
+static size_t
+GradientFill_memsize(const void *ptr)
+{
+    return sizeof(rm_GradientFill);
+}
+
+
 /**
  * Create new GradientFill object.
  *
- * No Ruby usage (internal function)
- *
- * @param class the Ruby class to use
- * @return a new GradientFill object
+ * @return [Magick::GradientFill] a new GradientFill object
  */
 VALUE
 GradientFill_alloc(VALUE class)
 {
     rm_GradientFill *fill;
 
-    return Data_Make_Struct(class, rm_GradientFill, NULL, free_Fill, fill);
+    return TypedData_Make_Struct(class, rm_GradientFill, &rm_gradient_fill_data_type, fill);
 }
 
 
 /**
- * Store the vector points and the start and stop colors.
- *
- * Ruby usage:
- *   - @verbatim GradientFill#initialize(x1,y1,x2,y2,start_color,stop_color) @endverbatim
- *
- * @param self this object
- * @param x1 x position of first point
- * @param y1 y position of first point
- * @param x2 x position of second point
- * @param y2 y position of second point
- * @param start_color the start color
- * @param stop_color the stop color
- * @return self
+ * Initialize GradientFill object.
+ *
+ * @param x1 [Float] x position of first point
+ * @param y1 [Float] y position of first point
+ * @param x2 [Float] x position of second point
+ * @param y2 [Float] y position of second point
+ * @param start_color [Magick::Pixel, String] the start color
+ * @param stop_color [Magick::Pixel, String] the stop color
+ * @return [Magick::GradientFill] self
  */
 VALUE
 GradientFill_initialize(
@@ -85,14 +117,14 @@ GradientFill_initialize(
 {
     rm_GradientFill *fill;
 
-    Data_Get_Struct(self, rm_GradientFill, fill);
+    TypedData_Get_Struct(self, rm_GradientFill, &rm_gradient_fill_data_type, fill);
 
     fill->x1 = NUM2DBL(x1);
     fill->y1 = NUM2DBL(y1);
     fill->x2 = NUM2DBL(x2);
     fill->y2 = NUM2DBL(y2);
-    Color_to_PixelPacket(&fill->start_color, start_color);
-    Color_to_PixelPacket(&fill->stop_color, stop_color);
+    Color_to_PixelColor(&fill->start_color, start_color);
+    Color_to_PixelColor(&fill->stop_color, stop_color);
 
     return self;
 }
@@ -113,17 +145,15 @@ point_fill(
           Image *image,
           double x0,
           double y0,
-          PixelPacket *start_color,
-          PixelPacket *stop_color)
+          PixelColor *start_color,
+          PixelColor *stop_color)
 {
     double steps, distance;
-    unsigned long x, y;
+    ssize_t x, y;
     MagickRealType red_step, green_step, blue_step;
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
     ExceptionInfo *exception;
 
     exception = AcquireExceptionInfo();
-#endif
 
     steps = sqrt((double)((image->columns-x0)*(image->columns-x0)
                           + (image->rows-y0)*(image->rows-y0)));
@@ -132,38 +162,42 @@ point_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step  = ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
-        PixelPacket *row_pixels;
-
-#if defined(HAVE_QUEUEAUTHENTICPIXELS)
-        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, exception);
-        CHECK_EXCEPTION()
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
 #else
-        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
-        rm_check_image_exception(image, RetainOnError);
+        PixelPacket *row_pixels;
 #endif
-        for (x = 0; x < image->columns; x++)
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        for (x = 0; x < (ssize_t) image->columns; x++)
         {
             distance = sqrt((double)((x-x0)*(x-x0)+(y-y0)*(y-y0)));
+
+#if defined(IMAGEMAGICK_7)
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+#else
             row_pixels[x].red     = ROUND_TO_QUANTUM(start_color->red   + (distance * red_step));
             row_pixels[x].green   = ROUND_TO_QUANTUM(start_color->green + (distance * green_step));
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
+#endif
         }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
+        CHECK_EXCEPTION();
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
     DestroyExceptionInfo(exception);
-#endif
 }
 
 /**
@@ -181,18 +215,18 @@ static void
 vertical_fill(
              Image *image,
              double x1,
-             PixelPacket *start_color,
-             PixelPacket *stop_color)
+             PixelColor *start_color,
+             PixelColor *stop_color)
 {
     double steps;
-    unsigned long x, y;
-    PixelPacket *master;
+    ssize_t x, y;
     MagickRealType red_step, green_step, blue_step;
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
     ExceptionInfo *exception;
+#if defined(IMAGEMAGICK_6)
+    PixelPacket *master;
+#endif
 
     exception = AcquireExceptionInfo();
-#endif
 
     steps = FMAX(x1, ((long)image->columns)-x1);
 
@@ -208,11 +242,38 @@ vertical_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step  = ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
+
+#if defined(IMAGEMAGICK_7)
+    for (y = 0; y < (ssize_t) image->rows; y++)
+    {
+        Quantum *row_pixels;
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        for (x = 0; x < (ssize_t) image->columns; x++)
+        {
+            double distance = fabs(x1 - x);
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+        }
+
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
+        CHECK_EXCEPTION();
+    }
+
+    DestroyExceptionInfo(exception);
+#else
     // All the rows are the same. Make a "master row" and simply copy
     // it to each actual row.
     master = ALLOC_N(PixelPacket, image->columns);
 
-    for (x = 0; x < image->columns; x++)
+    for (x = 0; x < (ssize_t) image->columns; x++)
     {
         double distance   = fabs(x1 - x);
         master[x].red     = ROUND_TO_QUANTUM(start_color->red   + (red_step * distance));
@@ -222,34 +283,32 @@ vertical_fill(
     }
 
     // Now copy the master row to each actual row.
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
         PixelPacket *row_pixels;
 
-#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
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        if (rm_should_raise_exception(exception, RetainExceptionRetention))
+        {
+            xfree((void *)master);
+            rm_raise_exception(exception);
+        }
 
         memcpy(row_pixels, master, image->columns * sizeof(PixelPacket));
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
+        if (rm_should_raise_exception(exception, RetainExceptionRetention))
+        {
+            xfree((void *)master);
+            rm_raise_exception(exception);
+        }
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
     DestroyExceptionInfo(exception);
-#endif
 
-    xfree((void *)master);
+    xfree((void *) master);
+#endif
 }
 
 /**
@@ -266,18 +325,18 @@ static void
 horizontal_fill(
                Image *image,
                double y1,
-               PixelPacket *start_color,
-               PixelPacket *stop_color)
+               PixelColor *start_color,
+               PixelColor *stop_color)
 {
     double steps;
-    unsigned long x, y;
-    PixelPacket *master;
+    ssize_t x, y;
     MagickRealType red_step, green_step, blue_step;
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
     ExceptionInfo *exception;
+#if defined(IMAGEMAGICK_6)
+    PixelPacket *master;
+#endif
 
     exception = AcquireExceptionInfo();
-#endif
 
     steps = FMAX(y1, ((long)image->rows)-y1);
 
@@ -292,11 +351,37 @@ horizontal_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step  = ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
+#if defined(IMAGEMAGICK_7)
+    for (y = 0; y < (ssize_t) image->rows; y++)
+    {
+        Quantum *row_pixels;
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        double distance = fabs(y1 - y);
+        for (x = 0; x < (ssize_t) image->columns; x++)
+        {
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+        }
+
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
+        CHECK_EXCEPTION();
+    }
+
+    DestroyExceptionInfo(exception);
+#else
     // All the columns are the same, so make a master column and copy it to
     // each of the "real" columns.
     master = ALLOC_N(PixelPacket, image->rows);
 
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
         double distance   = fabs(y1 - y);
         master[y].red     = ROUND_TO_QUANTUM(start_color->red   + (distance * red_step));
@@ -305,32 +390,32 @@ horizontal_fill(
         master[y].opacity = OpaqueOpacity;
     }
 
-    for (x = 0; x < image->columns; x++)
+    for (x = 0; x < (ssize_t) image->columns; x++)
     {
         PixelPacket *col_pixels;
 
-#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
+        col_pixels = QueueAuthenticPixels(image, x, 0, 1, image->rows, exception);
+        if (rm_should_raise_exception(exception, RetainExceptionRetention))
+        {
+            xfree((void *)master);
+            rm_raise_exception(exception);
+        }
+
         memcpy(col_pixels, master, image->rows * sizeof(PixelPacket));
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
+        if (rm_should_raise_exception(exception, RetainExceptionRetention))
+        {
+            xfree((void *)master);
+            rm_raise_exception(exception);
+        }
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
     DestroyExceptionInfo(exception);
-#endif
 
-    xfree((PixelPacket *)master);
+    xfree((void *) master);
+#endif
 }
 
 /**
@@ -354,18 +439,16 @@ v_diagonal_fill(
                double y1,
                double x2,
                double y2,
-               PixelPacket *start_color,
-               PixelPacket *stop_color)
+               PixelColor *start_color,
+               PixelColor *stop_color)
 {
-    unsigned long x, y;
+    ssize_t x, y;
     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;
 
     exception = AcquireExceptionInfo();
-#endif
 
     // Compute the equation of the line: y=mx+b
     m = ((double)(y2 - y1))/((double)(x2 - x1));
@@ -379,7 +462,7 @@ v_diagonal_fill(
 
     if (d1 < 0 && d2 < 0)
     {
-        steps += FMAX(fabs(d1),fabs(d2));
+        steps += FMAX(fabs(d1), fabs(d2));
     }
     else if (d1 > (double)image->rows && d2 > (double)image->rows)
     {
@@ -393,7 +476,7 @@ v_diagonal_fill(
     // If the line is entirely > image->rows, swap the start & end color
     if (steps < 0)
     {
-        PixelPacket t = *stop_color;
+        PixelColor t = *stop_color;
         *stop_color = *start_color;
         *start_color = t;
         steps = -steps;
@@ -403,39 +486,41 @@ v_diagonal_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step =  ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
-        PixelPacket *row_pixels;
-
-#if defined(HAVE_QUEUEAUTHENTICPIXELS)
-        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, exception);
-        CHECK_EXCEPTION()
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
 #else
-        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
-        rm_check_image_exception(image, RetainOnError);
+        PixelPacket *row_pixels;
 #endif
-        for (x = 0; x < image->columns; x++)
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        for (x = 0; x < (ssize_t) image->columns; x++)
         {
             double distance = (double) abs((int)(y-(m * x + b)));
+#if defined(IMAGEMAGICK_7)
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+#else
             row_pixels[x].red     = ROUND_TO_QUANTUM(start_color->red   + (distance * red_step));
             row_pixels[x].green   = ROUND_TO_QUANTUM(start_color->green + (distance * green_step));
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
+#endif
         }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
+        CHECK_EXCEPTION();
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
     DestroyExceptionInfo(exception);
-#endif
-
 }
 
 /**
@@ -459,18 +544,16 @@ h_diagonal_fill(
                double y1,
                double x2,
                double y2,
-               PixelPacket *start_color,
-               PixelPacket *stop_color)
+               PixelColor *start_color,
+               PixelColor *stop_color)
 {
-    unsigned long x, y;
+    ssize_t x, y;
     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;
 
     exception = AcquireExceptionInfo();
-#endif
 
     // Compute the equation of the line: y=mx+b
     m = ((double)(y2 - y1))/((double)(x2 - x1));
@@ -486,11 +569,11 @@ h_diagonal_fill(
     // the number of steps.
     if (d1 < 0 && d2 < 0)
     {
-        steps += FMAX(fabs(d1),fabs(d2));
+        steps += FMAX(fabs(d1), fabs(d2));
     }
     else if (d1 > (double)image->columns && d2 > (double)image->columns)
     {
-        steps += FMAX(abs((int)(image->columns-d1)),abs((int)(image->columns-d2)));
+        steps += FMAX(abs((int)(image->columns-d1)), abs((int)(image->columns-d2)));
     }
 
     d1 = FMAX(d1, image->columns-d1);
@@ -500,7 +583,7 @@ h_diagonal_fill(
     // If the line is entirely > image->columns, swap the start & end color
     if (steps < 0)
     {
-        PixelPacket t = *stop_color;
+        PixelColor t = *stop_color;
         *stop_color = *start_color;
         *start_color = t;
         steps = -steps;
@@ -510,60 +593,59 @@ h_diagonal_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step =  ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
-        PixelPacket *row_pixels;
-
-#if defined(HAVE_QUEUEAUTHENTICPIXELS)
-        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, exception);
-        CHECK_EXCEPTION()
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
 #else
-        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
-        rm_check_image_exception(image, RetainOnError);
+        PixelPacket *row_pixels;
 #endif
-        for (x = 0; x < image->columns; x++)
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        for (x = 0; x < (ssize_t) image->columns; x++)
         {
             double distance = (double) abs((int)(x-((y-b)/m)));
+#if defined(IMAGEMAGICK_7)
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+#else
             row_pixels[x].red     = ROUND_TO_QUANTUM(start_color->red   + (distance * red_step));
             row_pixels[x].green   = ROUND_TO_QUANTUM(start_color->green + (distance * green_step));
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
+#endif
         }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
+        CHECK_EXCEPTION();
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
     DestroyExceptionInfo(exception);
-#endif
 }
 
 /**
  * Call GradientFill with the start and stop colors specified when this fill
  * object was created.
  *
- * Ruby usage:
- *   - @verbatim GradientFill#fill(image) @endverbatim
- *
- * @param self this object
- * @param image_obj the image
- * @return self
+ * @param image_obj [Magick::Image] the image to fill
+ * @return [Magick::GradientFill] self
  */
 VALUE
 GradientFill_fill(VALUE self, VALUE image_obj)
 {
     rm_GradientFill *fill;
     Image *image;
-    PixelPacket start_color, stop_color;
+    PixelColor start_color, stop_color;
     double x1, y1, x2, y2;          // points on the line
 
-    Data_Get_Struct(self, rm_GradientFill, fill);
+    TypedData_Get_Struct(self, rm_GradientFill, &rm_gradient_fill_data_type, fill);
     image = rm_check_destroyed(image_obj);
 
     x1 = fill->x1;
@@ -626,49 +708,51 @@ GradientFill_fill(VALUE self, VALUE image_obj)
  * @param fill_obj the TextureFill
  */
 static void
-free_TextureFill(void *fill_obj)
+TextureFill_free(void *fill_obj)
 {
     rm_TextureFill *fill = (rm_TextureFill *)fill_obj;
 
     // Do not trace destruction
-    (void) DestroyImage(fill->texture);
+    if (fill->texture)
+    {
+        DestroyImage(fill->texture);
+    }
     xfree(fill);
 }
 
+
+/**
+  * Get TextureFill object size.
+  *
+  * No Ruby usage (internal function)
+  *
+  * @param ptr pointer to the TextureFill object
+  */
+static size_t
+TextureFill_memsize(const void *ptr)
+{
+    return sizeof(rm_TextureFill);
+}
+
+
 /**
  * Create new TextureFill object.
  *
- * No Ruby usage (internal function)
- *
- * Notes:
- *   - The texture is an Image or Image *object
- *
- * @param class the Ruby class to use
- * @return a new TextureFill object
+ * @return [Magick::TextureFill] a new TextureFill object
  */
 VALUE
 TextureFill_alloc(VALUE class)
 {
     rm_TextureFill *fill;
-    return Data_Make_Struct(class
-                            , rm_TextureFill
-                            , NULL
-                            , free_TextureFill
-                            , fill);
+    return TypedData_Make_Struct(class, rm_TextureFill, &rm_texture_fill_data_type, fill);
 }
 
 /**
- * Store the texture image.
- *
- * Ruby usage:
- *   - @verbatim TextureFill#initialize(texture) @endverbatim
- *
- * Notes:
- *   - The texture is an Image or Image *object
+ * Initialize TextureFill object.
  *
- * @param self this object
- * @param texture_arg the texture
- * @return self
+ * @param texture_arg [Magick::Image, Magick::ImageList] Either an imagelist or an image. If an
+ *   imagelist, uses the current image.
+ * @return [Magick::TextureFill] self
  */
 VALUE
 TextureFill_initialize(VALUE self, VALUE texture_arg)
@@ -677,13 +761,13 @@ TextureFill_initialize(VALUE self, VALUE texture_arg)
     Image *texture;
     VALUE texture_image;
 
-    Data_Get_Struct(self, rm_TextureFill, fill);
+    TypedData_Get_Struct(self, rm_TextureFill, &rm_texture_fill_data_type, fill);
 
     texture_image = rm_cur_image(texture_arg);
 
     // Bump the reference count on the texture image.
     texture = rm_check_destroyed(texture_image);
-    (void) ReferenceImage(texture);
+    ReferenceImage(texture);
 
     fill->texture = texture;
 
@@ -696,24 +780,30 @@ TextureFill_initialize(VALUE self, VALUE texture_arg)
  * Call TextureFill with the texture specified when this fill object was
  * created.
  *
- * Ruby usage:
- *   - @verbatim TextureFill#fill(image) @endverbatim
- *
- * @param self this object
- * @param image_obj the image
- * @return self
+ * @param image_obj [Magick::Image] the image to fill
+ * @return [Magick::TextureFill] self
  */
 VALUE
 TextureFill_fill(VALUE self, VALUE image_obj)
 {
     rm_TextureFill *fill;
     Image *image;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+#endif
 
     image = rm_check_destroyed(image_obj);
-    Data_Get_Struct(self, rm_TextureFill, fill);
+    TypedData_Get_Struct(self, rm_TextureFill, &rm_texture_fill_data_type, fill);
 
-    (void) TextureImage(image, fill->texture);
+#if defined(IMAGEMAGICK_7)
+    exception = AcquireExceptionInfo();
+    TextureImage(image, fill->texture, exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+#else
+    TextureImage(image, fill->texture);
     rm_check_image_exception(image, RetainOnError);
+#endif
 
     return self;
 }