rmagick 2.13.2 → 4.2.2

data/ext/RMagick/rmilist.c

@@ -16,7 +16,6 @@ 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);
 
@@ -26,17 +25,15 @@ static VALUE ImageList_new(void);
 
 /**
  * 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
  *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return self
+ * @overload animate(delay)
+ *   @param delay [Numeric] the length of time between each image in an animation
+ *
+ * @return [Magick::ImageList] self
  */
 
 VALUE
@@ -44,8 +41,16 @@ ImageList_animate(int argc, VALUE *argv, VALUE self)
 {
     Image *images;
     Info *info;
-    volatile VALUE info_obj;
+    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,9 +65,7 @@ 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;
@@ -70,30 +73,36 @@ ImageList_animate(int argc, VALUE *argv, VALUE self)
     }
 
     Data_Get_Struct(info_obj, Info, info);
-    (void) AnimateImages(info, images);
-    rm_check_image_exception(images, RetainOnError);
+#if defined(IMAGEMAGICK_7)
+    exception = AcquireExceptionInfo();
+    AnimateImages(info, images, exception);
     rm_split(images);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+#else
+    AnimateImages(info, images);
+    rm_split(images);
+    rm_check_image_exception(images, RetainOnError);
+#endif
+
+    RB_GC_GUARD(info_obj);
 
     return 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)
 {
     Image *images, *new_image;
     unsigned int stack;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     // Convert the image array to an image sequence.
     images = images_from_imagelist(self);
@@ -102,106 +111,184 @@ ImageList_append(VALUE self, VALUE stack_arg)
     // otherwise left-to-right.
     stack = RTEST(stack_arg);
 
-    GetExceptionInfo(&exception);
-    new_image = AppendImages(images, stack, &exception);
+    exception = AcquireExceptionInfo();
+    new_image = AppendImages(images, stack, exception);
     rm_split(images);
-    rm_check_exception(&exception, new_image, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
-
-    rm_ensure_result(new_image);
+    rm_check_exception(exception, new_image, DestroyOnError);
+    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)
 {
     Image *images, *new_image;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     // Convert the images array to an images sequence.
     images = images_from_imagelist(self);
 
-    GetExceptionInfo(&exception);
-    new_image = AverageImages(images, &exception);
-    rm_split(images);
-    rm_check_exception(&exception, new_image, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
+    new_image = EvaluateImages(images, MeanEvaluateOperator, exception);
 
-    rm_ensure_result(new_image);
+    rm_split(images);
+    rm_check_exception(exception, new_image, DestroyOnError);
+    DestroyExceptionInfo(exception);
 
     return rm_image_new(new_image);
 }
 
 
 /**
- * Call CoalesceImages.
+ * Composites a set of images while respecting any page offsets and disposal methods.
  *
- * Ruby usage:
- *   - @verbatim ImageList#coalesce @endverbatim
- *
- * 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)
 {
     Image *images, *new_images;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     // Convert the image array to an image sequence.
     images = images_from_imagelist(self);
 
-    GetExceptionInfo(&exception);
-    new_images = CoalesceImages(images, &exception);
+    exception = AcquireExceptionInfo();
+    new_images = CoalesceImages(images, exception);
     rm_split(images);
-    rm_check_exception(&exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
-
-    rm_ensure_result(new_images);
+    rm_check_exception(exception, new_images, DestroyOnError);
+    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);
+    new_image = CombineImages(images, channel, exception);
+#else
+    new_image = CombineImages(images, colorspace, exception);
+#endif
+
+    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)
 {
-    volatile VALUE source_images;
+    VALUE source_images;
     Image *dest, *source, *new_images;
     RectangleInfo geometry;
     CompositeOperator operator = OverCompositeOp;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     switch (argc)
     {
@@ -222,20 +309,22 @@ 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);
 
-    GetExceptionInfo(&exception);
-    CompositeLayers(new_images, operator, source, geometry.x, geometry.y, &exception);
+    exception = AcquireExceptionInfo();
+    CompositeLayers(new_images, operator, source, geometry.x, geometry.y, exception);
     rm_split(source);
-    rm_check_exception(&exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
+    rm_check_exception(exception, new_images, DestroyOnError);
+    DestroyExceptionInfo(exception);
+
+    RB_GC_GUARD(source_images);
 
     return rm_imagelist_from_images(new_images);
 }
@@ -245,26 +334,24 @@ 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)
 {
     Image *new_images, *images;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     images = images_from_imagelist(self);
-    GetExceptionInfo(&exception);
-    new_images = DeconstructImages(images, &exception);
+    exception = AcquireExceptionInfo();
+#if defined(IMAGEMAGICK_7)
+    new_images = CompareImagesLayers(images, CompareAnyLayer, exception);
+#else
+    new_images = DeconstructImages(images, exception);
+#endif
     rm_split(images);
-    rm_check_exception(&exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
-
-    rm_ensure_result(new_images);
+    rm_check_exception(exception, new_images, DestroyOnError);
+    DestroyExceptionInfo(exception);
 
     return rm_imagelist_from_images(new_images);
 }
@@ -273,18 +360,17 @@ 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)
 {
     Image *images;
     Info *info;
-    volatile VALUE info_obj;
+    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();
@@ -292,10 +378,19 @@ ImageList_display(VALUE self)
 
     // 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);
 
     return self;
 }
@@ -304,179 +399,46 @@ 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)
 {
     Image *images, *new_image;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     images = images_from_imagelist(self);
-    GetExceptionInfo(&exception);
-
-#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);
+    exception = AcquireExceptionInfo();
 
-    rm_ensure_result(new_image);
+    new_image = MergeImageLayers(images, FlattenLayer, exception);
 
-    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);
-
-    // 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);
-    GetExceptionInfo(&exception);
-    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);
+    rm_check_exception(exception, new_image, DestroyOnError);
+    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;
-    volatile VALUE scene, new_imagelist, t;
-    ExceptionInfo exception;
-
-#if defined(HAVE_REMAPIMAGES)
-    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.
-    GetExceptionInfo(&exception);
-
-    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
-    (void) MapImages(new_images, map, dither);
-    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);
-
-    return new_imagelist;
-}
-
-
-/**
- * Call MontageImages.
- *
- * Ruby usage:
- *   - @verbatim ImageList#montage <{parm block}> @endverbatim
+ * Tile one or more thumbnails across an image canvas.
  *
- * Notes:
- *   - Creates Montage object, yields to block if present in Montage object's
- *     scope.
+ * @overload montage
  *
- * @param self this object
- * @return a new image list
+ * @overload montage
+ *   Creates {Magick::ImageList::Montage} object, yields to block
+ *   if present in {Magick::ImageList::Montage} object's scope.
+ *   @yield []
+ * 
+ * @return [Magick::ImageList] a new image list
  */
 VALUE
 ImageList_montage(VALUE self)
 {
-    volatile VALUE montage_obj;
+    VALUE montage_obj;
     Montage *montage;
     Image *new_images, *images;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     // Create a new instance of the Magick::Montage class
     montage_obj = rm_montage_new();
@@ -484,32 +446,41 @@ ImageList_montage(VALUE self)
     {
         // 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);
+        if (rb_proc_arity(rb_block_proc()) == 0)
+        {
+            rb_obj_instance_eval(0, NULL, montage_obj);
+        }
+        else
+        {
+            rb_yield(montage_obj);
+        }
     }
 
     Data_Get_Struct(montage_obj, Montage, 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;
     }
 
-    GetExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
 
     // MontageImage can return more than one image.
-    new_images = MontageImages(images, montage->info, &exception);
+    new_images = MontageImages(images, montage->info, exception);
     rm_split(images);
-    rm_check_exception(&exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
+    rm_check_exception(exception, new_images, DestroyOnError);
+    DestroyExceptionInfo(exception);
 
-    rm_ensure_result(new_images);
+    RB_GC_GUARD(montage_obj);
 
     return rm_imagelist_from_images(new_images);
 }
@@ -517,23 +488,17 @@ 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".
- *
- * Ruby usage:
- *   - @verbatim ImageList#morph(number_images) @endverbatim
- *
- * Notes:
- *   - Sets \@scenes to 0
+ * second by a number of intervening images as specified by "nimages".
  *
- * @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)
 {
     Image *images, *new_images;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
     long number_images;
 
 
@@ -544,14 +509,12 @@ ImageList_morph(VALUE self, VALUE nimages)
         rb_raise(rb_eArgError, "number of intervening images must be > 0");
     }
 
-    GetExceptionInfo(&exception);
     images = images_from_imagelist(self);
-    new_images = MorphImages(images, (unsigned long)number_images, &exception);
+    exception = AcquireExceptionInfo();
+    new_images = MorphImages(images, (unsigned long)number_images, exception);
     rm_split(images);
-    rm_check_exception(&exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
-
-    rm_ensure_result(new_images);
+    rm_check_exception(exception, new_images, DestroyOnError);
+    DestroyExceptionInfo(exception);
 
     return rm_imagelist_from_images(new_images);
 }
@@ -560,151 +523,130 @@ 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)
 {
     Image *images, *new_image;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
-    GetExceptionInfo(&exception);
     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();
+    new_image = MergeImageLayers(images, MosaicLayer, exception);
 
     rm_split(images);
-    rm_check_exception(&exception, new_image, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
-
-    rm_ensure_result(new_image);
+    rm_check_exception(exception, new_image, DestroyOnError);
+    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;
-    ExceptionInfo exception;
+    LayerMethod mthd;
+    ExceptionInfo *exception;
     QuantizeInfo quantize_info;
 
     new_images2 = NULL;     // defeat "unused variable" message
 
-    GetExceptionInfo(&exception);
-#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);
+            new_images = CoalesceImages(images, exception);
             break;
         case DisposeLayer:
-            new_images = DisposeImages(images, &exception);
+            new_images = DisposeImages(images, exception);
             break;
         case OptimizeTransLayer:
             new_images = clone_imagelist(images);
-            OptimizeImageTransparency(new_images, &exception);
+            OptimizeImageTransparency(new_images, exception);
             break;
         case RemoveDupsLayer:
             new_images = clone_imagelist(images);
-            RemoveDuplicateLayers(&new_images, &exception);
+            RemoveDuplicateLayers(&new_images, exception);
             break;
         case RemoveZeroLayer:
             new_images = clone_imagelist(images);
-            RemoveZeroDelayLayers(&new_images, &exception);
+            RemoveZeroDelayLayers(&new_images, exception);
             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);
+            new_images = OptimizeImageLayers(images, exception);
             break;
             // and OptimizeLayer became a "General Purpose, GIF Animation Optimizer" (ref. mogrify.c)
         case OptimizeLayer:
-            new_images = CoalesceImages(images, &exception);
+            new_images = CoalesceImages(images, exception);
             rm_split(images);
-            rm_check_exception(&exception, new_images, DestroyOnError);
-            new_images2 = OptimizeImageLayers(new_images, &exception);
+            rm_check_exception(exception, new_images, DestroyOnError);
+            new_images2 = OptimizeImageLayers(new_images, exception);
             DestroyImageList(new_images);
-            rm_check_exception(&exception, new_images2, DestroyOnError);
+            rm_check_exception(exception, new_images2, DestroyOnError);
             new_images = new_images2;
-            OptimizeImageTransparency(new_images, &exception);
-            rm_check_exception(&exception, new_images, DestroyOnError);
+            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);
+#if defined(IMAGEMAGICK_7)
+            RemapImages(&quantize_info, new_images, NULL, exception);
 #else
-            (void) MapImages(new_images, NULL, 0);
+            RemapImages(&quantize_info, new_images, NULL);
 #endif
             break;
         case OptimizePlusLayer:
-            new_images = OptimizePlusImageLayers(images, &exception);
+            new_images = OptimizePlusImageLayers(images, exception);
             break;
         case CompareAnyLayer:
         case CompareClearLayer:
         case CompareOverlayLayer:
-            new_images = CompareImageLayers(images, mthd, &exception);
+#if defined(IMAGEMAGICK_7)
+            new_images = CompareImagesLayers(images, mthd, exception);
+#else
+            new_images = CompareImageLayers(images, mthd, exception);
+#endif
             break;
-#if defined(HAVE_ENUM_MOSAICLAYER)
         case MosaicLayer:
-            new_images = MergeImageLayers(images, mthd, &exception);
+            new_images = MergeImageLayers(images, mthd, exception);
             break;
-#endif
-#if defined(HAVE_ENUM_FLATTENLAYER)
         case FlattenLayer:
-            new_images = MergeImageLayers(images, mthd, &exception);
+            new_images = MergeImageLayers(images, mthd, exception);
             break;
-#endif
-#if defined(HAVE_ENUM_MERGELAYER)
         case MergeLayer:
-            new_images = MergeImageLayers(images, mthd, &exception);
+            new_images = MergeImageLayers(images, mthd, exception);
             break;
-#endif
-#if defined(HAVE_ENUM_TRIMBOUNDSLAYER)
         case TrimBoundsLayer:
-            new_images = MergeImageLayers(images, mthd, &exception);
+            new_images = MergeImageLayers(images, mthd, exception);
             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);
