rmagick 3.2.0 → 4.3.0

data/ext/RMagick/rmutil.c

@@ -12,7 +12,13 @@
 
 #include "rmagick.h"
 #include <errno.h>
+#if defined(_WIN32)
+#include <Windows.h>
+#else
+#include <pthread.h>
+#endif
 
+static VALUE rescue_not_str(VALUE, VALUE ATTRIBUTE_UNUSED) ATTRIBUTE_NORETURN;
 static void handle_exception(ExceptionInfo *, Image *, ErrorRetention);
 
 
@@ -78,7 +84,7 @@ magick_malloc(const size_t size)
 void
 magick_free(void *ptr)
 {
-    (void) RelinquishMagickMemory(ptr);
+    RelinquishMagickMemory(ptr);
 }
 
 
@@ -112,28 +118,6 @@ magick_safe_realloc(void *memory, const size_t count, const size_t quantum)
 }
 
 
-/**
- * ImageMagick version of realloc.
- *
- * No Ruby usage (internal function)
- *
- * @param ptr pointer to the existing block of memory
- * @param size the new size of memory to allocate
- * @return pointer to a block of memory
- */
-void *
-magick_realloc(void *ptr, const size_t size)
-{
-    void *v;
-    v = ResizeMagickMemory(ptr, size);
-    if (!v)
-    {
-        rb_raise(rb_eNoMemError, "not enough memory to continue");
-    }
-    return v;
-}
-
-
 /**
  * Make a copy of a string in malloc'd memory.
  *
@@ -149,7 +133,7 @@ magick_realloc(void *ptr, const size_t size)
 void
  magick_clone_string(char **new_str, const char *str)
 {
-    (void) CloneString(new_str, str);
+    CloneString(new_str, str);
 }
 
 
@@ -208,6 +192,28 @@ rm_strncasecmp(const char *s1, const char *s2, size_t n)
 }
 
 
+/**
+ * Get string length.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param str the string
+ * @param strsz the maximum number of characters
+ * @return same as strnlen_s()
+ */
+size_t
+rm_strnlen_s(const char *str, size_t strsz)
+{
+    size_t length = 0;
+    while(*str && length < strsz)
+    {
+        str++;
+        length++;
+    }
+    return length;
+}
+
+
 /**
  * Raise exception if array too short.
  *
@@ -243,7 +249,7 @@ rm_check_ary_type(VALUE ary)
     VALUE checked = rb_check_array_type(ary);
     if (NIL_P(checked))
     {
-        rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" was given. (must respond to :to_ary)", rb_obj_class(ary));
+        rb_raise(rb_eTypeError, "wrong argument type %"RMIsVALUE" was given. (must respond to :to_ary)", rb_obj_class(ary));
     }
     return checked;
 }
@@ -295,35 +301,12 @@ rm_check_frozen(VALUE obj)
  *
  * No Ruby usage (internal function)
  *
- * @param obj the object of the class to override
- * @return 0
- * @throw TypeError
+ * @raise [TypeError]
  */
 VALUE
 rm_no_freeze(VALUE obj)
 {
     rb_raise(rb_eTypeError, "can't freeze %s", rb_class2name(CLASS_OF(obj)));
-    return (VALUE)0;
-}
-
-
-/**
- * Return obj.to_s, or obj if obj is already a string.
- *
- * No Ruby usage (internal function)
- *
- * @param obj a Ruby object
- * @return a String representation of obj
- */
-VALUE
-rm_to_s(VALUE obj)
-{
-
-    if (TYPE(obj) != T_STRING)
-    {
-        return rb_funcall(obj, rm_ID_to_s, 0);
-    }
-    return obj;
 }
 
 
@@ -348,21 +331,6 @@ rm_str2cstr(VALUE str, long *len)
 }
 
 
-/**
- * Try to convert the argument to a double, raise an exception if fail.
- *
- * No Ruby usage (internal function)
- *
- * @param arg the argument
- * @return arg
- */
-static VALUE
-arg_is_number(VALUE arg)
-{
-    return DBL2NUM(NUM2DBL(arg));
-}
-
-
 /**
  * Called when `rb_str_to_str' raises an exception.
  *
@@ -373,11 +341,10 @@ arg_is_number(VALUE arg)
  * @throw TypeError
  */
 static VALUE
