rmagick 2.16.0 → 5.1.0

data/ext/RMagick/rmilist.c

@@ -16,27 +16,56 @@ static Image *clone_imagelist(Image *);
 static Image *images_from_imagelist(VALUE);
 static long imagelist_length(VALUE);
 static long check_imagelist_length(VALUE);
-static VALUE imagelist_scene_eq(VALUE, VALUE);
 static void imagelist_push(VALUE, VALUE);
 static VALUE ImageList_new(void);
 
 
+DEFINE_GVL_STUB3(AppendImages, const Image *, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB5(CloneImage, const Image *, const size_t, const size_t, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB2(CloneImageList, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(CoalesceImages, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(DisposeImages, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(EvaluateImages, const Image *, const MagickEvaluateOperator, ExceptionInfo *);
+DEFINE_GVL_STUB4(ImagesToBlob, const ImageInfo *, Image *, size_t *, ExceptionInfo *);
+DEFINE_GVL_STUB3(MergeImageLayers, Image *, const LayerMethod, ExceptionInfo *);
+DEFINE_GVL_STUB3(MontageImages, const Image *, const MontageInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(MorphImages, const Image *, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB2(OptimizeImageLayers, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(OptimizePlusImageLayers, const Image *, ExceptionInfo *);
+#if defined(IMAGEMAGICK_7)
+DEFINE_GVL_STUB3(AnimateImages, const ImageInfo *, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(CombineImages, const Image *, const ColorspaceType, ExceptionInfo *);
+DEFINE_GVL_STUB3(CompareImagesLayers, const Image *, const LayerMethod, ExceptionInfo *);
+DEFINE_GVL_STUB3(QuantizeImages, const QuantizeInfo *, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB4(RemapImages, const QuantizeInfo *, Image *, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(WriteImage, const ImageInfo *, Image *, ExceptionInfo *);
+#else
+DEFINE_GVL_STUB2(AnimateImages, const ImageInfo *, Image *);
+DEFINE_GVL_STUB3(CombineImages, const Image *, const ChannelType, ExceptionInfo *);
+DEFINE_GVL_STUB3(CompareImageLayers, const Image *, const ImageLayerMethod, ExceptionInfo *);
+DEFINE_GVL_STUB2(DeconstructImages, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(QuantizeImages, const QuantizeInfo *, Image *);
+DEFINE_GVL_STUB3(RemapImages, const QuantizeInfo *, Image *, const Image *);
+DEFINE_GVL_STUB2(WriteImage, const ImageInfo *, Image *);
+#endif
 
+DEFINE_GVL_VOID_STUB6(CompositeLayers, Image *, const CompositeOperator, Image *, const ssize_t, const ssize_t, ExceptionInfo *);
+DEFINE_GVL_VOID_STUB2(OptimizeImageTransparency, const Image *, ExceptionInfo *);
+DEFINE_GVL_VOID_STUB2(RemoveDuplicateLayers, Image **, ExceptionInfo *);
+DEFINE_GVL_VOID_STUB2(RemoveZeroDelayLayers, Image **, ExceptionInfo *);
 
 
 /**
  * Repeatedly display the images in the images array to an XWindow screen. The
- * "delay" argument is the number of 1/100ths of a second (0 to 65535) to delay
+ * +delay+ argument is the number of 1/100ths of a second (0 to 65535) to delay
  * between images.
  *
- * Ruby usage:
- *   - @verbatim ImageList#animate @endverbatim
- *   - @verbatim ImageList#animate(delay) @endverbatim
+ * @overload animate
+ *
+ * @overload animate(delay)
+ *   @param delay [Numeric] the length of time between each image in an animation
  *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return self
+ * @return [Magick::ImageList] self
  */
 
 VALUE
@@ -45,7 +74,15 @@ ImageList_animate(int argc, VALUE *argv, VALUE self)
     Image *images;
     Info *info;
     VALUE info_obj;
+    unsigned int delay;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+#endif
 
+    if (argc == 1)
+    {
+        delay = NUM2UINT(argv[0]);
+    }
     if (argc > 1)
     {
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc);
@@ -60,19 +97,27 @@ ImageList_animate(int argc, VALUE *argv, VALUE self)
     if (argc == 1)
     {
         Image *img;
-        unsigned int delay;
 
-        delay = NUM2UINT(argv[0]);
         for (img = images; img; img = GetNextImageInList(img))
         {
             img->delay = delay;
         }
     }
 
-    Data_Get_Struct(info_obj, Info, info);
-    (void) AnimateImages(info, images);
-    rm_check_image_exception(images, RetainOnError);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
+#if defined(IMAGEMAGICK_7)
+    exception = AcquireExceptionInfo();
+    GVL_STRUCT_TYPE(AnimateImages) args = { info, images, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AnimateImages), &args);
     rm_split(images);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+#else
+    GVL_STRUCT_TYPE(AnimateImages) args = { info, images };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AnimateImages), &args);
+    rm_split(images);
+    rm_check_image_exception(images, RetainOnError);
+#endif
 
     RB_GC_GUARD(info_obj);
 
@@ -81,14 +126,10 @@ ImageList_animate(int argc, VALUE *argv, VALUE self)
 
 
 /**
- * Append all the images by calling ImageAppend.
- *
- * Ruby usage:
- *   - @verbatim ImageList#append(stack) @endverbatim
+ * Append all the images
  *
- * @param self this object
- * @param stack_arg the stack of images
- * @return a Frame object for the result
+ * @param stack_arg [Magick::ImageList] the stack of images
+ * @return [Magick::Image] a frame object for the result
  */
 VALUE
 ImageList_append(VALUE self, VALUE stack_arg)
@@ -105,25 +146,20 @@ ImageList_append(VALUE self, VALUE stack_arg)
     stack = RTEST(stack_arg);
 
     exception = AcquireExceptionInfo();
-    new_image = AppendImages(images, stack, exception);
+    GVL_STRUCT_TYPE(AppendImages) args = { images, stack, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AppendImages), &args);
     rm_split(images);
     rm_check_exception(exception, new_image, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_image);
+    DestroyExceptionInfo(exception);
 
     return rm_image_new(new_image);
 }
 
 
 /**
- * Average all images together by calling AverageImages.
- *
- * Ruby usage:
- *   - @verbatim ImageList#average @endverbatim
+ * Average all images together
  *
- * @param self this object
- * @return a Frame object for the averaged image
+ * @return [Magick::Image] a frame object for the averaged image
  */
 VALUE
 ImageList_average(VALUE self)
@@ -135,34 +171,23 @@ ImageList_average(VALUE self)
     images = images_from_imagelist(self);
 
     exception = AcquireExceptionInfo();
-#if defined(HAVE_EVALUATEIMAGES)
-    new_image = EvaluateImages(images, MeanEvaluateOperator, exception);
-#else
-    new_image = AverageImages(images, exception);
-#endif
-
+    GVL_STRUCT_TYPE(EvaluateImages) args = { images, MeanEvaluateOperator, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EvaluateImages), &args);
     rm_split(images);
     rm_check_exception(exception, new_image, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_image);
+    DestroyExceptionInfo(exception);
 
     return rm_image_new(new_image);
 }
 
 
 /**
- * Call CoalesceImages.
- *
- * Ruby usage:
- *   - @verbatim ImageList#coalesce @endverbatim
+ * Composites a set of images while respecting any page offsets and disposal methods.
  *
- * Notes:
- *   - Respects the delay, matte, and start_loop fields in each image.
+ * - Respects the delay, matte, and start_loop fields in each image.
  *
- * @param self this object
- * @return a new Image with the coalesced image sequence return stored in the
- * images array
+ * @return [Magick::ImageList] a new image with the coalesced image sequence return stored in the
+ *   images array
  */
 VALUE
 ImageList_coalesce(VALUE self)
@@ -174,32 +199,124 @@ ImageList_coalesce(VALUE self)
     images = images_from_imagelist(self);
 
     exception = AcquireExceptionInfo();
-    new_images = CoalesceImages(images, exception);
+    GVL_STRUCT_TYPE(CoalesceImages) args = { images, exception };
+    new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CoalesceImages), &args);
     rm_split(images);
     rm_check_exception(exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_images);
+    DestroyExceptionInfo(exception);
 
     return rm_imagelist_from_images(new_images);
 }
 
 
 /**
- * Equivalent to convert's -layers composite option.
+ * Combines the images using the specified colorspace.
  *
- * Ruby usage:
- *   - @verbatim ImageList#composite_layers(images) @endverbatim
- *   - @verbatim ImageList#composite_layers(images,operator) @endverbatim
+ * @overload combine
  *
- * Notes:
- *   - Default operator is OverCompositeOp
+ * @overload combine(colorspace)
+ *   @param colorspace [Magick::ColorspaceType] the colorspace
  *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return a new imagelist
- * @see mogrify.c in ImageMagick
+ * @return [Magick::Image] a new image
+ */
+VALUE ImageList_combine(int argc, VALUE *argv, VALUE self)
+{
+#if defined(IMAGEMAGICK_6)
+    ChannelType channel;
+    ColorspaceType old_colorspace;
+#endif
+    ColorspaceType colorspace;
+    long len;
+    Image *images, *new_image;
+    ExceptionInfo *exception;
+
+    len = check_imagelist_length(self);
+
+    switch (argc)
+    {
+        case 1:
+            VALUE_TO_ENUM(argv[0], colorspace, ColorspaceType);
+            break;
+        case 0:
+            colorspace = sRGBColorspace;
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (expected 1, got %d)", argc);
+            break;
+    }
+
+#if defined(IMAGEMAGICK_7)
+    if (len > 5)
+    {
+        rb_raise(rb_eArgError, "invalid number of images in this image list");
+    }
+    if (len == 5 && colorspace != CMYKColorspace)
+    {
+        rb_raise(rb_eArgError, "invalid number of images in this image list");
+    }
+#else
+    channel = RedChannel;
+    switch (len)
+    {
+        case 5:
+            if (colorspace == CMYKColorspace)
+                channel |= AlphaChannel;
+            else
+                rb_raise(rb_eArgError, "invalid number of images in this image list");
+        case 4:
+            if (colorspace == CMYKColorspace)
+                channel |= IndexChannel;
+            else
+                channel |= AlphaChannel;
+        case 3:
+            channel |= GreenChannel;
+            channel |= BlueChannel;
+            break;
+        case 2:
+            channel |= AlphaChannel;
+            break;
+        case 1:
+            break;
+        default:
+            rb_raise(rb_eArgError, "invalid number of images in this image list");
+            break;
+    }
+#endif
+
+    images = images_from_imagelist(self);
+    exception = AcquireExceptionInfo();
+#if defined(IMAGEMAGICK_6)
+    old_colorspace = images->colorspace;
+    SetImageColorspace(images, colorspace);
+    GVL_STRUCT_TYPE(CombineImages) args = { images, channel, exception };
+#else
+    GVL_STRUCT_TYPE(CombineImages) args = { images, colorspace, exception };
+#endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CombineImages), &args);
+
+    rm_split(images);
+#if defined(IMAGEMAGICK_6)
+    images->colorspace = old_colorspace;
+#endif
+    rm_check_exception(exception, new_image, DestroyOnError);
+    DestroyExceptionInfo(exception);
+
+    return rm_image_new(new_image);
+}
+
+
+/**
+ * An image from source images is composited over an image from receiver's list until one list is finished.
+ *
+ * @overload composite_layers(images)
+ *   @param images [Magick::ImageList] the source images
+ *
+ * @overload composite_layers(images, operator)
+ *   - Default operator is {Magick::OverCompositeOp}
+ *   @param images [Magick::ImageList] the source images
+ *   @param operator [Magick::CompositeOperator] the operator
+ *
+ * @return [Magick::ImageList] a new imagelist
  */
 VALUE
 ImageList_composite_layers(int argc, VALUE *argv, VALUE self)
@@ -229,20 +346,21 @@ ImageList_composite_layers(int argc, VALUE *argv, VALUE self)
 
     source = images_from_imagelist(source_images);
 
-    SetGeometry(new_images,&geometry);
-    (void) ParseAbsoluteGeometry(new_images->geometry, &geometry);
+    SetGeometry(new_images, &geometry);
+    ParseAbsoluteGeometry(new_images->geometry, &geometry);
 
     geometry.width  = source->page.width != 0 ? source->page.width : source->columns;
     geometry.height = source->page.height != 0 ? source->page.height : source->rows;
-    GravityAdjustGeometry(new_images->page.width  != 0 ? new_images->page.width  : new_images->columns
-                        , new_images->page.height != 0 ? new_images->page.height : new_images->rows
-                        , new_images->gravity, &geometry);
+    GravityAdjustGeometry(new_images->page.width  != 0 ? new_images->page.width  : new_images->columns,
+                          new_images->page.height != 0 ? new_images->page.height : new_images->rows,
+                          new_images->gravity, &geometry);
 
     exception = AcquireExceptionInfo();
-    CompositeLayers(new_images, operator, source, geometry.x, geometry.y, exception);
+    GVL_STRUCT_TYPE(CompositeLayers) args = { new_images, operator, source, geometry.x, geometry.y, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeLayers), &args);
     rm_split(source);
     rm_check_exception(exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 
     RB_GC_GUARD(source_images);
 
@@ -254,11 +372,7 @@ ImageList_composite_layers(int argc, VALUE *argv, VALUE self)
  * Compare each image with the next in a sequence and returns the maximum
  * bounding region of any pixel differences it discovers.
  *
- * Ruby usage:
- *   - @verbatim ImageList#deconstruct @endverbatim
- *
- * @param self this object
- * @return a new imagelist
+ * @return [Magick::ImageList] a new imagelist
  */
 VALUE
 ImageList_deconstruct(VALUE self)
@@ -268,12 +382,16 @@ ImageList_deconstruct(VALUE self)
 
     images = images_from_imagelist(self);
     exception = AcquireExceptionInfo();
-    new_images = DeconstructImages(images, exception);
+#if defined(IMAGEMAGICK_7)
+    GVL_STRUCT_TYPE(CompareImagesLayers) args = { images, CompareAnyLayer, exception };
+    new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompareImagesLayers), &args);
+#else
+    GVL_STRUCT_TYPE(DeconstructImages) args = { images, exception };
+    new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(DeconstructImages), &args);
+#endif
     rm_split(images);
     rm_check_exception(exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_images);