+    rm_check_exception(exception, new_images, DestroyOnError);
+    DestroyExceptionInfo(exception);
 
     return rm_imagelist_from_images(new_images);
 }
@@ -742,23 +684,24 @@ ImageList_new(void)
 VALUE
 rm_imagelist_from_images(Image *images)
 {
-    volatile VALUE new_imagelist;
-    Image *image;
+    VALUE new_imagelist;
 
-    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);
+
     return new_imagelist;
 }
 
@@ -778,7 +721,7 @@ images_from_imagelist(VALUE imagelist)
 {
     long x, len;
     Image *head = NULL;
-    volatile VALUE images, t;
+    VALUE images, t;
 
     len = check_imagelist_length(imagelist);
 
@@ -789,28 +732,21 @@ images_from_imagelist(VALUE imagelist)
 
         t = rb_ary_entry(images, x);
         image = rm_check_destroyed(t);
+        // avoid a loop in this linked imagelist, issue #202
+        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);
     }
 
-    return head;
-}
+    RB_GC_GUARD(images);
+    RB_GC_GUARD(t);
 
-
-/**
- * \@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 head;
 }
 
 
@@ -825,7 +761,14 @@ imagelist_scene_eq(VALUE imagelist, VALUE scene)
 static long
 imagelist_length(VALUE imagelist)
 {
-    volatile VALUE images = rb_iv_get(imagelist, "@images");
+    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);
+
     return RARRAY_LEN(images);
 }
 
@@ -865,7 +808,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);
 }
 
 
@@ -880,48 +823,39 @@ imagelist_push(VALUE imagelist, VALUE image)
 static Image *
 clone_imagelist(Image *images)
 {
-    Image *new_imagelist = NULL, *image, *clone;
-    ExceptionInfo exception;
+    Image *new_imagelist = NULL, *image;
+    ExceptionInfo *exception;
 
-    GetExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
 
     image = GetFirstImageInList(images);
     while (image)
     {
-        clone = CloneImage(image, 0, 0, MagickTrue, &exception);
-        rm_check_exception(&exception, new_imagelist, DestroyOnError);
+        Image *clone;
+
+        clone = CloneImage(image, 0, 0, MagickTrue, exception);
+        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)
@@ -929,8 +863,8 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
     Image *images, *new_images;
     Image *new_image;
     QuantizeInfo quantize_info;
-    ExceptionInfo exception;
-    volatile VALUE new_imagelist, scene;
+    ExceptionInfo *exception;
+    VALUE new_imagelist, scene;
 
     GetQuantizeInfo(&quantize_info);
 
@@ -941,14 +875,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);
@@ -963,18 +908,21 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
 
 
     // Convert image array to image sequence, clone image sequence.
-    GetExceptionInfo(&exception);
     images = images_from_imagelist(self);
-    new_images = CloneImageList(images, &exception);
+    exception = AcquireExceptionInfo();
+    new_images = CloneImageList(images, exception);
     rm_split(images);
-    rm_check_exception(&exception, new_images, DestroyOnError);
-    (void) DestroyExceptionInfo(&exception);
+    rm_check_exception(exception, new_images, DestroyOnError);
 
     rm_ensure_result(new_images);
 
-
-    (void) QuantizeImages(&quantize_info, new_images);
-    rm_check_exception(&exception, new_images, DestroyOnError);
+#if defined(IMAGEMAGICK_7)
+    QuantizeImages(&quantize_info, new_images, exception);
+#else
+    QuantizeImages(&quantize_info, new_images);
+#endif
+    rm_check_exception(exception, new_images, DestroyOnError);
+    DestroyExceptionInfo(exception);
 
     // Create new ImageList object, convert mapped image sequence to images,
     // append to images array.
@@ -986,42 +934,39 @@ 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);
 
     return new_imagelist;
 }
 
 
 /**
- * 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)
     {
-        volatile VALUE t = rm_cur_image(argv[0]);
+        VALUE t = rm_cur_image(argv[0]);
         remap_image = rm_check_destroyed(t);
+        RB_GC_GUARD(t);
     }
 
     GetQuantizeInfo(&quantize_info);
@@ -1029,7 +974,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)
     {
@@ -1038,48 +985,43 @@ 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();
+    RemapImages(&quantize_info, images, remap_image, exception);
+    rm_split(images);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
 #else
-    (void) AffinityImages(&quantize_info, images, remap_image);
-#endif
-    rm_check_image_exception(images, RetainOnError);
+    RemapImages(&quantize_info, images, remap_image);
     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 []
  *
- * @param self this object
- * @return the blob
+ * @return [String] the blob
  */
 VALUE
 ImageList_to_blob(VALUE self)
 {
     Image *images, *image;
     Info *info;
-    volatile VALUE info_obj;
-    volatile VALUE blob_str;
+    VALUE info_obj;
+    VALUE blob_str;
     void *blob = NULL;
     size_t length = 0;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     info_obj = rm_info_new();
     Data_Get_Struct(info_obj, Info, info);
@@ -1087,16 +1029,16 @@ ImageList_to_blob(VALUE self)
     // Convert the images array to an images sequence.
     images = images_from_imagelist(self);
 
-    GetExceptionInfo(&exception);
-    (void) SetImageInfo(info, MagickTrue, &exception);
-    rm_check_exception(&exception, images, RetainOnError);
+    exception = AcquireExceptionInfo();
+    SetImageInfo(info, MagickTrue, exception);
+    rm_check_exception(exception, images, RetainOnError);
 
     if (*info->magick != '\0')
     {
         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));
         }
     }
 
