rmagick 2.13.2 → 4.2.2

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.
  *
@@ -228,6 +234,27 @@ rm_check_ary_len(VALUE ary, long len)
 }
 
 
+/**
+ * Raise exception if ary argument was invalid type
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param ary the array
+ * @return the array that is converted type of argument object if needed
+ * @throw TypeError
+ */
+VALUE
+rm_check_ary_type(VALUE ary)
+{
+    VALUE checked = rb_check_array_type(ary);
+    if (NIL_P(checked))
+    {
+        rb_raise(rb_eTypeError, "wrong argument type %"RMIsVALUE" was given. (must respond to :to_ary)", rb_obj_class(ary));
+    }
+    return checked;
+}
+
+
 /**
  * Raise an error if the image has been destroyed.
  *
@@ -274,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;
 }
 
 
@@ -327,24 +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)
-{
-    double d;
-    d = NUM2DBL(arg);
-    d = d;      // satisfy icc
-    return arg;
-}
-
-
 /**
  * Called when `rb_str_to_str' raises an exception.
  *
@@ -355,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;
 }
 
 
@@ -378,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)
@@ -437,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);
 }
 
@@ -451,9 +434,8 @@ check_num2dbl(VALUE obj)
  * @return 0
  */
 static VALUE
-rescue_not_dbl(VALUE ignored)
+rescue_not_dbl(VALUE ignored ATTRIBUTE_UNUSED, VALUE raised_exc ATTRIBUTE_UNUSED)
 {
-    ignored = ignored;      // defeat gcc message
     return INT2FIX(0);
 }
 
@@ -488,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);
 
@@ -524,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)
@@ -585,17 +565,43 @@ rm_fuzz_to_dbl(VALUE fuzz_arg)
 Quantum
 rm_app2quantum(VALUE obj)
 {
-    volatile VALUE v = obj;
+    VALUE v = obj;
 
     if (TYPE(obj) == T_FLOAT)
     {
-        v = rb_funcall(obj, rm_ID_to_i, 0);
+        v = rb_Integer(obj);
     }
 
     return NUM2QUANTUM(v);
 }
 
 
+/**
+ * Returns a pointer to an image structure initialized to default values
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param info the info
+ * @return the created image
+ */
+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
+}
+
+
 /**
  * Send the "cur_image" method to the object. If 'img' is an ImageList, then
  * cur_image is self[\@scene]. If 'img' is an image, then cur_image is simply
@@ -619,21 +625,28 @@ rm_cur_image(VALUE img)
  * No Ruby usage (internal function)
  *
  * @param image the image
- * @param color the color intensity as a PixelPacket
+ * @param color the color intensity as a PixelColor
  * @return the named color as a String
- * @see rm_pixelpacket_to_color_name_info
+ * @see rm_pixelcolor_to_color_name_info
  */
 VALUE
-rm_pixelpacket_to_color_name(Image *image, PixelPacket *color)
+rm_pixelcolor_to_color_name(Image *image, PixelColor *color)
 {
+    PixelColor pp;
     char name[MaxTextExtent];
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
-    GetExceptionInfo(&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);
 }
@@ -647,36 +660,80 @@ rm_pixelpacket_to_color_name(Image *image, PixelPacket *color)
  * Notes:
  *   - Simply create an Image from the Info, call QueryColorname, and then
  *     destroy the Image.
- *   - If the Info structure is NULL, creates a new one.
  *   - The default depth is always used, and the matte value is set to False,
  *     which means "don't use the alpha channel".
  *
  * @param info the info
- * @param color the color intensity as a PixelPacket
+ * @param color the color intensity as a PixelColor
  * @return the named color as a String
- * @see rm_pixelpacket_to_color_name
+ * @see rm_pixelcolor_to_color_name
  */
 VALUE