+    DestroyExceptionInfo(exception);
 
     return rm_imagelist_from_images(new_images);
 }
@@ -282,11 +400,7 @@ ImageList_deconstruct(VALUE self)
 /**
  * Display all the images to an X window screen.
  *
- * Ruby usage:
- *   - @verbatim ImageList#display @endverbatim
- *
- * @param self this object
- * @return self
+ * @return [Magick::ImageList] self
  */
 VALUE
 ImageList_display(VALUE self)
@@ -294,17 +408,27 @@ ImageList_display(VALUE self)
     Image *images;
     Info *info;
     VALUE info_obj;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+#endif
 
     // Create a new Info object to use with this call
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
 
     // Convert the images array to an images sequence.
     images = images_from_imagelist(self);
-
-    (void) DisplayImages(info, images);
+#if defined(IMAGEMAGICK_7)
+    exception = AcquireExceptionInfo();
+    DisplayImages(info, images, exception);
+    rm_split(images);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+#else
+    DisplayImages(info, images);
     rm_split(images);
     rm_check_image_exception(images, RetainOnError);
+#endif
 
     RB_GC_GUARD(info_obj);
 
@@ -315,14 +439,7 @@ ImageList_display(VALUE self)
 /**
  * Merge all the images into a single image.
  *
- * Ruby usage:
- *   - @verbatim ImageList#flatten_images @endverbatim
- *
- * Notes:
- *   - Can't use "flatten" because that's an Array method
- *
- * @param self this object
- * @return the new image
+ * @return [Magick::ImageList] the new image
  */
 VALUE
 ImageList_flatten_images(VALUE self)