@@ -1109,16 +1051,16 @@ 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);
-    if (blob && exception.severity >= ErrorException)
+    blob = ImagesToBlob(info, images, &length, exception);
+    if (blob && exception->severity >= ErrorException)
     {
         magick_free((void*)blob);
         blob = NULL;
         length = 0;
     }
     rm_split(images);
-    CHECK_EXCEPTION()
-    (void) DestroyExceptionInfo(&exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
 
 
     if (length == 0 || !blob)
@@ -1129,6 +1071,9 @@ ImageList_to_blob(VALUE self)
     blob_str = rb_str_new(blob, (long)length);
     magick_free((void*)blob);
 
+    RB_GC_GUARD(info_obj);
+    RB_GC_GUARD(blob_str);
+
     return blob_str;
 }
 
@@ -1139,12 +1084,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)
@@ -1152,9 +1092,9 @@ ImageList_write(VALUE self, VALUE file)
     Image *images, *img;
     Info *info;
     const MagickInfo *m;
-    volatile VALUE info_obj;
+    VALUE info_obj;
     unsigned long scene;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
     info_obj = rm_info_new();
     Data_Get_Struct(info_obj, Info, info);
@@ -1162,11 +1102,16 @@ ImageList_write(VALUE self, VALUE file)
 
     if (TYPE(file) == T_FILE)
     {
-        OpenFile *fptr;
+        rb_io_t *fptr;
 
         // Ensure file is open - raise error if not
         GetOpenFile(file, fptr);
-        SetImageInfoFile(info, GetReadFile(fptr));
+#if defined(_WIN32)
+        add_format_prefix(info, fptr->pathv);
+        SetImageInfoFile(info, NULL);
+#else
+        SetImageInfoFile(info, rb_io_stdio_file(fptr));
+#endif
     }
     else
     {
@@ -1182,20 +1127,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.
-    GetExceptionInfo(&exception);
-    (void) SetImageInfo(info, MagickTrue, &exception);
-    rm_check_exception(&exception, images, RetainOnError);
-
-    m = GetMagickInfo(info->magick, &exception);
-    rm_check_exception(&exception, images, RetainOnError);
-    (void) DestroyExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
+    SetImageInfo(info, MagickTrue, exception);
+    rm_check_exception(exception, images, RetainOnError);
+
+    m = GetMagickInfo(info->magick, exception);
+    rm_check_exception(exception, images, RetainOnError);
+#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;
     }
@@ -1203,15 +1150,27 @@ 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)
+        WriteImage(info, img, exception);
+        rm_check_exception(exception, img, RetainOnError);
+#else
+        WriteImage(info, img);
         // 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);
+
     return self;
 }