-rm_pixelpacket_to_color_name_info(Info *info, PixelPacket *color)
+rm_pixelcolor_to_color_name_info(Info *info, PixelColor *color)
 {
     Image *image;
-    Info *my_info;
-    volatile VALUE color_name;
-
-    my_info = info ? info : CloneImageInfo(NULL);
+    VALUE color_name;
 
-    image = AcquireImage(info);
-    image->matte = MagickFalse;
-    color_name = rm_pixelpacket_to_color_name(image, color);
-    (void) DestroyImage(image);
-    if (!info)
+    image = rm_acquire_image(info);
+    if (!image)
     {
-        (void) DestroyImageInfo(my_info);
+        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);
+    DestroyImage(image);
+
     return color_name;
 }
 
+/**
+ * Initializes the MagickPixel structure.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param image the image
+ * @param pp the MagickPixel
+ */
+void
+rm_init_magickpixel(const Image *image, MagickPixel *pp)
+{
+#if defined(IMAGEMAGICK_7)
+    GetPixelInfo(image, pp);
+#else
+    GetMagickPixelPacket(image, pp);
+#endif
+}
+
+/**
+ * Initializes the MagickPixel structure to the specified color.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param pp the MagickPixel
+ * @param color the color
+ */
+void
+rm_set_magickpixel(MagickPixel *pp, const char *color)
+{
+    ExceptionInfo *exception;
+
+    exception = AcquireExceptionInfo();
+
+#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.
+    DestroyExceptionInfo(exception);
+}
 
 /**
  * Write a temporary copy of the image to the IM registry.
@@ -689,20 +746,21 @@ rm_pixelpacket_to_color_name_info(Info *info, PixelPacket *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_"
 
     MagickBooleanType okay;
-    ExceptionInfo exception;
-    volatile VALUE id_value;
+    ExceptionInfo *exception;
+    VALUE id_value;
     int id;
 
-    GetExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
 
 
     // 'id' is always the value of its previous use
@@ -719,17 +777,18 @@ 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()
-    DestroyExceptionInfo(&exception);
+    okay = SetImageRegistry(ImageRegistryType, temp_name+5, image, exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
     if (!okay)
     {
         rb_raise(rb_eRuntimeError, "SetImageRegistry failed.");
     }
 
+    RB_GC_GUARD(id_value);
 }
 
 
@@ -768,7 +827,7 @@ rm_not_implemented(void)
 {
 
     rb_raise(rb_eNotImpError, "the `%s' method is not supported by ImageMagick "
-            MagickLibVersionText, rb_id2name(THIS_FUNC()));
+            MagickLibVersionText, rb_id2name(rb_frame_this_func()));
 }
 
 
@@ -782,45 +841,39 @@ rm_not_implemented(void)
  *     the ImageMagickError object in both 1.6.8 and 1.8.0.
  *
  * @param msg the error mesage
- * @param loc the location of the error
  * @throw ImageMagickError
  * @see www.ruby_talk.org/36408.
  */
 void
-rm_magick_error(const char *msg, const char *loc)
+rm_magick_error(const char *msg)
 {
-    volatile VALUE exc, mesg, extra;
+    VALUE exc, mesg;
 
     mesg = rb_str_new2(msg);
-    extra = loc ? rb_str_new2(loc) : Qnil;
 
-    exc = rb_funcall(Class_ImageMagickError, rm_ID_new, 2, mesg, extra);
-    (void) rb_funcall(rb_cObject, rb_intern("raise"), 1, exc);
+    exc = rb_funcall(Class_ImageMagickError, rm_ID_new, 2, mesg, Qnil);
+    rb_funcall(rb_cObject, rb_intern("raise"), 1, exc);
+
+    RB_GC_GUARD(exc);
+    RB_GC_GUARD(mesg);
 }
 
 
 /**
  * Initialize a new ImageMagickError object - store the "loc" string in the
- * \@magick_location instance variable.
- *
- * Ruby usage:
- *   - @verbatim ImageMagickError#initialize(msg) @endverbatim
- *   - @verbatim ImageMagickError#initialize(msg, loc) @endverbatim
+ * magick_location instance variable.
  *
- * Notes:
- *   - Default loc is nil
- *
- * @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)
 {
     VALUE super_argv[1] = {(VALUE)0};
     int super_argc = 0;
-    volatile VALUE extra = Qnil;
+    VALUE extra = Qnil;
 
     switch(argc)
     {
@@ -835,9 +888,10 @@ 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);
 
     return self;
 }
@@ -855,7 +909,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
 }
 
 
@@ -865,14 +930,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
 }
 
 
@@ -887,24 +963,20 @@ rm_set_property(Image *image, const char *property, const char *value)
  */
 void rm_set_user_artifact(Image *images, Info *info)
 {
-#if defined(HAVE_SETIMAGEARTIFACT)
-    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);
         }
     }