@@ -333,164 +450,28 @@ ImageList_flatten_images(VALUE self)
     images = images_from_imagelist(self);
     exception = AcquireExceptionInfo();
 
-#if defined(HAVE_ENUM_FLATTENLAYER)
-    new_image = MergeImageLayers(images, FlattenLayer, exception);
-#else
-    new_image = FlattenImages(images, exception);
-#endif
-
-    rm_split(images);
-    rm_check_exception(exception, new_image, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_image);
-
-    return rm_image_new(new_image);
-}
-
-
-/**
- * Apply fx on the images.
- *
- * Ruby usage:
- *   - @verbatim ImageList#fx(expression) @endverbatim
- *   - @verbatim ImageList#fx(expression, channel) @endverbatim
- *   - @verbatim ImageList#fx(expression, channel, ...) @endverbatim
- *
- * Notes:
- *   - Default channel is AllChannels
- *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return a new image
- */
-VALUE
-ImageList_fx(int argc, VALUE *argv, VALUE self)
-{
-    Image *images, *new_image;
-    char *expression;
-    ChannelType channels;
-    ExceptionInfo *exception;
-
-
-    channels = extract_channels(&argc, argv);
+    GVL_STRUCT_TYPE(MergeImageLayers) args = { images, FlattenLayer, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MergeImageLayers), &args);
 
-    // There must be exactly 1 remaining argument.
-    if (argc == 0)
-    {
-        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1 or more)");
-    }
-    else if (argc > 1)
-    {
-        raise_ChannelType_error(argv[argc-1]);
-    }
-
-    expression = StringValuePtr(argv[0]);
-
-    images = images_from_imagelist(self);
-    exception = AcquireExceptionInfo();
-    new_image = FxImageChannel(images, channels, expression, exception);
     rm_split(images);
     rm_check_exception(exception, new_image, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_image);
