rmagick 2.16.0 → 5.3.0

data/ext/RMagick/rmutil.c

@@ -12,10 +12,19 @@
 
 #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);
 
 
+DEFINE_GVL_STUB5(CloneImage, const Image *, const size_t, const size_t, const MagickBooleanType, ExceptionInfo *);
+
+
 /**
  * ImageMagick safe version of malloc.
  *
@@ -78,7 +87,7 @@ magick_malloc(const size_t size)
 void
 magick_free(void *ptr)
 {
-    (void) RelinquishMagickMemory(ptr);
+    RelinquishMagickMemory(ptr);
 }
 
 
@@ -112,28 +121,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 +136,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 +195,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 +237,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.
  *
@@ -242,7 +272,7 @@ rm_check_destroyed(VALUE obj)
 {
     Image *image;
 
-    Data_Get_Struct(obj, Image, image);
+    TypedData_Get_Struct(obj, Image, &rm_image_data_type, image);
     if (!image)
     {
         rb_raise(Class_DestroyedImageError, "destroyed image");
@@ -274,35 +304,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 +334,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 +344,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 +366,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 +423,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 +437,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 +473,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 +509,15 @@ double
 rm_fuzz_to_dbl(VALUE fuzz_arg)
 {
     double fuzz;
-    char *fuzz_str, *end;
-    int not_num;
+    char *end;
 
-    // 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);
-
-    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)
@@ -589,15 +572,39 @@ 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);
 }
 
 
+/**
+ * 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
@@ -621,21 +628,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;
 
     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);
 }
@@ -649,38 +663,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;
     VALUE color_name;
 
-    my_info = info ? info : CloneImageInfo(NULL);
-
-    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.");
     }
 
-    RB_GC_GUARD(color_name);
+#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.
@@ -693,10 +749,11 @@ 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_"
@@ -723,11 +780,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()
+    okay = (MagickBooleanType)SetImageRegistry(ImageRegistryType, temp_name+5, image, exception);
+    CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
     if (!okay)
     {
@@ -773,7 +830,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()));
 }
 
 
@@ -787,42 +844,51 @@ 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)
 {
-    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);
-    RB_GC_GUARD(extra);
 }
 
-
+#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)
@@ -844,8 +910,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);
 
@@ -865,7 +931,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
 }
 
 
@@ -875,14 +952,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
 }
 
 
@@ -897,24 +985,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
 }
 
 
@@ -943,7 +1027,8 @@ 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);
+
+        rb_yield(opt_args);
     }
 
     RB_GC_GUARD(optional_method_arguments);
@@ -953,7 +1038,6 @@ rm_get_optional_arguments(VALUE img)
 }
 
 
-#if defined(HAVE_SETIMAGEARTIFACT)
 /**
  * Copy image options from the Info structure to the Image structure.
  *
@@ -965,21 +1049,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
 
 
 /**
@@ -996,16 +1080,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;
@@ -1013,7 +1100,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)
@@ -1030,11 +1126,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
         }
     }
 
@@ -1070,7 +1175,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;
@@ -1083,7 +1188,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)
@@ -1100,7 +1205,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");
@@ -1109,12 +1214,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)
     {
@@ -1126,8 +1229,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;
               }
@@ -1135,8 +1243,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;
               }
@@ -1148,16 +1261,14 @@ void rm_sync_image_options(Image *image, Info *info)
         image->units = info->units;
     }
 
-#if defined(HAVE_SETIMAGEARTIFACT)
     copy_options(image, info);
-#endif
 }
 
 
 /**
  * Replicate old (ImageMagick < 6.3.2) EXIF:* functionality using
  * GetImageProperty by returning the exif entries as a single string, separated
- * by \n's.  Do this so that RMagick.rb works no matter which version of
+ * by \n's.  Do this so that RMagick works no matter which version of
  * ImageMagick is in use.
  *
  * No Ruby usage (internal function)
@@ -1173,8 +1284,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);
 
@@ -1182,7 +1301,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)
@@ -1190,11 +1309,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);
@@ -1202,8 +1326,12 @@ rm_exif_by_entry(Image *image)
 
     if (len == 0)
     {
+#if defined(IMAGEMAGICK_7)
+        DestroyExceptionInfo(exception);
+#endif
         return Qnil;
     }
+
     str = xmalloc(len);
     len = 0;
 
@@ -1213,7 +1341,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)
@@ -1222,10 +1350,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;
@@ -1234,6 +1371,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);
 
@@ -1246,7 +1387,7 @@ rm_exif_by_entry(Image *image)
 /**
  * Replicate old (ImageMagick < 6.3.2) EXIF:! functionality using
  * GetImageProperty by returning the exif entries as a single string, separated
- * by \n's. Do this so that RMagick.rb works no matter which version of
+ * by \n's. Do this so that RMagick works no matter which version of
  * ImageMagick is in use.
  *
  * No Ruby usage (internal function)
@@ -1262,8 +1403,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);
 
@@ -1271,7 +1419,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)
@@ -1279,11 +1427,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);
@@ -1291,8 +1444,12 @@ rm_exif_by_number(Image *image)
 
     if (len == 0)
     {
+#if defined(IMAGEMAGICK_7)
+        DestroyExceptionInfo(exception);
+#endif
         return Qnil;
     }
+
     str = xmalloc(len);
     len = 0;
 
@@ -1302,7 +1459,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)
@@ -1311,10 +1468,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;
@@ -1323,6 +1489,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);
 
@@ -1332,66 +1502,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.
  *
@@ -1411,66 +1521,19 @@ rm_clone_image(Image *image)
     ExceptionInfo *exception;
 
     exception = AcquireExceptionInfo();
-    clone = CloneImage(image, 0, 0, MagickTrue, exception);
+    GVL_STRUCT_TYPE(CloneImage) args = { image, 0, 0, MagickTrue, exception };
+    clone = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CloneImage), &args);
     if (!clone)
     {
         rb_raise(rb_eNoMemError, "not enough memory to continue");
     }
     rm_check_exception(exception, clone, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 
     return clone;
 }
 
 
-/**
- * SetImage(Info)ProgressMonitor exit.
- *
- * No Ruby usage (internal function)
- *
- * Notes:
- *   - ImageMagick's "tag" argument is unused. We pass along the method name
- *     instead.
- *
- * @param tag ImageMagick argument (unused)
- * @param of the offset type
- * @param sp the size type
- * @param client_data pointer to the progress method to call
- * @return true if calling client_data returns a non-nil value, otherwise false
- */
-MagickBooleanType
-rm_progress_monitor(
-    const char *tag,
-    const MagickOffsetType of,
-    const MagickSizeType sp,
-    void *client_data)
-{
-    VALUE rval;
-    VALUE method, offset, span;
-
-    tag = tag;      // defeat gcc message
-
-#if defined(HAVE_LONG_LONG)     // defined in Ruby's defines.h
-    offset = rb_ll2inum(of);
-    span = rb_ull2inum(sp);
-#else
-    offset = rb_int2big((long)of);
-    span = rb_uint2big((unsigned long)sp);
-#endif
-
-    method = rb_str_new2(rb_id2name(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;
-}
-
-
 /**
  * Remove the ImageMagick links between images in an scene sequence.
  *
@@ -1491,11 +1554,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
@@ -1543,7 +1607,34 @@ 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
+/**
+ * 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';
 }
 
 
@@ -1582,11 +1673,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) : "");
 }
 
 
@@ -1595,28 +1685,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);
 }
 
 
@@ -1627,14 +1707,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, "%s", GetLocaleExceptionMessage(severity, reason));
-    description = description;
+    rb_raise(Class_FatalImageMagickError, "%s%s%s",
+        GetLocaleExceptionMessage(severity, reason),
+        description ? ": " : "",
+        description ? GetLocaleExceptionMessage(severity, description) : "");
 }
 
 
@@ -1653,27 +1735,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("%s", msg);
+        rm_warning_handler(exception->severity, exception->reason, exception->description);
 
         // Caller deletes ExceptionInfo...
 
@@ -1689,7 +1756,7 @@ handle_exception(ExceptionInfo *exception, Image *imglist, ErrorRetention retent
     {
         if (retention == DestroyOnError)
         {
-            (void) DestroyImageList(imglist);
+            DestroyImageList(imglist);
             imglist = NULL;
         }
         else
@@ -1698,40 +1765,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);
 }
 
 
@@ -1752,3 +1790,52 @@ 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);
+}