-#else
-    images = images;
-    info = info;
-#endif
 }
 
 
@@ -922,25 +994,35 @@ void rm_set_user_artifact(Image *images, Info *info)
 void
 rm_get_optional_arguments(VALUE img)
 {
-  volatile VALUE OptionalMethodArguments;
-  volatile VALUE opt_args;
-  VALUE argv[1];
-
-  // opt_args = Magick::OptionalMethodArguments.new(img)
-  // opt_args.instance_eval { block }
-  if (rb_block_given_p())
-  {
-      OptionalMethodArguments = rb_const_get_from(Module_Magick, rb_intern("OptionalMethodArguments"));
-      argv[0] = img;
-      opt_args = rb_class_new_instance(1, argv, OptionalMethodArguments);
-      (void) rb_obj_instance_eval(0, NULL, opt_args);
-  }
-
-  return;
+    VALUE optional_method_arguments;
+    VALUE opt_args;
+    VALUE argv[1];
+
+    // opt_args = Magick::OptionalMethodArguments.new(img)
+    // opt_args.instance_eval { block }
+    if (rb_block_given_p())
+    {
+        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);
+
+        if (rb_proc_arity(rb_block_proc()) == 0)
+        {
+            rb_obj_instance_eval(0, NULL, opt_args);
+        }
+        else
+        {
+            rb_yield(opt_args);
+        }
+    }
+
+    RB_GC_GUARD(optional_method_arguments);
+    RB_GC_GUARD(opt_args);
+
+    return;
 }
 
 