+    DestroyExceptionInfo(exception);
 
     return rm_image_new(new_image);
 }
 
 
 /**
- * Call MapImages.
- *
- * Ruby usage:
- *   - @verbatim ImageList#map(reference) @endverbatim
- *   - @verbatim ImageList#map(reference, dither) @endverbatim
- *
- * Notes:
- *   - Default dither is false
- *   - Sets \@scene to self.scene
- *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return a new ImageList with mapped images.
- */
-VALUE
-ImageList_map(int argc, VALUE *argv, VALUE self)
-{
-    Image *images, *new_images = NULL;
-    Image *map;
-    unsigned int dither = MagickFalse;
-    VALUE scene, new_imagelist, t;
-    ExceptionInfo *exception;
-
-#if defined(HAVE_REMAPIMAGES)
-    QuantizeInfo quantize_info;
-    rb_warning("ImageList#map is deprecated. Use ImageList#remap instead.");
-#endif
-
-    switch (argc)
-    {
-        case 2:
-            dither = RTEST(argv[1]);
-        case 1:
-            t = rm_cur_image(argv[0]);
-            map = rm_check_destroyed(t);
-            break;
-        default:
-            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
-            break;
-    }
-
-
-    // Convert image array to image sequence, clone image sequence.
-    exception = AcquireExceptionInfo();
-
-    images = images_from_imagelist(self);
-    new_images = CloneImageList(images, exception);
-    rm_split(images);
-    rm_check_exception(exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_images);
-
-    // Call ImageMagick
-#if defined(HAVE_REMAPIMAGES)
-    GetQuantizeInfo(&quantize_info);
-    quantize_info.dither = dither;
-    (void) RemapImages(&quantize_info, new_images, map);
-#else
-    (void) MapImages(new_images, map, dither);
-#endif
-    rm_check_image_exception(new_images, DestroyOnError);
-
-    // Set @scene in new ImageList object to same value as in self.
-    new_imagelist = rm_imagelist_from_images(new_images);
-    scene = rb_iv_get(self, "@scene");
-    (void) imagelist_scene_eq(new_imagelist, scene);
-
-    RB_GC_GUARD(scene);
-    RB_GC_GUARD(new_imagelist);
-    RB_GC_GUARD(t);
-
-    return new_imagelist;
-}
-
-
-/**
- * Call MontageImages.
+ * Tile one or more thumbnails across an image canvas.
  *
- * Ruby usage:
- *   - @verbatim ImageList#montage <{parm block}> @endverbatim
+ * @overload montage
  *
- * Notes:
- *   - Creates Montage object, yields to block if present in Montage object's
- *     scope.
+ * @overload montage
+ *   Creates {Magick::ImageList::Montage} object, yields to block
+ *   if present in {Magick::ImageList::Montage} object's scope.
+ *   @yield [Magick::ImageList::Montage]
  *
- * @param self this object
- * @return a new image list
+ * @return [Magick::ImageList] a new image list
  */
 VALUE
 ImageList_montage(VALUE self)
@@ -500,38 +481,37 @@ ImageList_montage(VALUE self)
     Image *new_images, *images;
     ExceptionInfo *exception;
 
-    // Create a new instance of the Magick::Montage class
+    // Create a new instance of the Magick::ImageList::Montage class
     montage_obj = rm_montage_new();
     if (rb_block_given_p())
     {
-        // Run the block in the instance's context, allowing the app to modify the
-        // object's attributes.
-        (void) rb_obj_instance_eval(0, NULL, montage_obj);
+        rb_yield(montage_obj);
     }
 
-    Data_Get_Struct(montage_obj, Montage, montage);
+    TypedData_Get_Struct(montage_obj, Montage, &rm_montage_data_type, montage);
 
     images = images_from_imagelist(self);
 
-    // If app specified a non-default composition operator, use it for all images.
-    if (montage->compose != UndefinedCompositeOp)
+    for (Image *image = images; image; image = GetNextImageInList(image))
     {
-        Image *i;
-        for (i = images; i; i = GetNextImageInList(i))
+        if (montage->compose != UndefinedCompositeOp)
         {
-            i->compose = montage->compose;
+            image->compose = montage->compose;
         }
+        image->background_color = montage->info->background_color;
+        image->border_color = montage->info->border_color;
+        image->matte_color = montage->info->matte_color;
+        image->gravity = montage->info->gravity;
     }
 
     exception = AcquireExceptionInfo();
 
     // MontageImage can return more than one image.
-    new_images = MontageImages(images, montage->info, exception);
+    GVL_STRUCT_TYPE(MontageImages) args = { images, montage->info, exception };
+    new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MontageImages), &args);
     rm_split(images);
     rm_check_exception(exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_images);
+    DestroyExceptionInfo(exception);
 
     RB_GC_GUARD(montage_obj);
 
@@ -541,17 +521,11 @@ ImageList_montage(VALUE self)
 
 /**
  * Requires a minimum of two images. The first image is transformed into the
- * second by a number of intervening images as specified by "number_images".
+ * second by a number of intervening images as specified by "nimages".
  *
- * Ruby usage:
- *   - @verbatim ImageList#morph(number_images) @endverbatim
- *
- * Notes:
- *   - Sets \@scenes to 0
- *
- * @param self this object
- * @param nimages the number of images
- * @return a new image list with the images array set to the morph sequence.
+ * @note Sets +@scenes+ to 0
+ * @param nimages [Numeric] the number of images
+ * @return [Magick::ImageList] a new image list with the images array set to the morph sequence.
  */
 VALUE
 ImageList_morph(VALUE self, VALUE nimages)
@@ -568,14 +542,13 @@ ImageList_morph(VALUE self, VALUE nimages)
         rb_raise(rb_eArgError, "number of intervening images must be > 0");
     }
 
-    exception = AcquireExceptionInfo();
     images = images_from_imagelist(self);
-    new_images = MorphImages(images, (unsigned long)number_images, exception);
+    exception = AcquireExceptionInfo();
+    GVL_STRUCT_TYPE(MorphImages) args = { images, number_images, exception };
+    new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MorphImages), &args);
     rm_split(images);
     rm_check_exception(exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_images);
+    DestroyExceptionInfo(exception);
 
     return rm_imagelist_from_images(new_images);
 }
@@ -584,11 +557,7 @@ ImageList_morph(VALUE self, VALUE nimages)
 /**
  * Merge all the images into a single image.
  *
- * Ruby usage:
- *   - @verbatim ImageList#mosaic @endverbatim
- *
- * @param self this object
- * @return the new image
+ * @return [Magick::Image] the new image
  */
 VALUE
 ImageList_mosaic(VALUE self)
@@ -596,139 +565,169 @@ ImageList_mosaic(VALUE self)
     Image *images, *new_image;
     ExceptionInfo *exception;
 
-    exception = AcquireExceptionInfo();
     images = images_from_imagelist(self);
 