-rescue_not_str(VALUE arg)
+rescue_not_str(VALUE arg, VALUE raised_exc ATTRIBUTE_UNUSED)
 {
     rb_raise(rb_eTypeError, "argument must be a number or a string in the form 'NN%%' (%s given)",
             rb_class2name(CLASS_OF(arg)));
-    return (VALUE)0;
 }
 
 
@@ -396,17 +363,15 @@ double
 rm_percentage(VALUE arg, double max)
 {
     double pct;
-    long pct_long;
-    char *pct_str, *end;
-    int not_num;
-
-    // Try to convert the argument to a number. If failure, sets not_num to non-zero.
-    (void) rb_protect(arg_is_number, arg, &not_num);
+    char *end;
 
-    if (not_num)
+    if (!rm_check_num2dbl(arg))
     {
+        char *pct_str;
+        long pct_long;
+
         arg = rb_rescue(rb_str_to_str, arg, rescue_not_str, arg);
-        pct_str = StringValuePtr(arg);
+        pct_str = StringValueCStr(arg);
         errno = 0;
         pct_long = strtol(pct_str, &end, 10);
         if (errno == ERANGE)
@@ -455,7 +420,7 @@ rm_percentage(VALUE arg, double max)
 static VALUE
 check_num2dbl(VALUE obj)
 {
-    (void) rb_num2dbl(obj);
+    rb_num2dbl(obj);
     return INT2FIX(1);
 }
 
@@ -469,7 +434,7 @@ check_num2dbl(VALUE obj)
  * @return 0
  */
 static VALUE
-rescue_not_dbl(VALUE ignored ATTRIBUTE_UNUSED)
+rescue_not_dbl(VALUE ignored ATTRIBUTE_UNUSED, VALUE raised_exc ATTRIBUTE_UNUSED)
 {
     return INT2FIX(0);
 }
@@ -505,7 +470,7 @@ rm_str_to_pct(VALUE str)
     char *pct_str, *end;
 
     str = rb_rescue(rb_str_to_str, str, rescue_not_str, str);
-    pct_str = StringValuePtr(str);
+    pct_str = StringValueCStr(str);
     errno = 0;
     pct = strtol(pct_str, &end, 10);
 
@@ -541,17 +506,15 @@ double
 rm_fuzz_to_dbl(VALUE fuzz_arg)
 {
     double fuzz;
-    char *fuzz_str, *end;
-    int not_num;
-
-    // Try to convert the argument to a number. If failure, sets not_num to non-zero.
-    (void) rb_protect(arg_is_number, fuzz_arg, &not_num);
+    char *end;
 
-    if (not_num)
+    if (!rm_check_num2dbl(fuzz_arg))
     {
+        char *fuzz_str;
+
         // Convert to string, issue error message if failure.
         fuzz_arg = rb_rescue(rb_str_to_str, fuzz_arg, rescue_not_str, fuzz_arg);
-        fuzz_str = StringValuePtr(fuzz_arg);
+        fuzz_str = StringValueCStr(fuzz_arg);
         errno = 0;
         fuzz = strtod(fuzz_str, &end);
         if (errno == ERANGE)
@@ -606,11 +569,9 @@ rm_app2quantum(VALUE obj)
 
     if (TYPE(obj) == T_FLOAT)
     {
-        v = rb_funcall(obj, rm_ID_to_i, 0);
+        v = rb_Integer(obj);
     }
 
-    RB_GC_GUARD(v);
-
     return NUM2QUANTUM(v);
 }
 
@@ -626,7 +587,18 @@ rm_app2quantum(VALUE obj)
 Image *
 rm_acquire_image(ImageInfo *info)
 {
+#if defined(IMAGEMAGICK_7)
+    Image *new_image;
+    ExceptionInfo *exception;
+
+    exception = AcquireExceptionInfo();
+    new_image = AcquireImage(info, exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+    return new_image;
+#else
     return AcquireImage(info);
+#endif
 }
 
 
@@ -660,14 +632,21 @@ rm_cur_image(VALUE img)
 VALUE
 rm_pixelcolor_to_color_name(Image *image, PixelColor *color)
 {
+    PixelColor pp;
     char name[MaxTextExtent];
     ExceptionInfo *exception;
 
     exception = AcquireExceptionInfo();
 
-    (void) QueryColorname(image, color, X11Compliance, name, exception);
-    CHECK_EXCEPTION()
-    (void) DestroyExceptionInfo(exception);
+    pp = *color;
+#if defined(IMAGEMAGICK_7)
+    pp.depth = MAGICKCORE_QUANTUM_DEPTH;
+    pp.colorspace = image->colorspace;
+#endif
+
+    QueryColorname(image, &pp, X11Compliance, name, exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
 
     return rb_str_new2(name);
 }
@@ -701,9 +680,14 @@ rm_pixelcolor_to_color_name_info(Info *info, PixelColor *color)
         rb_raise(rb_eNoMemError, "not enough memory to continue.");
     }
 
+#if defined(IMAGEMAGICK_7)
+    image->alpha_trait = UndefinedPixelTrait;
+#else
     image->matte = MagickFalse;
+#endif
+
     color_name = rm_pixelcolor_to_color_name(image, color);
-    (void) DestroyImage(image);
+    DestroyImage(image);
 
     return color_name;
 }
@@ -719,7 +703,11 @@ rm_pixelcolor_to_color_name_info(Info *info, PixelColor *color)
 void
 rm_init_magickpixel(const Image *image, MagickPixel *pp)
 {
+#if defined(IMAGEMAGICK_7)
+    GetPixelInfo(image, pp);
+#else
     GetMagickPixelPacket(image, pp);
+#endif
 }
 
 /**
@@ -736,10 +724,15 @@ rm_set_magickpixel(MagickPixel *pp, const char *color)
     ExceptionInfo *exception;
 
     exception = AcquireExceptionInfo();
-    (void) QueryMagickColor(color, pp, exception);
+
+#if defined(IMAGEMAGICK_7)
+    QueryColorCompliance(color, AllCompliance, pp, exception);
+#else
+    QueryMagickColor(color, pp, exception);
+#endif
     // This exception is ignored because the color comes from places where we control
     // the value and it is very unlikely that an exception will be thrown.
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 }
 
 /**
@@ -753,10 +746,11 @@ rm_set_magickpixel(MagickPixel *pp, const char *color)
  *
  * @param image the image
  * @param temp_name the temporary name to use
+ * @param temp_name_l the length of temp_name
  * @return the "filename" of the registered image
  */
 void
-rm_write_temp_image(Image *image, char *temp_name)
+rm_write_temp_image(Image *image, char *temp_name, size_t temp_name_l)
 {
 
 #define TMPNAM_CLASS_VAR "@@_tmpnam_"
@@ -783,11 +777,11 @@ rm_write_temp_image(Image *image, char *temp_name)
 
     id += 1;
     rb_cv_set(Module_Magick, TMPNAM_CLASS_VAR, INT2FIX(id));
-    sprintf(temp_name, "mpri:%d", id);
+    snprintf(temp_name, temp_name_l, "mpri:%d", id);
 
     // Omit "mpri:" from filename to form the key
     okay = SetImageRegistry(ImageRegistryType, temp_name+5, image, exception);
-    CHECK_EXCEPTION()
+    CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
     if (!okay)
     {
@@ -858,28 +852,40 @@ rm_magick_error(const char *msg)
     mesg = rb_str_new2(msg);
 
     exc = rb_funcall(Class_ImageMagickError, rm_ID_new, 2, mesg, Qnil);
-    (void) rb_funcall(rb_cObject, rb_intern("raise"), 1, exc);
+    rb_funcall(rb_cObject, rb_intern("raise"), 1, exc);
 
     RB_GC_GUARD(exc);
     RB_GC_GUARD(mesg);
 }
 
-
+#if defined(IMAGEMAGICK_7)
 /**
- * Initialize a new ImageMagickError object - store the "loc" string in the
- * \@magick_location instance variable.
+ * Sets the alpha channel of a pixel color
  *
- * Ruby usage:
- *   - @verbatim ImageMagickError#initialize(msg) @endverbatim
- *   - @verbatim ImageMagickError#initialize(msg, loc) @endverbatim
+ * No Ruby usage (internal function)
  *
- * Notes:
- *   - Default loc is nil
+ * @param pixel the Pixel
+ * @param value the value
+ */
+void
+rm_set_pixelinfo_alpha(PixelInfo *pixel, const MagickRealType value)
+{
+    pixel->alpha = value;
+    if (value != (MagickRealType) OpaqueAlpha)
+    {
+        pixel->alpha_trait = BlendPixelTrait;
+    }
+}
+#endif
+
+/**
+ * Initialize a new ImageMagickError object - store the "loc" string in the
+ * magick_location instance variable.
  *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return self
+ * @overload initialize(msg, loc = nil)
+ *   @param msg [String] the exception message
+ *   @param loc [String] the location stored in the magick_location instance variable
+ *   @return [Magick::ImageMagickError] self
  */
 VALUE
 ImageMagickError_initialize(int argc, VALUE *argv, VALUE self)
@@ -901,8 +907,8 @@ ImageMagickError_initialize(int argc, VALUE *argv, VALUE self)
             rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 2)", argc);
     }
 
-    (void) rb_call_super(super_argc, (const VALUE *)super_argv);
-    (void) rb_iv_set(self, "@"MAGICK_LOC, extra);
+    rb_call_super(super_argc, (const VALUE *)super_argv);
+    rb_iv_set(self, "@"MAGICK_LOC, extra);
 
     RB_GC_GUARD(extra);
 
@@ -922,7 +928,18 @@ ImageMagickError_initialize(int argc, VALUE *argv, VALUE self)
 const char *
 rm_get_property(const Image *img, const char *property)
 {
+#if defined(IMAGEMAGICK_7)
+    const char *result;
+    ExceptionInfo *exception;
+
+    exception = AcquireExceptionInfo();
+    result = GetImageProperty(img, property, exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+    return result;
+#else
     return GetImageProperty(img, property);
+#endif
 }
 
 
@@ -932,14 +949,25 @@ rm_get_property(const Image *img, const char *property)
  * No Ruby usage (internal function)
  *
  * @param image the image
- * @param property the property name 
+ * @param property the property name
  * @param value the property value
  * @return true if successful, otherwise false
  */
 MagickBooleanType
 rm_set_property(Image *image, const char *property, const char *value)
 {
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+    MagickBooleanType okay;
+
+    exception = AcquireExceptionInfo();
+    okay = SetImageProperty(image, property, value, exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+    return okay;
+#else
     return SetImageProperty(image, property, value);
+#endif
 }
 
 
@@ -954,16 +982,17 @@ rm_set_property(Image *image, const char *property, const char *value)
  */
 void rm_set_user_artifact(Image *images, Info *info)
 {
-    Image *image;
     const char *value;
 
     value = GetImageOption(info, "user");
     if (value)
     {
+        Image *image;
+
         image = GetFirstImageInList(images);
         while (image)
         {
-            (void) SetImageArtifact(image, "user", value);
+            SetImageArtifact(image, "user", value);
             image = GetNextImageInList(image);
         }
     }
@@ -995,7 +1024,16 @@ rm_get_optional_arguments(VALUE img)
         optional_method_arguments = rb_const_get_from(Module_Magick, rb_intern("OptionalMethodArguments"));
         argv[0] = img;
         opt_args = rb_class_new_instance(1, argv, optional_method_arguments);
-        (void) rb_obj_instance_eval(0, NULL, opt_args);
+
+        if (rb_proc_arity(rb_block_proc()) == 0)
+        {
+            rb_warn("passing a block without an image argument is deprecated");
+            rb_obj_instance_eval(0, NULL, opt_args);
+        }
+        else
+        {
+            rb_yield(opt_args);
+        }
     }
 
     RB_GC_GUARD(optional_method_arguments);
@@ -1016,17 +1054,18 @@ rm_get_optional_arguments(VALUE img)
 static void copy_options(Image *image, Info *info)
 {
     char property[MaxTextExtent];
-    const char *value, *option;
+    const char *option;
 
     ResetImageOptionIterator(info);
     for (option = GetNextImageOption(info); option; option = GetNextImageOption(info))
     {
-        value = GetImageOption(info,option);
+        const char *value;
+
+        value = GetImageOption(info, option);
         if (value)
         {
-            strncpy(property, value, MaxTextExtent);
-            property[MaxTextExtent-1] = '\0';
-            (void) SetImageArtifact(image, property, value);
+            strlcpy(property, value, sizeof(property));
+            SetImageArtifact(image, property, value);
         }
     }
 }
@@ -1046,16 +1085,19 @@ void rm_sync_image_options(Image *image, Info *info)
     MagickStatusType flags;
     GeometryInfo geometry_info;
     const char *option;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+#endif
 
     // The option strings will be set only when their attribute values were
     // set in the optional argument block.
-    option = GetImageOption(info,"background");
+    option = GetImageOption(info, "background");
     if (option)
     {
         image->background_color = info->background_color;
     }
 
-    option = GetImageOption(info,"bordercolor");
+    option = GetImageOption(info, "bordercolor");
     if (option)
     {
         image->border_color = info->border_color;
@@ -1063,7 +1105,16 @@ void rm_sync_image_options(Image *image, Info *info)
 
     if (info->colorspace != UndefinedColorspace)
     {
+#if defined(IMAGEMAGICK_7)
+        exception = AcquireExceptionInfo();
+        SetImageColorspace(image, info->colorspace, exception);
+        // We should not throw an exception in this method because we will
+        // leak memory in the place where this method is called. And that is
+        // why the exception is being ignored here.
+        DestroyExceptionInfo(exception);
+#else
         SetImageColorspace(image, info->colorspace);
+#endif
     }
 
     if (info->compression != UndefinedCompression)
@@ -1080,11 +1131,20 @@ void rm_sync_image_options(Image *image, Info *info)
     if (info->density)
     {
         flags = ParseGeometry(info->density, &geometry_info);
+#if defined(IMAGEMAGICK_7)
+        image->resolution.x = geometry_info.rho;
+        image->resolution.y = geometry_info.sigma;
+#else
         image->x_resolution = geometry_info.rho;
         image->y_resolution = geometry_info.sigma;
+#endif
         if ((flags & SigmaValue) == 0)
         {
+#if defined(IMAGEMAGICK_7)
+            image->resolution.y = image->resolution.x;
+#else
             image->y_resolution = image->x_resolution;
+#endif
         }
     }
 
@@ -1120,7 +1180,7 @@ void rm_sync_image_options(Image *image, Info *info)
         image->interlace = info->interlace;
     }
 
-    option = GetImageOption(info,"mattecolor");
+    option = GetImageOption(info, "mattecolor");
     if (option)
     {
         image->matte_color = info->matte_color;
@@ -1133,7 +1193,7 @@ void rm_sync_image_options(Image *image, Info *info)
 
     if (info->page)
     {
-        (void)ParseAbsoluteGeometry(info->page, &image->page);
+        ParseAbsoluteGeometry(info->page, &image->page);
     }
 
     if (info->quality != 0UL)
@@ -1150,7 +1210,7 @@ void rm_sync_image_options(Image *image, Info *info)
     option = GetImageOption(info, "tile-offset");
     if (option)
     {
-        (void)ParseAbsoluteGeometry(option, &image->tile_offset);
+        ParseAbsoluteGeometry(option, &image->tile_offset);
     }
 
     option = GetImageOption(info, "transparent");
@@ -1174,8 +1234,13 @@ void rm_sync_image_options(Image *image, Info *info)
               {
                 if (info->units == PixelsPerCentimeterResolution)
                 {
+#if defined(IMAGEMAGICK_7)
+                    image->resolution.x /= 2.54;
+                    image->resolution.y /= 2.54;
+#else
                     image->x_resolution /= 2.54;
                     image->y_resolution /= 2.54;
+#endif
                 }
                 break;
               }
@@ -1183,8 +1248,13 @@ void rm_sync_image_options(Image *image, Info *info)
               {
                 if (info->units == PixelsPerInchResolution)
                 {
+#if defined(IMAGEMAGICK_7)
+                    image->resolution.x *= 2.54;
+                    image->resolution.y *= 2.54;
+#else
                     image->x_resolution *= 2.54;
                     image->y_resolution *= 2.54;
+#endif
                 }
                 break;
               }
@@ -1219,8 +1289,16 @@ rm_exif_by_entry(Image *image)
     char *str;
     size_t len = 0, property_l, value_l;
     VALUE v;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+
+    exception = AcquireExceptionInfo();
+    GetImageProperty(image, "exif:*", exception);
+    CHECK_EXCEPTION();
+#else
+    GetImageProperty(image, "exif:*");
+#endif
 
-    (void) GetImageProperty(image, "exif:*");
     ResetImagePropertyIterator(image);
     property = GetNextImageProperty(image);
 
@@ -1228,7 +1306,7 @@ rm_exif_by_entry(Image *image)
     while (property)
     {
         // ignore properties that don't start with "exif:"
-        property_l = strlen(property);
+        property_l = rm_strnlen_s(property, MaxTextExtent);
         if (property_l > 5 && rm_strncasecmp(property, "exif:", 5) == 0)
         {
             if (len > 0)
@@ -1236,11 +1314,16 @@ rm_exif_by_entry(Image *image)
                 len += 1;   // there will be a \n between property=value entries
             }
             len += property_l - 5;
-            value = GetImageProperty(image,property);
+#if defined(IMAGEMAGICK_7)
+            value = GetImageProperty(image, property, exception);
+            CHECK_EXCEPTION();
+#else
+            value = GetImageProperty(image, property);
+#endif
             if (value)
             {
                 // add 1 for the = between property and value
-                len += 1 + strlen(value);
+                len += 1 + rm_strnlen_s(value, MaxTextExtent);
             }
         }
         property = GetNextImageProperty(image);
@@ -1248,8 +1331,12 @@ rm_exif_by_entry(Image *image)
 
     if (len == 0)
     {
+#if defined(IMAGEMAGICK_7)
+        DestroyExceptionInfo(exception);
+#endif
         return Qnil;
     }
+
     str = xmalloc(len);
     len = 0;
 
@@ -1259,7 +1346,7 @@ rm_exif_by_entry(Image *image)
 
     while (property)
     {
-        property_l = strlen(property);
+        property_l = rm_strnlen_s(property, MaxTextExtent);
         if (property_l > 5 && rm_strncasecmp(property, "exif:", 5) == 0)
         {
             if (len > 0)
@@ -1268,10 +1355,19 @@ rm_exif_by_entry(Image *image)
             }
             memcpy(str+len, property+5, property_l-5);
             len += property_l - 5;
-            value = GetImageProperty(image,property);
+#if defined(IMAGEMAGICK_7)
+            value = GetImageProperty(image, property, exception);
+            if (rm_should_raise_exception(exception, RetainExceptionRetention))
+            {
+                xfree(str);
+                rm_raise_exception(exception);
+            }
+#else
+            value = GetImageProperty(image, property);
+#endif
             if (value)
             {
-                value_l = strlen(value);
+                value_l = rm_strnlen_s(value, MaxTextExtent);
                 str[len++] = '=';
                 memcpy(str+len, value, value_l);
                 len += value_l;
@@ -1280,6 +1376,10 @@ rm_exif_by_entry(Image *image)
         property = GetNextImageProperty(image);
     }
 
+#if defined(IMAGEMAGICK_7)
+    DestroyExceptionInfo(exception);
+#endif
+
     v = rb_str_new(str, len);
     xfree(str);
 
@@ -1308,8 +1408,15 @@ rm_exif_by_number(Image *image)
     char *str;
     size_t len = 0, property_l, value_l;
     VALUE v;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
 
-    (void) GetImageProperty(image, "exif:!");
+    exception = AcquireExceptionInfo();
+    GetImageProperty(image, "exif:!", exception);
+    CHECK_EXCEPTION();
+#else
+    GetImageProperty(image, "exif:!");
+#endif
     ResetImagePropertyIterator(image);
     property = GetNextImageProperty(image);
 
@@ -1317,7 +1424,7 @@ rm_exif_by_number(Image *image)
     while (property)
     {
         // ignore properties that don't start with "#"
-        property_l = strlen(property);
+        property_l = rm_strnlen_s(property, MaxTextExtent);
         if (property_l > 1 && property[0] == '#')
         {
             if (len > 0)
@@ -1325,11 +1432,16 @@ rm_exif_by_number(Image *image)
                 len += 1;   // there will be a \n between property=value entries
             }
             len += property_l;
-            value = GetImageProperty(image,property);
+#if defined(IMAGEMAGICK_7)
+            value = GetImageProperty(image, property, exception);
+            CHECK_EXCEPTION();
+#else
+            value = GetImageProperty(image, property);
+#endif
             if (value)
             {
                 // add 1 for the = between property and value
-                len += 1 + strlen(value);
+                len += 1 + rm_strnlen_s(value, MaxTextExtent);
             }
         }
         property = GetNextImageProperty(image);
@@ -1337,8 +1449,12 @@ rm_exif_by_number(Image *image)
 
     if (len == 0)
     {
+#if defined(IMAGEMAGICK_7)
+        DestroyExceptionInfo(exception);
+#endif
         return Qnil;
     }
+
     str = xmalloc(len);
     len = 0;
 
@@ -1348,7 +1464,7 @@ rm_exif_by_number(Image *image)
 
     while (property)
     {
-        property_l = strlen(property);
+        property_l = rm_strnlen_s(property, MaxTextExtent);
         if (property_l > 1 && property[0] == '#')
         {
             if (len > 0)
@@ -1357,10 +1473,19 @@ rm_exif_by_number(Image *image)
             }
             memcpy(str+len, property, property_l);
             len += property_l;
-            value = GetImageProperty(image,property);
+#if defined(IMAGEMAGICK_7)
+            value = GetImageProperty(image, property, exception);
+            if (rm_should_raise_exception(exception, RetainExceptionRetention))
+            {
+                xfree(str);
+                rm_raise_exception(exception);
+            }
+#else
+            value = GetImageProperty(image, property);
+#endif
             if (value)
             {
-                value_l = strlen(value);
+                value_l = rm_strnlen_s(value, MaxTextExtent);
                 str[len++] = '=';
                 memcpy(str+len, value, value_l);
                 len += value_l;
@@ -1369,6 +1494,10 @@ rm_exif_by_number(Image *image)
         property = GetNextImageProperty(image);
     }
 
+#if defined(IMAGEMAGICK_7)
+    DestroyExceptionInfo(exception);
+#endif
+
     v = rb_str_new(str, len);
     xfree(str);
 
@@ -1378,66 +1507,6 @@ rm_exif_by_number(Image *image)
 }
 
 
-/**
- * Get the values from a Geometry object and return them in C variables.
- *
- * No Ruby usage (internal function)
- *
- * Notes:
- *   - No return value: modifies x, y, width, height, and flag
- *
- * @param geom the Geometry object
- * @param x pointer to the x position of the start of the rectangle
- * @param y pointer to the y position of the start of the rectangle
- * @param width pointer to the width of the rectangle
- * @param height pointer to the height of the rectangle
- * @param flag pointer to the Geometry's flag
- */
-void
-rm_get_geometry(
-    VALUE geom,
-    long *x,
-    long *y,
-    unsigned long *width,
-    unsigned long *height,
-    int *flag)
-{
-    VALUE v;
-
-    v = rb_funcall(geom, rm_ID_x, 0);
-    *x = NUM2LONG(v);
-    v = rb_funcall(geom, rm_ID_y, 0);
-    *y = NUM2LONG(v);
-    v = rb_funcall(geom, rm_ID_width, 0);
-    *width = NUM2ULONG(v);
-    v = rb_funcall(geom, rm_ID_height, 0);
-    *height = NUM2ULONG(v);
-
-    // Getting the flag field is a bit more difficult since it's
-    // supposed to be an instance of the GeometryValue Enum class. We
-    // may not know the VALUE for the GeometryValue class, and we
-    // need to check that the flag field is an instance of that class.
-    if (flag)
-    {
-        MagickEnum *magick_enum;
-
-        v = rb_funcall(geom, rm_ID_flag, 0);
-        if (!Class_GeometryValue)
-        {
-            Class_GeometryValue = rb_const_get(Module_Magick, rm_ID_GeometryValue);
-        }
-        if (CLASS_OF(v) != Class_GeometryValue)
-        {
-            rb_raise(rb_eTypeError, "wrong enumeration type - expected %s, got %s"
-                        , rb_class2name(Class_GeometryValue),rb_class2name(CLASS_OF(v)));
-        }
-        Data_Get_Struct(v, MagickEnum, magick_enum);
-        *flag = magick_enum->val;
-    }
-
-}
-
-
 /**
  * Clone an image, handle errors.
  *
@@ -1463,7 +1532,7 @@ rm_clone_image(Image *image)
         rb_raise(rb_eNoMemError, "not enough memory to continue");
     }
     rm_check_exception(exception, clone, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 
     return clone;
 }
@@ -1494,14 +1563,15 @@ rm_progress_monitor(
     VALUE rval;
     VALUE method, offset, span;
 
-// Default Ruby minimum stack size
-#define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN (  16 * 1024 * sizeof(VALUE)) /*   64 KB or  128 KB */
-
-    // Check stack length manually instead of ruby_stack_check() for old Ruby.
-    if (ruby_stack_length(NULL) > RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN)
+    // Check running thread.
+    if (rm_current_thread_id() != rm_main_thread_id)
     {
-        // If there is not enough stack or the using stack size shows an abnormal value in Ruby,
-        // skip the callback and continue ImageMagick process.
+        // ImageMagick might call back in a different thread than Ruby is running in.
+        // If it is a different thread, it would not have a Ruby GVL and
+        // it could not retrieve properly Ruby stack.
+
+        // Unfortunately, there is no API available to check if the current thread has a GVL,
+        // so the thread id was checked in here.
         return MagickTrue;
     }
 
@@ -1546,11 +1616,12 @@ rm_split(Image *image)
     }
     while (image)
     {
-        (void) RemoveFirstImageFromList(&image);
+        RemoveFirstImageFromList(&image);
     }
 }
 
 
+#if defined(IMAGEMAGICK_6)
 /**
  * If an ExceptionInfo struct in a list of images indicates a warning, issue a
  * warning message. If an ExceptionInfo struct indicates an error, raise an
@@ -1598,8 +1669,9 @@ rm_check_image_exception(Image *imglist, ErrorRetention retention)
         rm_check_exception(exception, imglist, retention);
     }
 
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 }
+#endif
 
 
 #define ERROR_MSG_SIZE 1024
@@ -1617,7 +1689,7 @@ static void
 format_exception(const ExceptionType severity, const char *reason, const char *description, char *msg)
 {
     int len;
-    memset(msg, 0, sizeof(ERROR_MSG_SIZE));
+    memset(msg, 0, ERROR_MSG_SIZE);
 
     len = snprintf(msg, ERROR_MSG_SIZE, "%s%s%s",
         GetLocaleExceptionMessage(severity, reason),
@@ -1746,7 +1818,7 @@ handle_exception(ExceptionInfo *exception, Image *imglist, ErrorRetention retent
     {
         if (retention == DestroyOnError)
         {
-            (void) DestroyImageList(imglist);
+            DestroyImageList(imglist);
             imglist = NULL;
         }
         else
@@ -1757,7 +1829,7 @@ handle_exception(ExceptionInfo *exception, Image *imglist, ErrorRetention retent
 
     format_exception(exception->severity, exception->reason, exception->description, msg);
 
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 
     rm_magick_error(msg);
 }
@@ -1801,7 +1873,7 @@ rm_should_raise_exception(ExceptionInfo *exception, const ExceptionRetention ret
 
         if (retention == DestroyExceptionRetention)
         {
-            (void) DestroyExceptionInfo(exception);
+            DestroyExceptionInfo(exception);
         }
 
         return MagickFalse;
@@ -1825,8 +1897,24 @@ rm_raise_exception(ExceptionInfo *exception)
 
     format_exception(exception->severity, exception->reason, exception->description, msg);
 
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 
     rm_magick_error(msg);
 }
 
+/**
+ * Get current thread id.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @return thread id
+ */
+unsigned long long
+rm_current_thread_id()
+{
+#if defined(_WIN32)
+    return (unsigned long long)GetCurrentThreadId();
+#else
+    return (unsigned long long)pthread_self();
+#endif
+}