-#if defined(HAVE_SETIMAGEARTIFACT)
 /**
  * Copy image options from the Info structure to the Image structure.
  *
@@ -952,21 +1034,21 @@ 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);
         }
     }
 }
-#endif
 
 
 /**
@@ -983,16 +1065,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;
@@ -1000,7 +1085,16 @@ void rm_sync_image_options(Image *image, Info *info)
 
     if (info->colorspace != UndefinedColorspace)
     {
-        image->colorspace = info->colorspace;
+#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)
@@ -1017,11 +1111,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
         }
     }
 
@@ -1057,7 +1160,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;
@@ -1070,7 +1173,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)
@@ -1087,7 +1190,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");
@@ -1096,12 +1199,10 @@ void rm_sync_image_options(Image *image, Info *info)
         image->transparent_color = info->transparent_color;
     }
 
-#if defined(HAVE_ST_TYPE)
     if (info->type != UndefinedType)
     {
         image->type = info->type;
     }
-#endif
 
     if (info->units != UndefinedResolution)
     {
@@ -1113,8 +1214,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;
               }
@@ -1122,8 +1228,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;
               }
@@ -1135,9 +1246,7 @@ void rm_sync_image_options(Image *image, Info *info)
         image->units = info->units;
     }
 
-#if defined(HAVE_SETIMAGEARTIFACT)
     copy_options(image, info);
-#endif
 }
 
 
@@ -1159,9 +1268,17 @@ rm_exif_by_entry(Image *image)
     const char *property, *value;
     char *str;
     size_t len = 0, property_l, value_l;
-    volatile VALUE v;
+    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);
 
@@ -1169,7 +1286,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)
@@ -1177,11 +1294,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);
@@ -1189,8 +1311,12 @@ rm_exif_by_entry(Image *image)
 
     if (len == 0)
     {
+#if defined(IMAGEMAGICK_7)
+        DestroyExceptionInfo(exception);
+#endif
         return Qnil;
     }
+
     str = xmalloc(len);
     len = 0;
 
@@ -1200,7 +1326,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)
@@ -1209,10 +1335,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;
@@ -1221,8 +1356,15 @@ rm_exif_by_entry(Image *image)
         property = GetNextImageProperty(image);
     }
 
+#if defined(IMAGEMAGICK_7)
+    DestroyExceptionInfo(exception);
+#endif
+
     v = rb_str_new(str, len);
     xfree(str);
+
+    RB_GC_GUARD(v);
+
     return v;
 }
 
@@ -1245,9 +1387,16 @@ rm_exif_by_number(Image *image)
     const char *property, *value;
     char *str;
     size_t len = 0, property_l, value_l;
-    volatile VALUE v;
+    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);
 
@@ -1255,7 +1404,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)
@@ -1263,11 +1412,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);
@@ -1275,8 +1429,12 @@ rm_exif_by_number(Image *image)
 
     if (len == 0)
     {
+#if defined(IMAGEMAGICK_7)
+        DestroyExceptionInfo(exception);
+#endif
         return Qnil;
     }
+
     str = xmalloc(len);
     len = 0;
 
@@ -1286,7 +1444,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)
@@ -1295,10 +1453,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;
@@ -1307,69 +1474,16 @@ rm_exif_by_number(Image *image)
         property = GetNextImageProperty(image);
     }
 
+#if defined(IMAGEMAGICK_7)
+    DestroyExceptionInfo(exception);
+#endif
+
     v = rb_str_new(str, len);
     xfree(str);
-    return v;
-}
-
 
-/**
- * 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;
-    }
+    RB_GC_GUARD(v);
 
+    return v;
 }
 
 
@@ -1389,16 +1503,16 @@ Image *
 rm_clone_image(Image *image)
 {
     Image *clone;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
-    GetExceptionInfo(&exception);
-    clone = CloneImage(image, 0, 0, MagickTrue, &exception);
+    exception = AcquireExceptionInfo();
+    clone = CloneImage(image, 0, 0, MagickTrue, exception);
     if (!clone)
     {
         rb_raise(rb_eNoMemError, "not enough memory to continue");
     }
-    rm_check_exception(&exception, clone, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
+    rm_check_exception(exception, clone, DestroyOnError);
+    DestroyExceptionInfo(exception);
 
     return clone;
 }
@@ -1421,15 +1535,25 @@ rm_clone_image(Image *image)
  */
 MagickBooleanType
 rm_progress_monitor(
-    const char *tag,
+    const char *tag ATTRIBUTE_UNUSED,
     const MagickOffsetType of,
     const MagickSizeType sp,
     void *client_data)
 {
-    volatile VALUE rval;
-    volatile VALUE method, offset, span;
+    VALUE rval;
+    VALUE method, offset, span;
 
-    tag = tag;      // defeat gcc message
+    // Check running thread.
+    if (rm_current_thread_id() != rm_main_thread_id)
+    {
+        // 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;
+    }
 
 #if defined(HAVE_LONG_LONG)     // defined in Ruby's defines.h
     offset = rb_ll2inum(of);
@@ -1439,10 +1563,15 @@ rm_progress_monitor(
     span = rb_uint2big((unsigned long)sp);
 #endif
 
-    method = rb_str_new2(rb_id2name(THIS_FUNC()));
+    method = rb_id2str(rb_frame_this_func());
 
     rval = rb_funcall((VALUE)client_data, rm_ID_call, 3, method, offset, span);
 
+    RB_GC_GUARD(rval);
+    RB_GC_GUARD(method);
+    RB_GC_GUARD(offset);
+    RB_GC_GUARD(span);
+
     return RTEST(rval) ? MagickTrue : MagickFalse;
 }
 
@@ -1467,11 +1596,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
@@ -1486,7 +1616,7 @@ rm_split(Image *image)
 void
 rm_check_image_exception(Image *imglist, ErrorRetention retention)
 {
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
     Image *badboy = NULL;
     Image *image;
 
@@ -1495,7 +1625,7 @@ rm_check_image_exception(Image *imglist, ErrorRetention retention)
         return;
     }
 
-    GetExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
 
     // Find the image with the highest severity
     image = GetFirstImageInList(imglist);
@@ -1506,7 +1636,7 @@ rm_check_image_exception(Image *imglist, ErrorRetention retention)
             if (!badboy || image->exception.severity > badboy->exception.severity)
             {
                 badboy = image;
-                InheritException(&exception, &badboy->exception);
+                InheritException(exception, &badboy->exception);
             }
 
             ClearMagickException(&image->exception);
@@ -1516,10 +1646,37 @@ rm_check_image_exception(Image *imglist, ErrorRetention retention)
 
     if (badboy)
     {
-        rm_check_exception(&exception, imglist, retention);
+        rm_check_exception(exception, imglist, retention);
     }
 
-    (void) DestroyExceptionInfo(&exception);
+    DestroyExceptionInfo(exception);
+}
+#endif
+
+
+#define ERROR_MSG_SIZE 1024
+/**
+ * Formats the exception into the message buffer
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param severity information about the severity of the error
+ * @param reason the reason for the error
+ * @param description description of the error
+ * @param msg the buffer where the exception message should be formated in
+ */
+static void
+format_exception(const ExceptionType severity, const char *reason, const char *description, char *msg)
+{
+    int len;
+    memset(msg, 0, ERROR_MSG_SIZE);
+
+    len = snprintf(msg, ERROR_MSG_SIZE, "%s%s%s",
+        GetLocaleExceptionMessage(severity, reason),
+        description ? ": " : "",
+        description ? GetLocaleExceptionMessage(severity, description) : "");
+
+    msg[len] = '\0';
 }
 
 