-#if defined(HAVE_ENUM_MOSAICLAYER)
-    new_image = MergeImageLayers(images, MosaicLayer, exception);
-#else
-    new_image = MosaicImages(images, exception);
-#endif
+    exception = AcquireExceptionInfo();
+    GVL_STRUCT_TYPE(MergeImageLayers) args = { images, MosaicLayer, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MergeImageLayers), &args);
 
     rm_split(images);
     rm_check_exception(exception, new_image, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_image);
+    DestroyExceptionInfo(exception);
 
     return rm_image_new(new_image);
 }
 
 
 /**
- * Equivalent to -layers option in ImageMagick 6.2.6.
- *
- * Ruby usage:
- *   - @verbatim ImageList#optimize_layers(method) @endverbatim
+ * Optimizes or compares the images in the list.
+ * Equivalent to the -layers option in ImageMagick's mogrify command.
  *
- * @param self this object
- * @param method the method to use
- * @return a new imagelist
+ * @param method [Magick::LayerMethod] the method to use
+ * @return [Magick::ImageList] a new imagelist
  */
 VALUE
 ImageList_optimize_layers(VALUE self, VALUE method)
 {
     Image *images, *new_images, *new_images2;
-    LAYERMETHODTYPE mthd;
+    LayerMethod mthd;
     ExceptionInfo *exception;
     QuantizeInfo quantize_info;
 
     new_images2 = NULL;     // defeat "unused variable" message
 
-    exception = AcquireExceptionInfo();
-#if defined(HAVE_TYPE_IMAGELAYERMETHOD)
-    VALUE_TO_ENUM(method, mthd, ImageLayerMethod);
-#else
-    VALUE_TO_ENUM(method, mthd, MagickLayerMethod);
-#endif
+    VALUE_TO_ENUM(method, mthd, LayerMethod);
     images = images_from_imagelist(self);
 
+    exception = AcquireExceptionInfo();
     switch (mthd)
     {
         case CoalesceLayer:
-            new_images = CoalesceImages(images, exception);
+            {
+                GVL_STRUCT_TYPE(CoalesceImages) args = { images, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CoalesceImages), &args);
+            }
             break;
         case DisposeLayer:
-            new_images = DisposeImages(images, exception);
+            {
+                GVL_STRUCT_TYPE(DisposeImages) args = { images, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(DisposeImages), &args);
+            }
             break;
         case OptimizeTransLayer:
-            new_images = clone_imagelist(images);
-            OptimizeImageTransparency(new_images, exception);
+            {
+                new_images = clone_imagelist(images);
+                GVL_STRUCT_TYPE(OptimizeImageTransparency) args = { new_images, exception };
+                CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OptimizeImageTransparency), &args);
+            }
             break;
         case RemoveDupsLayer:
-            new_images = clone_imagelist(images);
-            RemoveDuplicateLayers(&new_images, exception);
+            {
+                new_images = clone_imagelist(images);
+                GVL_STRUCT_TYPE(RemoveDuplicateLayers) args = { &new_images, exception };
+                CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RemoveDuplicateLayers), &args);
+            }
             break;
         case RemoveZeroLayer:
-            new_images = clone_imagelist(images);
-            RemoveZeroDelayLayers(&new_images, exception);
+            {
+                new_images = clone_imagelist(images);
+                GVL_STRUCT_TYPE(RemoveZeroDelayLayers) args = { &new_images, exception };
+                CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RemoveZeroDelayLayers), &args);
+            }
             break;
         case CompositeLayer:
             rm_split(images);
+            DestroyExceptionInfo(exception);
             rb_raise(rb_eNotImpError, "Magick::CompositeLayer is not supported. Use the composite_layers method instead.");
             break;
             // In 6.3.4-ish, OptimizeImageLayer replaced OptimizeLayer
         case OptimizeImageLayer:
-            new_images = OptimizeImageLayers(images, exception);
+            {
+                GVL_STRUCT_TYPE(OptimizeImageLayers) args = { images, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OptimizeImageLayers), &args);
+            }
             break;
             // and OptimizeLayer became a "General Purpose, GIF Animation Optimizer" (ref. mogrify.c)
         case OptimizeLayer:
-            new_images = CoalesceImages(images, exception);
-            rm_split(images);
-            rm_check_exception(exception, new_images, DestroyOnError);
-            new_images2 = OptimizeImageLayers(new_images, exception);
-            DestroyImageList(new_images);
-            rm_check_exception(exception, new_images2, DestroyOnError);
-            new_images = new_images2;
-            OptimizeImageTransparency(new_images, exception);
-            rm_check_exception(exception, new_images, DestroyOnError);
-            // mogrify supports -dither here. We don't.
-#if defined(HAVE_REMAPIMAGE)
-            GetQuantizeInfo(&quantize_info);
-            (void) RemapImages(&quantize_info, new_images, NULL);
+            {
+                GVL_STRUCT_TYPE(CoalesceImages) args_CoalesceImages = { images, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CoalesceImages), &args_CoalesceImages);
+                rm_split(images);
+                rm_check_exception(exception, new_images, DestroyOnError);
+
+                GVL_STRUCT_TYPE(OptimizeImageLayers) args_OptimizeImageLayers = { new_images, exception };
+                new_images2 = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OptimizeImageLayers), &args_OptimizeImageLayers);
+                DestroyImageList(new_images);
+                rm_check_exception(exception, new_images2, DestroyOnError);
+
+                new_images = new_images2;
+                GVL_STRUCT_TYPE(OptimizeImageTransparency) args_OptimizeImageTransparency = { new_images, exception };
+                CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OptimizeImageTransparency), &args_OptimizeImageTransparency);
+                rm_check_exception(exception, new_images, DestroyOnError);
+                // mogrify supports -dither here. We don't.
+                GetQuantizeInfo(&quantize_info);
+#if defined(IMAGEMAGICK_7)
+                GVL_STRUCT_TYPE(RemapImages) args_RemapImages = { &quantize_info, new_images, NULL, exception };
 #else
-            (void) MapImages(new_images, NULL, 0);
+                GVL_STRUCT_TYPE(RemapImages) args_RemapImages = { &quantize_info, new_images, NULL };
 #endif
+                CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RemapImages), &args_RemapImages);
+
+            }
             break;
         case OptimizePlusLayer:
-            new_images = OptimizePlusImageLayers(images, exception);
+            {
+                GVL_STRUCT_TYPE(OptimizePlusImageLayers) args = { images, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OptimizePlusImageLayers), &args);
+            }
             break;
         case CompareAnyLayer:
         case CompareClearLayer:
         case CompareOverlayLayer:
-            new_images = CompareImageLayers(images, mthd, exception);
+            {
+#if defined(IMAGEMAGICK_7)
+                GVL_STRUCT_TYPE(CompareImagesLayers) args = { images, mthd, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompareImagesLayers), &args);
+#else
+                GVL_STRUCT_TYPE(CompareImageLayers) args = { images, mthd, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompareImageLayers), &args);
+#endif
+            }
             break;
-#if defined(HAVE_ENUM_MOSAICLAYER)
         case MosaicLayer:
-            new_images = MergeImageLayers(images, mthd, exception);
+            {
+                GVL_STRUCT_TYPE(MergeImageLayers) args = { images, mthd, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MergeImageLayers), &args);
+            }
             break;
-#endif
-#if defined(HAVE_ENUM_FLATTENLAYER)
         case FlattenLayer:
-            new_images = MergeImageLayers(images, mthd, exception);
+            {
+                GVL_STRUCT_TYPE(MergeImageLayers) args = { images, mthd, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MergeImageLayers), &args);
+            }
             break;
-#endif
-#if defined(HAVE_ENUM_MERGELAYER)
         case MergeLayer:
-            new_images = MergeImageLayers(images, mthd, exception);
+            {
+                GVL_STRUCT_TYPE(MergeImageLayers) args = { images, mthd, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MergeImageLayers), &args);
+            }
             break;
-#endif
-#if defined(HAVE_ENUM_TRIMBOUNDSLAYER)
         case TrimBoundsLayer:
-            new_images = MergeImageLayers(images, mthd, exception);
+            {
+                GVL_STRUCT_TYPE(MergeImageLayers) args = { images, mthd, exception };
+                new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MergeImageLayers), &args);
+            }
             break;
-#endif
         default:
             rm_split(images);
+            DestroyExceptionInfo(exception);
             rb_raise(rb_eArgError, "undefined layer method");
             break;
     }
 
     rm_split(images);
     rm_check_exception(exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
-
-    rm_ensure_result(new_images);
+    DestroyExceptionInfo(exception);
 
     return rm_imagelist_from_images(new_images);
 }
@@ -767,22 +766,20 @@ VALUE
 rm_imagelist_from_images(Image *images)
 {
     VALUE new_imagelist;
-    Image *image;
 
-    if (!images)
-    {
-        rb_bug("rm_imagelist_from_images called with NULL argument");
-    }
+    rm_ensure_result(images);
 
     new_imagelist = ImageList_new();
 
     while (images)
     {
+        Image *image;
+
         image = RemoveFirstImageFromList(&images);
         imagelist_push(new_imagelist, rm_image_new(image));
     }
 
-    (void) rb_iv_set(new_imagelist, "@scene", INT2FIX(0));
+    rb_iv_set(new_imagelist, "@scene", INT2FIX(0));
 
     RB_GC_GUARD(new_imagelist);
 
@@ -820,6 +817,9 @@ images_from_imagelist(VALUE imagelist)
         if (head == image || GetPreviousImageInList(image) != NULL)
         {
             image = rm_clone_image(image);
+
+            // Wrap raw ImageMagick object by Ruby object to destroy using Ruby's GC.
+            rm_image_new(image);
         }
         AppendImageToList(&head, image);
     }
@@ -831,24 +831,6 @@ images_from_imagelist(VALUE imagelist)
 }
 
 
-/**
- * \@scene attribute writer.
- *
- * No Ruby usage (internal function)
- *
- * @param imagelist the imagelist
- * @param scene the scene
- * @return the scene
- */
-static VALUE
-imagelist_scene_eq(VALUE imagelist, VALUE scene)
-{
-    rb_check_frozen(imagelist);
-    (void) rb_iv_set(imagelist, "@scene", scene);
-    return scene;
-}
-
-
 /**
  * return the # of images in an imagelist.
  *
@@ -861,6 +843,10 @@ static long
 imagelist_length(VALUE imagelist)
 {
     VALUE images = rb_iv_get(imagelist, "@images");
+    if (!RB_TYPE_P(images, T_ARRAY))
+    {
+        rb_raise(Class_ImageMagickError, "@images is not of type Array");
+    }
 
     RB_GC_GUARD(images);
 
@@ -903,7 +889,7 @@ static void
 imagelist_push(VALUE imagelist, VALUE image)
 {
     rb_check_frozen(imagelist);
-    (void) rb_funcall(imagelist, rm_ID_push, 1, image);
+    rb_funcall(imagelist, rm_ID_push, 1, image);
 }
 
 
@@ -918,7 +904,7 @@ imagelist_push(VALUE imagelist, VALUE image)
 static Image *
 clone_imagelist(Image *images)
 {
-    Image *new_imagelist = NULL, *image, *clone;
+    Image *new_imagelist = NULL, *image;
     ExceptionInfo *exception;
 
     exception = AcquireExceptionInfo();
@@ -926,40 +912,32 @@ clone_imagelist(Image *images)
     image = GetFirstImageInList(images);
     while (image)
     {
-        clone = CloneImage(image, 0, 0, MagickTrue, exception);
+        Image *clone;
+
+        GVL_STRUCT_TYPE(CloneImage) args = { image, 0, 0, MagickTrue, exception };
+        clone = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CloneImage), &args);
         rm_check_exception(exception, new_imagelist, DestroyOnError);
         AppendImageToList(&new_imagelist, clone);
         image = GetNextImageInList(image);
     }
 
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
     return new_imagelist;
 }
 
 
 /**
- * Call QuantizeImages.
- *
- * Ruby usage:
- *   - @verbatim ImageList#quantize @endverbatim
- *   - @verbatim ImageList#quantize(number_colors) @endverbatim
- *   - @verbatim ImageList#quantize(number_colors, colorspace) @endverbatim
- *   - @verbatim ImageList#quantize(number_colors, colorspace, dither) @endverbatim
- *   - @verbatim ImageList#quantize(number_colors, colorspace, dither, tree_depth) @endverbatim
- *   - @verbatim ImageList#quantize(number_colors, colorspace, dither, tree_depth, measure_error) @endverbatim
- *
- * Notes:
- *   - Default number_colors is 256
- *   - Default coorspace is Magick::RGBColorsapce
- *   - Default dither is true
- *   - Default tree_depth is 0
- *   - Default measure_error is false
- *   - Sets \@scene to the same value as self.scene
- *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return a new ImageList with quantized images
+ * Analyzes the colors within a set of reference images and chooses a fixed number of colors to represent the set.
+ * The goal of the algorithm is to minimize the difference between the input and output images while minimizing the processing time.
+ *
+ * @overload quantize(number_colors = 256, colorspace = Magick::RGBColorsapce, dither = true, tree_depth = 0, measure_error = false)
+ *   @param number_colors [Numeric] the maximum number of colors to use in the output images.
+ *   @param colorspace [Magick::ColorspaceType] the colorspace to quantize in.
+ *   @param dither [Magick::DitherMethod, Boolean] a DitherMethod value or true if you want apply dither.
+ *   @param tree_depth [Numeric] specify the tree depth to use while quantizing.
+ *   @param measure_error [Boolean] calculate quantization errors when quantizing the image.
+ *   @return [Magick::ImageList] a new ImageList with quantized images
+ *   @note Sets +@scene+ to the same value as +self.scene+
  */
 VALUE
 ImageList_quantize(int argc, VALUE *argv, VALUE self)