@@ -1558,11 +1715,10 @@ rm_check_exception(ExceptionInfo *exception, Image *imglist, ErrorRetention rete
 void
 rm_warning_handler(const ExceptionType severity, const char *reason, const char *description)
 {
-    ExceptionType dummy;
-
-    rb_warning("RMagick: %s: `%s'", reason, description);
-    dummy = severity;
-    dummy = dummy;
+    rb_warning("RMagick: %s%s%s",
+        GetLocaleExceptionMessage(severity, reason),
+        description ? ": " : "",
+        description ? GetLocaleExceptionMessage(severity, description) : "");
 }
 
 
@@ -1571,28 +1727,18 @@ rm_warning_handler(const ExceptionType severity, const char *reason, const char
  *
  * No Ruby usage (internal function)
  *
- * @param severity information about the severity of the error (ignored)
+ * @param severity information about the severity of the error
  * @param reason the reason for the error
  * @param description description of the error
  */
 void
 rm_error_handler(const ExceptionType severity, const char *reason, const char *description)
 {
-    char msg[500];
-    int len;
-    ExceptionType dummy;
+    char msg[ERROR_MSG_SIZE];
 
-    memset(msg, 0, sizeof(msg));
-#if defined(HAVE_SNPRINTF)
-    len = snprintf(msg, sizeof(msg), "%s: `%s'", reason, description);
-#else
-    len = sprintf(msg, "%.250s: `%.240s'", reason, description);
-#endif
-    msg[len] = '\0';
+    format_exception(severity, reason, description, msg);
 
-    rm_magick_error(msg, NULL);
-    dummy = severity;
-    dummy = dummy;
+    rm_magick_error(msg);
 }
 
 
@@ -1603,14 +1749,16 @@ rm_error_handler(const ExceptionType severity, const char *reason, const char *d
  *
  * @param severity information about the severity of the error
  * @param reason the reason for the error
- * @param description description of the error (ignored)
+ * @param description description of the error
  * @throw FatalImageMagickError
  */
 void
 rm_fatal_error_handler(const ExceptionType severity, const char *reason, const char *description)
 {
-    rb_raise(Class_FatalImageMagickError, GetLocaleExceptionMessage(severity, reason));
-    description = description;
+    rb_raise(Class_FatalImageMagickError, "%s%s%s",
+        GetLocaleExceptionMessage(severity, reason),
+        description ? ": " : "",
+        description ? GetLocaleExceptionMessage(severity, description) : "");
 }
 
 
@@ -1629,27 +1777,12 @@ rm_fatal_error_handler(const ExceptionType severity, const char *reason, const c
 static void
 handle_exception(ExceptionInfo *exception, Image *imglist, ErrorRetention retention)
 {
-
-    char reason[500];
-    char desc[500];
-    char msg[sizeof(reason)+sizeof(desc)+20];
-
-    memset(msg, 0, sizeof(msg));
-
+    char msg[ERROR_MSG_SIZE];
 
     // Handle simple warning
     if (exception->severity < ErrorException)
     {
-#if defined(HAVE_SNPRINTF)
-        snprintf(msg, sizeof(msg)-1, "RMagick: %s%s%s",
-#else
-        sprintf(msg, "RMagick: %.500s%s%.500s",
-#endif
-            GetLocaleExceptionMessage(exception->severity, exception->reason),
-            exception->description ? ": " : "",
-            exception->description ? GetLocaleExceptionMessage(exception->severity, exception->description) : "");
-        msg[sizeof(msg)-1] = '\0';
-        rb_warning(msg);
+        rm_warning_handler(exception->severity, exception->reason, exception->description);
 
         // Caller deletes ExceptionInfo...
 
@@ -1665,7 +1798,7 @@ handle_exception(ExceptionInfo *exception, Image *imglist, ErrorRetention retent
     {
         if (retention == DestroyOnError)
         {
-            (void) DestroyImageList(imglist);
+            DestroyImageList(imglist);
             imglist = NULL;
         }
         else
@@ -1674,40 +1807,11 @@ handle_exception(ExceptionInfo *exception, Image *imglist, ErrorRetention retent
         }
     }
 
+    format_exception(exception->severity, exception->reason, exception->description, msg);
 
-    // Clone the ExceptionInfo with all arguments on the stack.
-    memset(reason, 0, sizeof(reason));
-    memset(desc, 0, sizeof(desc));
-
-    if (exception->reason)
-    {
-        strncpy(reason, exception->reason, sizeof(reason)-1);
-        reason[sizeof(reason)-1] = '\0';
-    }
-    if (exception->description)
-    {
-        strncpy(desc, exception->description, sizeof(desc)-1);
-        desc[sizeof(desc)-1] = '\0';
-    }
-
-
-#if defined(HAVE_SNPRINTF)
-    snprintf(msg, sizeof(msg)-1, "%s%s%s",
-        GetLocaleExceptionMessage(exception->severity, reason),
-        desc[0] ? ": " : "",
-        desc[0] ? GetLocaleExceptionMessage(exception->severity, desc) : "");
-#else
-    sprintf(msg, "%.*s%s%.*s",
-        sizeof(reason)-1, GetLocaleExceptionMessage(exception->severity, reason),
-        desc[0] ? ": " : "",
-        sizeof(desc)-1, desc[0] ? GetLocaleExceptionMessage(exception->severity, desc) : "");
-#endif
-
-    msg[sizeof(msg)-1] = '\0';
-
-    (void) DestroyExceptionInfo(exception);
-    rm_magick_error(msg, NULL);
+    DestroyExceptionInfo(exception);
 
+    rm_magick_error(msg);
 }
 
 
@@ -1728,3 +1832,69 @@ rm_ensure_result(Image *image)
     }
 }
 
+
+/**
+ * Checks if an error should be raised for the exception.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param exception information about the exception
+ * @param retention retention strategy for the exception in case there was no error
+ */
+MagickBooleanType
+rm_should_raise_exception(ExceptionInfo *exception, const ExceptionRetention retention)
+{
+    if (exception->severity < ErrorException)
+    {
+        if (exception->severity != UndefinedException)
+        {
+            rm_warning_handler(exception->severity, exception->reason, exception->description);
+        }
+
+        if (retention == DestroyExceptionRetention)
+        {
+            DestroyExceptionInfo(exception);
+        }
+
+        return MagickFalse;
+    }
+
+    return MagickTrue;
+}
+
+
+/**
+ * Raises an exception.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param exception information about the exception
+ */
+void
+rm_raise_exception(ExceptionInfo *exception)
+{
+    char msg[ERROR_MSG_SIZE];
+
+    format_exception(exception->severity, exception->reason, exception->description, msg);
+
+    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
+}