@@ -979,14 +957,25 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
         case 4:
             quantize_info.tree_depth = (unsigned long)NUM2INT(argv[3]);
         case 3:
-#if defined(HAVE_TYPE_DITHERMETHOD) && defined(HAVE_ENUM_NODITHERMETHOD)
+#if defined(IMAGEMAGICK_7)
             if (rb_obj_is_kind_of(argv[2], Class_DitherMethod))
             {
                 VALUE_TO_ENUM(argv[2], quantize_info.dither_method, DitherMethod);
-                quantize_info.dither = quantize_info.dither_method != NoDitherMethod;
+            }
+            else
+            {
+                quantize_info.dither_method = RTEST(argv[2]) ? UndefinedDitherMethod : NoDitherMethod;
             }
 #else
-            quantize_info.dither = (MagickBooleanType) RTEST(argv[2]);
+            if (rb_obj_is_kind_of(argv[2], Class_DitherMethod))
+            {
+                VALUE_TO_ENUM(argv[2], quantize_info.dither_method, DitherMethod);
+                quantize_info.dither = quantize_info.dither_method != NoDitherMethod;
+            }
+            else
+            {
+                quantize_info.dither = (MagickBooleanType) RTEST(argv[2]);
+            }
 #endif
         case 2:
             VALUE_TO_ENUM(argv[1], quantize_info.colorspace, ColorspaceType);
@@ -1001,18 +990,23 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
 
 
     // Convert image array to image sequence, clone image sequence.
-    exception = AcquireExceptionInfo();
     images = images_from_imagelist(self);
-    new_images = CloneImageList(images, exception);
+    exception = AcquireExceptionInfo();
+    GVL_STRUCT_TYPE(CloneImageList) args_CloneImageList = { images, exception };
+    new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CloneImageList), &args_CloneImageList);
     rm_split(images);
     rm_check_exception(exception, new_images, DestroyOnError);
 
     rm_ensure_result(new_images);
 
-
-    (void) QuantizeImages(&quantize_info, new_images);
+#if defined(IMAGEMAGICK_7)
+    GVL_STRUCT_TYPE(QuantizeImages) args_QuantizeImages = { &quantize_info, new_images, exception };
+#else
+    GVL_STRUCT_TYPE(QuantizeImages) args_QuantizeImages = { &quantize_info, new_images };
+#endif
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(QuantizeImages), &args_QuantizeImages);
     rm_check_exception(exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 
     // Create new ImageList object, convert mapped image sequence to images,
     // append to images array.
@@ -1024,7 +1018,7 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
 
     // Set @scene in new ImageList object to same value as in self.
     scene = rb_iv_get(self, "@scene");
-    (void) rb_iv_set(new_imagelist, "@scene", scene);
+    rb_iv_set(new_imagelist, "@scene", scene);
 
     RB_GC_GUARD(new_imagelist);
     RB_GC_GUARD(scene);
@@ -1034,30 +1028,23 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
 
 
 /**
- * Call RemapImages.
- *
- * Ruby usage:
- *   - @verbatim ImageList#remap @endverbatim
- *   - @verbatim ImageList#remap(remap_image) @endverbatim
- *   - @verbatim ImageList#remap(remap_image, dither_method) @endverbatim
- *
- * Notes:
- *   - Default remap_image is nil
- *   - Default dither_method is RiemersmaDitherMethod
- *   - Modifies images in-place.
- *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @see Image_remap
+ * Reduce the colors used in the image list to the set of colors in +remap_image+.
+ *
+ * @overload remap(remap_image = nil, dither_method = Magick::RiemersmaDitherMethod)
+ *   @param remap_image [Magick::Image, Magick::ImageList] Either an imagelist or an image. If an
+ *     imagelist, uses the current image.
+ *   @param dither_method [Magick::DitherMethod] a DitherMethod value.
+ *   @return [Magick::ImageList] self
+ *   @note Modifies images in-place.
  */
 VALUE
 ImageList_remap(int argc, VALUE *argv, VALUE self)
 {
-#if defined(HAVE_REMAPIMAGES) || defined(HAVE_AFFINITYIMAGES)
     Image *images, *remap_image = NULL;
     QuantizeInfo quantize_info;
-
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+#endif
 
     if (argc > 0 && argv[0] != Qnil)
     {
@@ -1071,7 +1058,9 @@ ImageList_remap(int argc, VALUE *argv, VALUE self)
     if (argc > 1)
     {
         VALUE_TO_ENUM(argv[1], quantize_info.dither_method, DitherMethod);
+#if defined(IMAGEMAGICK_6)
         quantize_info.dither = MagickTrue;
+#endif
     }
     if (argc > 2)
     {
@@ -1080,37 +1069,34 @@ ImageList_remap(int argc, VALUE *argv, VALUE self)
 
     images = images_from_imagelist(self);
 
-#if defined(HAVE_REMAPIMAGE)
-    (void) RemapImages(&quantize_info, images, remap_image);
+#if defined(IMAGEMAGICK_7)
+    exception = AcquireExceptionInfo();
+    GVL_STRUCT_TYPE(RemapImages) args = { &quantize_info, images, remap_image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RemapImages), &args);
+    rm_split(images);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
 #else
-    (void) AffinityImages(&quantize_info, images, remap_image);
-#endif
-    rm_check_image_exception(images, RetainOnError);
+    GVL_STRUCT_TYPE(RemapImages) args = { &quantize_info, images, remap_image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RemapImages), &args);
     rm_split(images);
+    rm_check_image_exception(images, RetainOnError);
+#endif
 
     return self;
-#else
-    self = self;
-    argc = argc;
-    argv = argv;
-    rm_not_implemented();
-    return(VALUE)0;
-#endif
 }
 
 
 /**
  * Return the imagelist as a blob (a String).
  *
- * Ruby usage:
- *   - @verbatim ImageList#to_blob @endverbatim
+ * @overload to_blob
  *
- * Notes:
- *   - Runs an info parm block if present - the user can specify the image
- *     format and depth
+ * @overload to_blob
+ *   Runs an info parm block if present - the user can specify the image format and depth
+ *   @yield [Magick::Image::Info]
  *
- * @param self this object
- * @return the blob
+ * @return [String] the blob
  */
 VALUE
 ImageList_to_blob(VALUE self)
@@ -1124,13 +1110,13 @@ ImageList_to_blob(VALUE self)
     ExceptionInfo *exception;
 
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
 
     // Convert the images array to an images sequence.
     images = images_from_imagelist(self);
 
     exception = AcquireExceptionInfo();
-    (void) SetImageInfo(info, MagickTrue, exception);
+    SetImageInfo(info, MagickTrue, exception);
     rm_check_exception(exception, images, RetainOnError);
 
     if (*info->magick != '\0')
@@ -1138,7 +1124,7 @@ ImageList_to_blob(VALUE self)
         Image *img;
         for (img = images; img; img = GetNextImageInList(img))
         {
-            strncpy(img->magick, info->magick, sizeof(info->magick)-1);
+            strlcpy(img->magick, info->magick, sizeof(img->magick));
         }
     }
 
@@ -1151,7 +1137,8 @@ ImageList_to_blob(VALUE self)
     // can happen is that there's only one image or the format
     // doesn't support multi-image files.
     info->adjoin = MagickTrue;
-    blob = ImagesToBlob(info, images, &length, exception);
+    GVL_STRUCT_TYPE(ImagesToBlob) args = { info, images, &length, exception };
+    blob = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ImagesToBlob), &args);
     if (blob && exception->severity >= ErrorException)
     {
         magick_free((void*)blob);
@@ -1159,8 +1146,8 @@ ImageList_to_blob(VALUE self)
         length = 0;
     }
     rm_split(images);
-    CHECK_EXCEPTION()
-    (void) DestroyExceptionInfo(exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
 
 
     if (length == 0 || !blob)
@@ -1184,12 +1171,7 @@ ImageList_to_blob(VALUE self)
  * the images will be written as a single multi-image file. Otherwise each image
  * will be written to a separate file.
  *
- * Ruby usage:
- *   - @verbatim ImageList#write(file) @endverbatim
- *
- * @param self this object
- * @param file the file
- * @return self
+ * @param file [File, String] the file
  */
 VALUE
 ImageList_write(VALUE self, VALUE file)
@@ -1202,12 +1184,12 @@ ImageList_write(VALUE self, VALUE file)
     ExceptionInfo *exception;
 
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
 
 
     if (TYPE(file) == T_FILE)
     {
-        OpenFile *fptr;
+        rb_io_t *fptr;
 
         // Ensure file is open - raise error if not
         GetOpenFile(file, fptr);
@@ -1215,7 +1197,7 @@ ImageList_write(VALUE self, VALUE file)
         add_format_prefix(info, fptr->pathv);
         SetImageInfoFile(info, NULL);
 #else
-        SetImageInfoFile(info, GetReadFile(fptr));
+        SetImageInfoFile(info, rb_io_stdio_file(fptr));
 #endif
     }
     else
@@ -1232,20 +1214,22 @@ ImageList_write(VALUE self, VALUE file)
     for (scene = 0, img = images; img; img = GetNextImageInList(img))
     {
         img->scene = scene++;
-        strcpy(img->filename, info->filename);
+        strlcpy(img->filename, info->filename, sizeof(img->filename));
     }
 
     // Find out if the format supports multi-images files.
     exception = AcquireExceptionInfo();
-    (void) SetImageInfo(info, MagickTrue, exception);
+    SetImageInfo(info, MagickTrue, exception);
     rm_check_exception(exception, images, RetainOnError);
 
     m = GetMagickInfo(info->magick, exception);
     rm_check_exception(exception, images, RetainOnError);
-    (void) DestroyExceptionInfo(exception);
+#if defined(IMAGEMAGICK_6)
+    DestroyExceptionInfo(exception);
+#endif
 
     // Tell WriteImage if we want a multi-images file.
-    if (imagelist_length(self) > 1L && m->adjoin)
+    if (imagelist_length(self) > 1L && GetMagickAdjoin(m))
     {
         info->adjoin = MagickTrue;
     }
@@ -1253,15 +1237,26 @@ ImageList_write(VALUE self, VALUE file)
     for (img = images; img; img = GetNextImageInList(img))
     {
         rm_sync_image_options(img, info);
-        (void) WriteImage(info, img);
+#if defined(IMAGEMAGICK_7)
+        GVL_STRUCT_TYPE(WriteImage) args = { info, img, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(WriteImage), &args);
+        rm_check_exception(exception, img, RetainOnError);
+#else
+        GVL_STRUCT_TYPE(WriteImage) args = { info, img };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(WriteImage), &args);
         // images will be split before raising an exception
         rm_check_image_exception(images, RetainOnError);
+#endif
         if (info->adjoin)
         {
             break;
         }
     }
 
+#if defined(IMAGEMAGICK_7)
+    DestroyExceptionInfo(exception);
+#endif
+
     rm_split(images);
 
     RB_GC_GUARD(info_obj);