rmagick 4.2.2 → 5.3.0

data/ext/RMagick/rmimage.c

@@ -29,47 +29,276 @@
     #define magick_module module
 #endif
 
-/** Method that effects an image */
-typedef Image *(effector_t)(const Image *, const double, const double, ExceptionInfo *);
-/** Method that flips an image */
-typedef Image *(flipper_t)(const Image *, ExceptionInfo *);
-/** Method that magnifies an image */
-typedef Image *(magnifier_t)(const Image *, ExceptionInfo *);
-/** Method that reads an image */
-typedef Image *(reader_t)(const Info *, ExceptionInfo *);
-/** Method that scales an image */
-typedef Image *(scaler_t)(const Image *, const size_t, const size_t, ExceptionInfo *);
-/** Method that computes threshold on an image */
-#if defined(IMAGEMAGICK_7)
-    typedef MagickBooleanType (auto_channel_t)(Image *, ExceptionInfo *exception);
-    typedef Image *(channel_method_t)(const Image *, const double, const double, ExceptionInfo *);
-    typedef MagickBooleanType (thresholder_t)(Image *, const char *, ExceptionInfo *);
-#else
-    typedef MagickBooleanType (auto_channel_t)(Image *, const ChannelType);
-    typedef Image *(channel_method_t)(const Image *, const ChannelType, const double, const double, ExceptionInfo *);
-    typedef MagickBooleanType (thresholder_t)(Image *, const char *);
-    #define IsEquivalentImage IsImageSimilar
-    #define OrderedDitherImage OrderedPosterizeImage
-#endif
-/** Method that transforms an image */
-typedef Image *(xformer_t)(const Image *, const RectangleInfo *, ExceptionInfo *);
-
 static VALUE cropper(int, int, VALUE *, VALUE);
-static VALUE effect_image(VALUE, int, VALUE *, effector_t);
-static VALUE flipflop(int, VALUE, flipper_t);
-static VALUE rd_image(VALUE, VALUE, reader_t);
+static VALUE effect_image(VALUE, int, VALUE *, gvl_function_t);
+static VALUE flipflop(int, VALUE, gvl_function_t);
+static VALUE rd_image(VALUE, VALUE, gvl_function_t);
 static VALUE rotate(int, int, VALUE *, VALUE);
-static VALUE scale(int, int, VALUE *, VALUE, scaler_t);
-static VALUE threshold_image(int, VALUE *, VALUE, thresholder_t);
-static VALUE xform_image(int, VALUE, VALUE, VALUE, VALUE, VALUE, xformer_t);
+static VALUE scale(int, int, VALUE *, VALUE, gvl_function_t);
+static VALUE threshold_image(int, VALUE *, VALUE, gvl_function_t);
+static VALUE xform_image(int, VALUE, VALUE, VALUE, VALUE, VALUE, gvl_function_t);
 static VALUE array_from_images(Image *);
-static void call_trace_proc(Image *, const char *);
 static VALUE file_arg_rescue(VALUE, VALUE ATTRIBUTE_UNUSED) ATTRIBUTE_NORETURN;
-static VALUE rm_trace_creation_handle_exception(VALUE, VALUE) ATTRIBUTE_NORETURN;
+static size_t rm_image_memsize(const void *img);
+
+const rb_data_type_t rm_image_data_type = {
+    "Magick::Image",
+    { NULL, rm_image_destroy, rm_image_memsize, },
+    0, 0,
+    RUBY_TYPED_FROZEN_SHAREABLE,
+};
 
 static const char *BlackPointCompensationKey = "PROFILE:black-point-compensation";
 
 
+DEFINE_GVL_STUB4(AdaptiveBlurImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(AdaptiveResizeImage, const Image *, const size_t, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB4(AdaptiveSharpenImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(AdaptiveThresholdImage, const Image *, const size_t, const size_t, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(AffineTransformImage, const Image *, const AffineMatrix *, ExceptionInfo *);
+DEFINE_GVL_STUB2(Base64Decode, const char *, size_t *);
+DEFINE_GVL_STUB4(BlobToImage, const ImageInfo *, const void *, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB3(BlueShiftImage, const Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(BlurImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(CharcoalImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(ChopImage, const Image *, const RectangleInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(ColorMatrixImage, const Image *, const KernelInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(CropImage, const Image *, const RectangleInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(DecipherImage, Image *, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB3(DeskewImage, const Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB2(DespeckleImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB6(DistortImage, const Image *, DistortMethod, const size_t, const double *, MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB3(EdgeImage, const Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(EmbossImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(EncipherImage, Image *, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB2(EnhanceImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(ExcerptImage, const Image *, const RectangleInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB9(ExportImagePixels, const Image *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *, ExceptionInfo *);
+DEFINE_GVL_STUB3(ExtentImage, const Image *, const RectangleInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB2(FlipImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(FlopImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB4(GaussianBlurImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB6(GetAuthenticPixels, Image *, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB2(GetImageDepth, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(GetImageHistogram, const Image *, size_t *, ExceptionInfo *);
+DEFINE_GVL_STUB3(GetNumberColors, const Image *, FILE *, ExceptionInfo *);
+DEFINE_GVL_STUB6(GetVirtualPixels, const Image *, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB4(ImageToBlob, const ImageInfo *, Image *, size_t *, ExceptionInfo *);
+DEFINE_GVL_STUB6(LiquidRescaleImage, const Image *, const size_t, const size_t, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB2(MagnifyImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(MinifyImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB5(MotionBlurImage, const Image *, const double, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB2(PingImage, const ImageInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(PreviewImage, const Image *, const PreviewType, ExceptionInfo *);
+DEFINE_GVL_STUB2(ReadImage, const ImageInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB4(RollImage, const Image *, const ssize_t, const ssize_t, ExceptionInfo *);
+DEFINE_GVL_STUB3(RotateImage, const Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(SampleImage, const Image *, const size_t, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB4(ScaleImage, const Image *, const size_t, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB3(SepiaToneImage, const Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(ShadeImage, const Image *, const MagickBooleanType, const double, const double,ExceptionInfo *);
+DEFINE_GVL_STUB6(ShadowImage, const Image *, const double, const double, const ssize_t, const ssize_t,  ExceptionInfo *);
+DEFINE_GVL_STUB4(SharpenImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(ShaveImage, const Image *, const RectangleInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB4(ShearImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(SketchImage, const Image *, const double, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(SpliceImage, const Image *, const RectangleInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB5(StatisticImage, const Image *, const StatisticType, const size_t, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB3(SteganoImage, const Image *, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(StereoImage, const Image *, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(SyncAuthenticPixels, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB4(ThumbnailImage, const Image *, const size_t, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB2(TransposeImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(TransverseImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(TrimImage, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(UniqueImageColors, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB6(UnsharpMaskImage, const Image *, const double, const double, const double, const double,  ExceptionInfo *);
+DEFINE_GVL_STUB6(VignetteImage, const Image *, const double, const double, const ssize_t, const ssize_t, ExceptionInfo *);
+#if defined(IMAGEMAGICK_7)
+DEFINE_GVL_STUB4(AddNoiseImage, const Image *, const NoiseType, const double, ExceptionInfo *);
+DEFINE_GVL_STUB2(AutoGammaImage, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB2(AutoLevelImage, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(BilevelImage, Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(BlackThresholdImage, Image *, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB4(BorderImage, const Image *, const RectangleInfo *, const CompositeOperator, ExceptionInfo *);
+DEFINE_GVL_STUB4(ClutImage, Image *, const Image *, const PixelInterpolateMethod, ExceptionInfo *);
+DEFINE_GVL_STUB4(ColorizeImage, const Image *, const char *, const PixelInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB5(CompareImages, Image *, const Image *, const MetricType, double *, ExceptionInfo *);
+DEFINE_GVL_STUB7(CompositeImage, Image *, const Image *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t, ExceptionInfo *);
+DEFINE_GVL_STUB2(CompressImageColormap, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB4(ContrastStretchImage, Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(ConvolveImage, const Image *, const KernelInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(CycleColormapImage, Image *, const ssize_t, ExceptionInfo *);
+DEFINE_GVL_STUB4(DrawAffineImage, Image *, const Image *, const AffineMatrix *, ExceptionInfo *);
+DEFINE_GVL_STUB2(EqualizeImage, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB4(EvaluateImage, Image *, const MagickEvaluateOperator, const double, ExceptionInfo *);
+DEFINE_GVL_STUB7(FloodfillPaintImage, Image *, const DrawInfo *, const PixelInfo *, const ssize_t, const ssize_t, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB4(FrameImage, const Image *, const FrameInfo *, const CompositeOperator, ExceptionInfo *);
+DEFINE_GVL_STUB5(FunctionImage, Image *, const MagickFunction, const size_t, const double *, ExceptionInfo *);
+DEFINE_GVL_STUB3(FxImage, const Image *, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB3(GammaImage, Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(GetImageDistortion, Image *, const Image *, const MetricType, double *, ExceptionInfo *);
+DEFINE_GVL_STUB3(GetImageEntropy, const Image *, double *, ExceptionInfo *);
+DEFINE_GVL_STUB4(GetImageExtrema, const Image *, size_t *, size_t *, ExceptionInfo *);
+DEFINE_GVL_STUB3(GetImageMask, const Image *, const PixelMask, ExceptionInfo *);
+DEFINE_GVL_STUB4(GetImageMean, const Image *, double *, double *, ExceptionInfo *);
+DEFINE_GVL_STUB4(ImplodeImage, const Image *, const double, const PixelInterpolateMethod, ExceptionInfo *);
+DEFINE_GVL_STUB9(ImportImagePixels, Image *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *, ExceptionInfo *);
+DEFINE_GVL_STUB5(IsEquivalentImage, const Image *, const Image *, ssize_t *, ssize_t *, ExceptionInfo *);
+DEFINE_GVL_STUB5(LevelImage, Image *, const double, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(LevelImageColors, Image *, const PixelInfo *, const PixelInfo *, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB5(LevelizeImage, Image *, const double, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(LinearStretchImage, Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(ModulateImage, Image *, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB5(MorphologyImage, const Image *, const MorphologyMethod, const ssize_t, const KernelInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(NegateImage, Image *, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB2(NormalizeImage, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB4(OilPaintImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(OpaquePaintImage, Image *, const PixelInfo *, const PixelInfo *, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB3(OrderedDitherImage, Image *, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB6(PolaroidImage, const Image *, const DrawInfo *, const char *, const double, const PixelInterpolateMethod, ExceptionInfo *);
+DEFINE_GVL_STUB4(PosterizeImage, Image *, const size_t, const DitherMethod, ExceptionInfo *);
+DEFINE_GVL_STUB5(ProfileImage, Image *, const char *, const void *, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB3(QuantizeImage, const QuantizeInfo *, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB4(RaiseImage, Image *, const RectangleInfo *, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB4(RandomThresholdImage, Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(RemapImage, const QuantizeInfo *, Image *, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB5(ResampleImage, const Image *, const double, const double, const FilterType, ExceptionInfo *);
+DEFINE_GVL_STUB5(ResizeImage, const Image *, const size_t, const size_t, const FilterType, ExceptionInfo *);
+DEFINE_GVL_STUB6(SegmentImage, Image *, const ColorspaceType, const MagickBooleanType, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(SelectiveBlurImage, const Image *, const double, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(SeparateImage, const Image *, const ChannelType, ExceptionInfo *);
+DEFINE_GVL_STUB2(SeparateImages, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(SetImageAlphaChannel, Image *, const AlphaChannelOption, ExceptionInfo *);
+DEFINE_GVL_STUB2(SetImageBackgroundColor, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(SetImageDepth, Image *, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB4(SetImageExtent, Image *, const size_t, const size_t, ExceptionInfo *);
+DEFINE_GVL_STUB4(SetImageMask, Image *, const PixelMask, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(SetImageStorageClass, Image *, const ClassType, ExceptionInfo *);
+DEFINE_GVL_STUB5(SigmoidalContrastImage, Image *, const MagickBooleanType, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB2(SignatureImage, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(SolarizeImage, Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(SparseColorImage, const Image *, const SparseColorMethod, const size_t, const double *, ExceptionInfo *);
+DEFINE_GVL_STUB4(SpreadImage, const Image *, const PixelInterpolateMethod, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(SwirlImage, const Image *, double, const PixelInterpolateMethod, ExceptionInfo *);
+DEFINE_GVL_STUB2(SyncImage, Image *, ExceptionInfo *);
+DEFINE_GVL_STUB4(TintImage, const Image *, const char *, const PixelInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(TransformImageColorspace, Image *, const ColorspaceType, ExceptionInfo *);
+DEFINE_GVL_STUB5(TransparentPaintImage, Image *, const PixelInfo *, const Quantum, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB6(TransparentPaintImageChroma, Image *, const PixelInfo *, const PixelInfo *, const Quantum, const MagickBooleanType, ExceptionInfo *);
+DEFINE_GVL_STUB5(WaveImage, const Image *, const double, const double, const PixelInterpolateMethod, ExceptionInfo *);
+DEFINE_GVL_STUB3(WhiteThresholdImage, Image *, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB3(WriteImage, const ImageInfo *, Image *, ExceptionInfo *);
+#else
+DEFINE_GVL_STUB5(AdaptiveBlurImageChannel, const Image *, const ChannelType, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(AdaptiveSharpenImageChannel, const Image *, const ChannelType, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(AddNoiseImage, const Image *, const NoiseType, ExceptionInfo *);
+DEFINE_GVL_STUB4(AddNoiseImageChannel, const Image *, const ChannelType, const NoiseType, ExceptionInfo *);
+DEFINE_GVL_STUB2(AutoGammaImageChannel, Image *, const ChannelType);
+DEFINE_GVL_STUB2(AutoLevelImageChannel,Image *, const ChannelType);
+DEFINE_GVL_STUB3(BilevelImageChannel, Image *, const ChannelType,const double);
+DEFINE_GVL_STUB2(BlackThresholdImage, Image *, const char *);
+DEFINE_GVL_STUB5(BlurImageChannel, const Image *, const ChannelType, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(BorderImage, const Image *, const RectangleInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB3(ClutImageChannel, Image *, const ChannelType, const Image *);
+DEFINE_GVL_STUB4(ColorizeImage, const Image *, const char *, const PixelPacket, ExceptionInfo *);
+DEFINE_GVL_STUB6(CompareImageChannels, Image *, const Image *, const ChannelType, const MetricType, double *, ExceptionInfo *);
+DEFINE_GVL_STUB5(CompositeImage, Image *, const CompositeOperator, const Image *, const ssize_t, const ssize_t);
+DEFINE_GVL_STUB6(CompositeImageChannel, Image *, const ChannelType, const CompositeOperator, const Image *, const ssize_t, const ssize_t);
+DEFINE_GVL_STUB1(CompressImageColormap, Image *);
+DEFINE_GVL_STUB4(ContrastStretchImageChannel, Image *, const ChannelType, const double, const double);
+DEFINE_GVL_STUB4(ConvolveImage, const Image *, const size_t, const double *, ExceptionInfo *);
+DEFINE_GVL_STUB5(ConvolveImageChannel, const Image *, const ChannelType, const size_t, const double *, ExceptionInfo *);
+DEFINE_GVL_STUB2(CycleColormapImage, Image *, const ssize_t);
+DEFINE_GVL_STUB3(DrawAffineImage, Image *, const Image *, const AffineMatrix *);
+DEFINE_GVL_STUB1(EqualizeImage, Image *);
+DEFINE_GVL_STUB2(EqualizeImageChannel, Image *, const ChannelType);
+DEFINE_GVL_STUB5(EvaluateImageChannel, Image *, const ChannelType, const MagickEvaluateOperator, const double, ExceptionInfo *);
+DEFINE_GVL_STUB7(FloodfillPaintImage, Image *, const ChannelType, const DrawInfo *, const MagickPixelPacket *, const ssize_t, const ssize_t, const MagickBooleanType);
+DEFINE_GVL_STUB3(FrameImage, const Image *, const FrameInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB6(FunctionImageChannel, Image *, const ChannelType, const MagickFunction, const size_t, const double *, ExceptionInfo *);
+DEFINE_GVL_STUB4(FxImageChannel, const Image *, const ChannelType, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB3(GammaImageChannel, Image *, const ChannelType, const double);
+DEFINE_GVL_STUB5(GaussianBlurImageChannel, const Image *, const ChannelType, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(GetImageChannelDepth, const Image *, const ChannelType, ExceptionInfo *);
+DEFINE_GVL_STUB6(GetImageChannelDistortion, Image *, const Image *, const ChannelType, const MetricType, double *, ExceptionInfo *);
+DEFINE_GVL_STUB5(GetImageChannelExtrema, const Image *, const ChannelType, size_t *, size_t *, ExceptionInfo *);
+DEFINE_GVL_STUB5(GetImageChannelMean, const Image *, const ChannelType, double *, double *, ExceptionInfo *);
+DEFINE_GVL_STUB2(GetImageClipMask, const Image *, ExceptionInfo *);
+DEFINE_GVL_STUB3(ImplodeImage, const Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB8(ImportImagePixels, Image *, const ssize_t, const ssize_t, const size_t,const size_t,const char *, const StorageType, const void *);
+DEFINE_GVL_STUB5(IsImageSimilar, const Image *, const Image *, ssize_t *, ssize_t *, ExceptionInfo *);
+DEFINE_GVL_STUB2(IsImagesEqual, Image *, const Image *);
+DEFINE_GVL_STUB5(LevelColorsImageChannel, Image *, const ChannelType, const MagickPixelPacket *, const MagickPixelPacket *, const MagickBooleanType);
+DEFINE_GVL_STUB2(LevelImage, Image *, const char *);
+DEFINE_GVL_STUB5(LevelImageChannel, Image *, const ChannelType, const double, const double, const double);
+DEFINE_GVL_STUB5(LevelizeImageChannel, Image *, const ChannelType, const double, const double, const double);
+DEFINE_GVL_STUB3(LinearStretchImage, Image *, const double, const double);
+DEFINE_GVL_STUB2(ModulateImage, Image *, const char *);
+DEFINE_GVL_STUB6(MorphologyImageChannel, const Image *, const ChannelType, const MorphologyMethod, const ssize_t, const KernelInfo *, ExceptionInfo *);
+DEFINE_GVL_STUB2(NegateImage, Image *, const MagickBooleanType);
+DEFINE_GVL_STUB3(NegateImageChannel, Image *, const ChannelType, const MagickBooleanType);
+DEFINE_GVL_STUB1(NormalizeImage, Image *);
+DEFINE_GVL_STUB2(NormalizeImageChannel, Image *, const ChannelType);
+DEFINE_GVL_STUB3(OilPaintImage, const Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(OpaquePaintImageChannel, Image *, const ChannelType, const MagickPixelPacket *, const MagickPixelPacket *, const MagickBooleanType);
+DEFINE_GVL_STUB3(OrderedPosterizeImage, Image *, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB4(PolaroidImage, const Image *, const DrawInfo *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(PosterizeImage, Image *, const size_t, const MagickBooleanType);
+DEFINE_GVL_STUB5(ProfileImage, Image *, const char *, const void *, const size_t, const MagickBooleanType);
+DEFINE_GVL_STUB2(QuantizeImage, const QuantizeInfo *, Image *);
+DEFINE_GVL_STUB3(RaiseImage, Image *, const RectangleInfo *, const MagickBooleanType);
+DEFINE_GVL_STUB4(RandomThresholdImageChannel, Image *, const ChannelType, const char *, ExceptionInfo *);
+DEFINE_GVL_STUB3(RemapImage, const QuantizeInfo *, Image *, const Image *);
+DEFINE_GVL_STUB6(ResampleImage, const Image *, const double, const double, const FilterTypes, const double, ExceptionInfo *);
+DEFINE_GVL_STUB6(ResizeImage, const Image *, const size_t, const size_t, const FilterTypes, const double, ExceptionInfo *);
+DEFINE_GVL_STUB5(SegmentImage, Image *, const ColorspaceType, const MagickBooleanType, const double, const double);
+DEFINE_GVL_STUB6(SelectiveBlurImageChannel, const Image *, const ChannelType, const double, const double,  const double, ExceptionInfo *);
+DEFINE_GVL_STUB2(SeparateImageChannel, Image *, const ChannelType);
+DEFINE_GVL_STUB3(SeparateImages, const Image *, const ChannelType, ExceptionInfo *);
+DEFINE_GVL_STUB2(SetImageAlphaChannel, Image *, const AlphaChannelType);
+DEFINE_GVL_STUB1(SetImageBackgroundColor, Image *);
+DEFINE_GVL_STUB3(SetImageChannelDepth, Image *, const ChannelType, const size_t);
+DEFINE_GVL_STUB2(SetImageClipMask, Image *, const Image *);
+DEFINE_GVL_STUB2(SetImageDepth, Image *, const size_t);
+DEFINE_GVL_STUB3(SetImageExtent, Image *, const size_t, const size_t);
+DEFINE_GVL_STUB2(SetImageMask, Image *, const Image *);
+DEFINE_GVL_STUB2(SetImageStorageClass, Image *, const ClassType);
+DEFINE_GVL_STUB5(SharpenImageChannel, const Image *, const ChannelType, const double, const double,  ExceptionInfo *);
+DEFINE_GVL_STUB5(SigmoidalContrastImageChannel, Image *, const ChannelType, const MagickBooleanType, const double, const double);
+DEFINE_GVL_STUB1(SignatureImage, Image *);
+DEFINE_GVL_STUB2(SolarizeImage, Image *, const double);
+DEFINE_GVL_STUB6(SparseColorImage, const Image *, const ChannelType, const SparseColorMethod, const size_t, const double *, ExceptionInfo *);
+DEFINE_GVL_STUB3(SpreadImage, const Image *, const double, ExceptionInfo *);
+DEFINE_GVL_STUB3(SwirlImage, const Image *, double, ExceptionInfo *);
+DEFINE_GVL_STUB1(SyncImage, Image *);
+DEFINE_GVL_STUB4(TintImage, const Image *, const char *, const PixelPacket, ExceptionInfo *);
+DEFINE_GVL_STUB2(TransformImageColorspace, Image *, const ColorspaceType);
+DEFINE_GVL_STUB4(TransparentPaintImage, Image *, const MagickPixelPacket *, const Quantum, const MagickBooleanType);
+DEFINE_GVL_STUB5(TransparentPaintImageChroma, Image *, const MagickPixelPacket *, const MagickPixelPacket *, const Quantum, const MagickBooleanType);
+DEFINE_GVL_STUB7(UnsharpMaskImageChannel, const Image *, const ChannelType, const double, const double,  const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB4(WaveImage, const Image *, const double, const double, ExceptionInfo *);
+DEFINE_GVL_STUB2(WhiteThresholdImage, Image *, const char *);
+DEFINE_GVL_STUB2(WriteImage, const ImageInfo *, Image *);
+#endif
+
+#if defined(HAVE_GETIMAGECHANNELENTROPY)
+DEFINE_GVL_STUB4(GetImageChannelEntropy, const Image *, const ChannelType, double *, ExceptionInfo *);
+#endif
+
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+DEFINE_GVL_STUB3(RotationalBlurImage, const Image *, const double, ExceptionInfo *);
+#else
+DEFINE_GVL_STUB3(RadialBlurImage, const Image *, const double, ExceptionInfo *);
+#endif
+
+#if defined(IMAGEMAGICK_7)
+#elif defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+DEFINE_GVL_STUB4(RotationalBlurImageChannel, const Image *, const ChannelType, const double, ExceptionInfo *);
+#else
+DEFINE_GVL_STUB4(RadialBlurImageChannel, const Image *, const ChannelType, const double, ExceptionInfo *);
+#endif
+
 /**
  * Returns the alpha value from the hash.
  *
@@ -100,6 +329,9 @@ get_named_alpha_value(VALUE hash)
 }
 
 
+// aliases for common use of structure types; AdaptiveBlurImage, AdaptiveSharpenImage
+typedef GVL_STRUCT_TYPE(AdaptiveBlurImage) GVL_STRUCT_TYPE(adaptive_method);
+
 /**
  * Call Adaptive(Blur|Sharpen)Image.
  *
@@ -112,8 +344,7 @@ get_named_alpha_value(VALUE hash)
  * @return a new image
  */
 static VALUE
-adaptive_method(int argc, VALUE *argv, VALUE self,
-                Image *fp(const Image *, const double, const double, ExceptionInfo *))
+adaptive_method(int argc, VALUE *argv, VALUE self, gvl_function_t fp)
 {
     Image *image, *new_image;
     double radius = 0.0;
@@ -137,7 +368,8 @@ adaptive_method(int argc, VALUE *argv, VALUE self,
 
     exception = AcquireExceptionInfo();
 
-    new_image = (fp)(image, radius, sigma, exception);
+    GVL_STRUCT_TYPE(adaptive_method) args = { image, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -145,6 +377,12 @@ adaptive_method(int argc, VALUE *argv, VALUE self,
 }
 
 
+// aliases for common use of structure types; AdaptiveBlurImage, AdaptiveSharpenImage, AdaptiveBlurImageChannel, AdaptiveSharpenImageChannel
+#if defined(IMAGEMAGICK_7)
+typedef GVL_STRUCT_TYPE(AdaptiveBlurImage) GVL_STRUCT_TYPE(adaptive_channel_method);
+#else
+typedef GVL_STRUCT_TYPE(AdaptiveBlurImageChannel) GVL_STRUCT_TYPE(adaptive_channel_method);
+#endif
 
 /**
  * Call Adaptive(Blur|Sharpen)ImageChannel.
@@ -158,7 +396,7 @@ adaptive_method(int argc, VALUE *argv, VALUE self,
  * @return a new image
  */
 static VALUE
-adaptive_channel_method(int argc, VALUE *argv, VALUE self, channel_method_t fp)
+adaptive_channel_method(int argc, VALUE *argv, VALUE self, gvl_function_t fp)
 {
     Image *image, *new_image;
     double radius = 0.0;
@@ -186,11 +424,13 @@ adaptive_channel_method(int argc, VALUE *argv, VALUE self, channel_method_t fp)
 
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = (fp)(image, radius, sigma, exception);
+    GVL_STRUCT_TYPE(adaptive_channel_method) args = { image, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #else
-    new_image = (fp)(image, channels, radius, sigma, exception);
+    GVL_STRUCT_TYPE(adaptive_channel_method) args = { image, channels, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
 #endif
 
     rm_check_exception(exception, new_image, DestroyOnError);
@@ -214,11 +454,10 @@ adaptive_channel_method(int argc, VALUE *argv, VALUE self, channel_method_t fp)
 VALUE
 Image_adaptive_blur(int argc, VALUE *argv, VALUE self)
 {
-    return adaptive_method(argc, argv, self, AdaptiveBlurImage);
+    return adaptive_method(argc, argv, self, GVL_FUNC(AdaptiveBlurImage));
 }
 
 
-
 /**
  * The same as {Magick::Image#adaptive_blur} except only the specified channels are blurred.
  *
@@ -238,9 +477,9 @@ VALUE
 Image_adaptive_blur_channel(int argc, VALUE *argv, VALUE self)
 {
 #if defined(IMAGEMAGICK_7)
-    return adaptive_channel_method(argc, argv, self, AdaptiveBlurImage);
+    return adaptive_channel_method(argc, argv, self, GVL_FUNC(AdaptiveBlurImage));
 #else
-    return adaptive_channel_method(argc, argv, self, AdaptiveBlurImageChannel);
+    return adaptive_channel_method(argc, argv, self, GVL_FUNC(AdaptiveBlurImageChannel));
 #endif
 }
 
@@ -296,7 +535,8 @@ Image_adaptive_resize(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = AdaptiveResizeImage(image, columns, rows, exception);
+    GVL_STRUCT_TYPE(AdaptiveResizeImage) args = { image, columns, rows, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AdaptiveResizeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -304,7 +544,6 @@ Image_adaptive_resize(int argc, VALUE *argv, VALUE self)
 }
 
 
-
 /**
  * Adaptively sharpens the image by sharpening more intensely near image edges and less intensely
  * far from edges.
@@ -323,11 +562,10 @@ Image_adaptive_resize(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_adaptive_sharpen(int argc, VALUE *argv, VALUE self)
 {
-    return adaptive_method(argc, argv, self, AdaptiveSharpenImage);
+    return adaptive_method(argc, argv, self, GVL_FUNC(AdaptiveSharpenImage));
 }
 
 
-
 /**
  * The same as {Magick::Image#adaptive_sharpen} except only the specified channels are sharpened.
  *
@@ -347,14 +585,13 @@ VALUE
 Image_adaptive_sharpen_channel(int argc, VALUE *argv, VALUE self)
 {
 #if defined(IMAGEMAGICK_7)
-    return adaptive_channel_method(argc, argv, self, AdaptiveSharpenImage);
+    return adaptive_channel_method(argc, argv, self, GVL_FUNC(AdaptiveSharpenImage));
 #else
-    return adaptive_channel_method(argc, argv, self, AdaptiveSharpenImageChannel);
+    return adaptive_channel_method(argc, argv, self, GVL_FUNC(AdaptiveSharpenImageChannel));
 #endif
 }
 
 
-
 /**
  * Selects an individual threshold for each pixel based on the range of intensity values in its
  * local neighborhood. This allows for thresholding of an image whose global intensity histogram
@@ -391,7 +628,8 @@ Image_adaptive_threshold(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = AdaptiveThresholdImage(image, width, height, offset, exception);
+    GVL_STRUCT_TYPE(AdaptiveThresholdImage) args = { image, width, height, offset, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AdaptiveThresholdImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -430,17 +668,21 @@ Image_add_compose_mask(VALUE self, VALUE mask)
     clip_mask = rm_clone_image(mask_image);
 
     exception = AcquireExceptionInfo();
-    NegateImage(clip_mask, MagickFalse, exception);
+    GVL_STRUCT_TYPE(NegateImage) args_NegateImage = { clip_mask, MagickFalse, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NegateImage), &args_NegateImage);
     rm_check_exception(exception, clip_mask, DestroyOnError);
-    SetImageMask(image, CompositePixelMask, clip_mask, exception);
+    GVL_STRUCT_TYPE(SetImageMask) args_SetImageMask = { image, CompositePixelMask, clip_mask, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageMask), &args_SetImageMask);
     DestroyImage(clip_mask);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
     // Delete any previously-existing mask image.
     // Store a clone of the new mask image.
-    SetImageMask(image, mask_image);
-    NegateImage(image->mask, MagickFalse);
+    GVL_STRUCT_TYPE(SetImageMask) args_SetImageMask = { image, mask_image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageMask), &args_SetImageMask);
+    GVL_STRUCT_TYPE(NegateImage) args_NegateImage = { image->mask, MagickFalse };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NegateImage), &args_NegateImage);
 
     // Since both Set and GetImageMask clone the mask image I don't see any
     // way to negate the mask without referencing it directly. Sigh.
@@ -469,10 +711,11 @@ Image_add_noise(VALUE self, VALUE noise)
 
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
-    new_image = AddNoiseImage(image, noise_type, 1.0, exception);
+    GVL_STRUCT_TYPE(AddNoiseImage) args = { image, noise_type, 1.0, exception };
 #else
-    new_image = AddNoiseImage(image, noise_type, exception);
+    GVL_STRUCT_TYPE(AddNoiseImage) args = { image, noise_type, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AddNoiseImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -519,10 +762,12 @@ Image_add_noise_channel(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = AddNoiseImage(image, noise_type, 1.0, exception);
+    GVL_STRUCT_TYPE(AddNoiseImage) args = { image, noise_type, 1.0, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AddNoiseImage), &args);
     END_CHANNEL_MASK(new_image);
 #else
-    new_image = AddNoiseImageChannel(image, channels, noise_type, exception);
+    GVL_STRUCT_TYPE(AddNoiseImageChannel) args = { image, channels, noise_type, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AddNoiseImageChannel), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -580,10 +825,12 @@ Image_add_profile(VALUE self, VALUE name)
         if (profile)
         {
 #if defined(IMAGEMAGICK_7)
-            ProfileImage(image, profile_name, GetStringInfoDatum(profile), GetStringInfoLength(profile), exception);
+            GVL_STRUCT_TYPE(ProfileImage) args = { image, profile_name, GetStringInfoDatum(profile), GetStringInfoLength(profile), exception };
+            CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ProfileImage), &args);
             if (rm_should_raise_exception(exception, RetainExceptionRetention))
 #else
-            ProfileImage(image, profile_name, GetStringInfoDatum(profile), GetStringInfoLength(profile), MagickFalse);
+            GVL_STRUCT_TYPE(ProfileImage) args = { image, profile_name, GetStringInfoDatum(profile), GetStringInfoLength(profile), MagickFalse };
+            CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ProfileImage), &args);
             if (rm_should_raise_exception(&image->exception, RetainExceptionRetention))
 #endif
             {
@@ -654,11 +901,13 @@ Image_alpha(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SetImageAlphaChannel(image, alpha, exception);
+    GVL_STRUCT_TYPE(SetImageAlphaChannel) args = { image, alpha, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageAlphaChannel), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    SetImageAlphaChannel(image, alpha);
+    GVL_STRUCT_TYPE(SetImageAlphaChannel) args = { image, alpha };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageAlphaChannel), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -703,7 +952,8 @@ Image_affine_transform(VALUE self, VALUE affine)
     Export_AffineMatrix(&matrix, affine);
 
     exception = AcquireExceptionInfo();
-    new_image = AffineTransformImage(image, &matrix, exception);
+    GVL_STRUCT_TYPE(AffineTransformImage) args = { image, &matrix, exception };
+    new_image = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(AffineTransformImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -825,6 +1075,9 @@ Image_aset(VALUE self, VALUE key_arg, VALUE attr_arg)
 }
 
 
+// aliases for common use of structure types; TransposeImage, TransverseImage
+typedef GVL_STRUCT_TYPE(TransposeImage) GVL_STRUCT_TYPE(crisscross);
+
 /**
  * Handle #transverse, #transform methods.
  *
@@ -836,15 +1089,16 @@ Image_aset(VALUE self, VALUE key_arg, VALUE attr_arg)
  * @return self if bang, otherwise a new image
  */
 static VALUE
-crisscross(int bang, VALUE self, Image *fp(const Image *, ExceptionInfo *))
+crisscross(int bang, VALUE self, gvl_function_t fp)
 {
     Image *image, *new_image;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
     exception = AcquireExceptionInfo();
 
-    new_image = (fp)(image, exception);
+    GVL_STRUCT_TYPE(crisscross) args = { image, exception };
+    new_image = CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -861,6 +1115,12 @@ crisscross(int bang, VALUE self, Image *fp(const Image *, ExceptionInfo *))
 }
 
 
+// aliases for common use of structure types; AutoGammaImage, AutoLevelImage, AutoGammaImageChannel, AutoLevelImageChannel
+#if defined(IMAGEMAGICK_7)
+typedef GVL_STRUCT_TYPE(AutoGammaImage) GVL_STRUCT_TYPE(auto_channel);
+#else
+typedef GVL_STRUCT_TYPE(AutoGammaImageChannel) GVL_STRUCT_TYPE(auto_channel);
+#endif
 
 /**
  * Handle #auto_gamma_channel, #auto_level_channel methods.
@@ -874,7 +1134,7 @@ crisscross(int bang, VALUE self, Image *fp(const Image *, ExceptionInfo *))
  * @return a new image
  */
 static VALUE
-auto_channel(int argc, VALUE *argv, VALUE self, auto_channel_t fp)
+auto_channel(int argc, VALUE *argv, VALUE self, gvl_function_t fp)
 {
     Image *image, *new_image;
     ChannelType channels;
@@ -895,12 +1155,14 @@ auto_channel(int argc, VALUE *argv, VALUE self, auto_channel_t fp)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    (fp)(new_image, exception);
+    GVL_STRUCT_TYPE(auto_channel) args = { new_image, exception };
+    CALL_FUNC_WITHOUT_GVL(fp, &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    (fp)(new_image, channels);
+    GVL_STRUCT_TYPE(auto_channel) args = { new_image, channels };
+    CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -923,9 +1185,9 @@ VALUE
 Image_auto_gamma_channel(int argc, VALUE *argv, VALUE self)
 {
 #if defined(IMAGEMAGICK_7)
-    return auto_channel(argc, argv, self, AutoGammaImage);
+    return auto_channel(argc, argv, self, GVL_FUNC(AutoGammaImage));
 #else
-    return auto_channel(argc, argv, self, AutoGammaImageChannel);
+    return auto_channel(argc, argv, self, GVL_FUNC(AutoGammaImageChannel));
 #endif
 }
 
@@ -945,9 +1207,9 @@ VALUE
 Image_auto_level_channel(int argc, VALUE *argv, VALUE self)
 {
 #if defined(IMAGEMAGICK_7)
-    return auto_channel(argc, argv, self, AutoLevelImage);
+    return auto_channel(argc, argv, self, GVL_FUNC(AutoLevelImage));
 #else
-    return auto_channel(argc, argv, self, AutoLevelImageChannel);
+    return auto_channel(argc, argv, self, GVL_FUNC(AutoLevelImageChannel));
 #endif
 }
 
@@ -970,12 +1232,12 @@ auto_orient(int bang, VALUE self)
     VALUE new_image;
     VALUE degrees[1];
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     switch (image->orientation)
     {
         case TopRightOrientation:
-            new_image = flipflop(bang, self, FlopImage);
+            new_image = flipflop(bang, self, GVL_FUNC(FlopImage));
             break;
 
         case BottomRightOrientation:
@@ -984,11 +1246,11 @@ auto_orient(int bang, VALUE self)
             break;
 
         case BottomLeftOrientation:
-            new_image = flipflop(bang, self, FlipImage);
+            new_image = flipflop(bang, self, GVL_FUNC(FlipImage));
             break;
 
         case LeftTopOrientation:
-            new_image = crisscross(bang, self, TransposeImage);
+            new_image = crisscross(bang, self, GVL_FUNC(TransposeImage));
             break;
 
         case RightTopOrientation:
@@ -997,7 +1259,7 @@ auto_orient(int bang, VALUE self)
             break;
 
         case RightBottomOrientation:
-            new_image = crisscross(bang, self, TransverseImage);
+            new_image = crisscross(bang, self, GVL_FUNC(TransverseImage));
             break;
 
         case LeftBottomOrientation:
@@ -1011,7 +1273,7 @@ auto_orient(int bang, VALUE self)
     }
 
 
-    Data_Get_Struct(new_image, Image, image);
+    TypedData_Get_Struct(new_image, Image, &rm_image_data_type, image);
     image->orientation = TopLeftOrientation;
 
     RB_GC_GUARD(new_image);
@@ -1230,12 +1492,14 @@ Image_bilevel_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    BilevelImage(new_image, threshold, exception);
+    GVL_STRUCT_TYPE(BilevelImage) args = { new_image, threshold, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BilevelImage), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    BilevelImageChannel(new_image, channels, threshold);
+    GVL_STRUCT_TYPE(BilevelImageChannel) args = { new_image, channels, threshold };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BilevelImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -1322,7 +1586,7 @@ Image_black_point_compensation_eq(VALUE self, VALUE arg)
 VALUE
 Image_black_threshold(int argc, VALUE *argv, VALUE self)
 {
-    return threshold_image(argc, argv, self, BlackThresholdImage);
+    return threshold_image(argc, argv, self, GVL_FUNC(BlackThresholdImage));
 }
 
 
@@ -1632,11 +1896,13 @@ special_composite(Image *image, Image *overlay, double image_pct, double overlay
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    CompositeImage(new_image, overlay, op, MagickTrue, x_off, y_off, exception);
+    GVL_STRUCT_TYPE(CompositeImage) args = { new_image, overlay, op, MagickTrue, x_off, y_off, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    CompositeImage(new_image, op, overlay, x_off, y_off);
+    GVL_STRUCT_TYPE(CompositeImage) args = { new_image, op, overlay, x_off, y_off };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImage), &args);
 
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
@@ -1743,7 +2009,8 @@ Image_blue_shift(int argc, VALUE *argv, VALUE self)
 
 
     exception = AcquireExceptionInfo();
-    new_image = BlueShiftImage(image, factor, exception);
+    GVL_STRUCT_TYPE(BlueShiftImage) args = { image, factor, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlueShiftImage), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 
@@ -1795,11 +2062,13 @@ Image_blur_channel(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = BlurImage(image, radius, sigma, exception);
+    GVL_STRUCT_TYPE(BlurImage) args = { image, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlurImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #else
-    new_image = BlurImageChannel(image, channels, radius, sigma, exception);
+    GVL_STRUCT_TYPE(BlurImageChannel) args = { image, channels, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlurImageChannel), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -1819,7 +2088,7 @@ Image_blur_channel(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_blur_image(int argc, VALUE *argv, VALUE self)
 {
-    return effect_image(self, argc, argv, BlurImage);
+    return effect_image(self, argc, argv, GVL_FUNC(BlurImage));
 }
 
 
@@ -1846,7 +2115,7 @@ border(int bang, VALUE self, VALUE width, VALUE height, VALUE color)
     ExceptionInfo *exception;
     RectangleInfo rect;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     memset(&rect, 0, sizeof(rect));
     rect.width = NUM2UINT(width);
@@ -1858,10 +2127,11 @@ border(int bang, VALUE self, VALUE width, VALUE height, VALUE color)
 
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
-    new_image = BorderImage(image, &rect, image->compose, exception);
+    GVL_STRUCT_TYPE(BorderImage) args = { image, &rect, image->compose, exception };
 #else
-    new_image = BorderImage(image, &rect, exception);
+    GVL_STRUCT_TYPE(BorderImage) args = { image, &rect, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BorderImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -1990,12 +2260,12 @@ Image_bounding_box(VALUE self)
  *     importantly, you can capture menus or other popups that are independent windows but appear
  *     over the specified window.
  *   @param borders [Boolean] If true, include the border in the image.
- *   @yield []
+ *   @yield [Magick::Image::Info]
  *
  * @return [Magick::Image] a new image
  * @example
- *   img = Image.capture {
- *     self.filename = "root"
+ *   img = Image.capture { |options|
+ *     options.filename = "root"
  *   }
  */
 VALUE
@@ -2035,7 +2305,7 @@ Image_capture(int argc, VALUE *argv, VALUE self ATTRIBUTE_UNUSED)
     // Set info->server_name to the server name
     // Also info->colorspace, depth, dither, interlace, type
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, image_info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, image_info);
 
     // If an error occurs, IM will call our error handler and we raise an exception.
 #if defined(IMAGEMAGICK_7)
@@ -2146,12 +2416,14 @@ Image_channel(VALUE self, VALUE channel_arg)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    new_image = SeparateImage(image, channel, exception);
+    GVL_STRUCT_TYPE(SeparateImage) args = { image, channel, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SeparateImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
     new_image = rm_clone_image(image);
-    SeparateImageChannel(new_image, channel);
+    GVL_STRUCT_TYPE(SeparateImageChannel) args = { new_image, channel };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SeparateImageChannel), &args);
 
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
@@ -2176,7 +2448,7 @@ Image_channel_depth(int argc, VALUE *argv, VALUE self)
 {
     Image *image;
     ChannelType channels;
-    unsigned long channel_depth;
+    size_t channel_depth;
     ExceptionInfo *exception;
 
     image = rm_check_destroyed(self);
@@ -2192,10 +2464,12 @@ Image_channel_depth(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    channel_depth = GetImageDepth(image, exception);
+    GVL_STRUCT_TYPE(GetImageDepth) args = { image, exception };
+    channel_depth = (size_t)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageDepth), &args);
     END_CHANNEL_MASK(image);
 #else
-    channel_depth = GetImageChannelDepth(image, channels, exception);
+    GVL_STRUCT_TYPE(GetImageChannelDepth) args = { image, channels, exception };
+    channel_depth = (size_t)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageChannelDepth), &args);
 #endif
     CHECK_EXCEPTION();
 
@@ -2239,10 +2513,12 @@ Image_channel_extrema(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    GetImageExtrema(image, &min, &max, exception);
+    GVL_STRUCT_TYPE(GetImageExtrema) args = { image, &min, &max, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageExtrema), &args);
     END_CHANNEL_MASK(image);
 #else
-    GetImageChannelExtrema(image, channels, &min, &max, exception);
+    GVL_STRUCT_TYPE(GetImageChannelExtrema) args = { image, channels, &min, &max, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageChannelExtrema), &args);
 #endif
     CHECK_EXCEPTION();
 
@@ -2292,10 +2568,12 @@ Image_channel_mean(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    GetImageMean(image, &mean, &stddev, exception);
+    GVL_STRUCT_TYPE(GetImageMean) args = { image, &mean, &stddev, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageMean), &args);
     END_CHANNEL_MASK(image);
 #else
-    GetImageChannelMean(image, channels, &mean, &stddev, exception);
+    GVL_STRUCT_TYPE(GetImageChannelMean) args = { image, channels, &mean, &stddev, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageChannelMean), &args);
 #endif
     CHECK_EXCEPTION();
 
@@ -2344,10 +2622,12 @@ Image_channel_entropy(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    GetImageEntropy(image, &entropy, exception);
+    GVL_STRUCT_TYPE(GetImageEntropy) args = { image, &entropy, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageEntropy), &args);
     END_CHANNEL_MASK(image);
 #else
-    GetImageChannelEntropy(image, channels, &entropy, exception);
+    GVL_STRUCT_TYPE(GetImageChannelEntropy) args = { image, channels, &entropy, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageChannelEntropy), &args);
 #endif
     CHECK_EXCEPTION();
 
@@ -2379,7 +2659,7 @@ Image_channel_entropy(int argc ATTRIBUTE_UNUSED, VALUE *argv ATTRIBUTE_UNUSED, V
 VALUE
 Image_charcoal(int argc, VALUE *argv, VALUE self)
 {
-    return effect_image(self, argc, argv, CharcoalImage);
+    return effect_image(self, argc, argv, GVL_FUNC(CharcoalImage));
 }
 
 
@@ -2410,7 +2690,7 @@ VALUE
 Image_chop(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
 {
     rm_check_destroyed(self);
-    return xform_image(False, self, x, y, width, height, ChopImage);
+    return xform_image(False, self, x, y, width, height, GVL_FUNC(ChopImage));
 }
 
 
@@ -2515,17 +2795,19 @@ Image_clut_channel(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or more)", argc);
     }
 
-    Data_Get_Struct(argv[0], Image, clut);
+    TypedData_Get_Struct(argv[0], Image, &rm_image_data_type, clut);
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(image, channels);
-    okay = ClutImage(image, clut, image->interpolate, exception);
+    GVL_STRUCT_TYPE(ClutImage) args = { image, clut, image->interpolate, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ClutImage), &args);
     END_CHANNEL_MASK(image);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    okay = ClutImageChannel(image, channels, clut);
+    GVL_STRUCT_TYPE(ClutImageChannel) args = { image, channels, clut };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ClutImageChannel), &args);
     rm_check_image_exception(image, RetainOnError);
     rm_check_image_exception(clut, RetainOnError);
 #endif
@@ -2566,14 +2848,16 @@ Image_color_histogram(VALUE self)
     {
         dc_copy = rm_clone_image(image);
 #if defined(IMAGEMAGICK_7)
-        SetImageStorageClass(dc_copy, DirectClass, exception);
+        GVL_STRUCT_TYPE(SetImageStorageClass) args = { dc_copy, DirectClass, exception };
 #else
-        SetImageStorageClass(dc_copy, DirectClass);
+        GVL_STRUCT_TYPE(SetImageStorageClass) args = { dc_copy, DirectClass };
 #endif
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args);
         image = dc_copy;
     }
 
-    histogram = GetImageHistogram(image, &colors, exception);
+    GVL_STRUCT_TYPE(GetImageHistogram) args = { image, &colors, exception };
+    histogram = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageHistogram), &args);
 
     if (histogram == NULL)
     {
@@ -2667,7 +2951,8 @@ set_profile(VALUE self, const char *name, VALUE profile)
 
     strlcpy(info->magick, m->name, sizeof(info->magick));
 
-    profile_image = BlobToImage(info, profile_blob, (size_t)profile_length, exception);
+    GVL_STRUCT_TYPE(BlobToImage) args = { info, profile_blob, (size_t)profile_length, exception };
+    profile_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlobToImage), &args);
     DestroyImageInfo(info);
     CHECK_EXCEPTION();
 
@@ -2679,10 +2964,12 @@ set_profile(VALUE self, const char *name, VALUE profile)
         if (rm_strcasecmp("8bim", profile_name) == 0 && rm_strcasecmp("iptc", name) == 0)
         {
 #if defined(IMAGEMAGICK_7)
-            ProfileImage(image, name, profile_blob, profile_length, exception);
+            GVL_STRUCT_TYPE(ProfileImage) args = { image, name, profile_blob, profile_length, exception };
+            CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ProfileImage), &args);
             if (rm_should_raise_exception(exception, RetainExceptionRetention))
 #else
-            ProfileImage(image, name, profile_blob, profile_length, MagickFalse);
+            GVL_STRUCT_TYPE(ProfileImage) args = { image, name, profile_blob, profile_length, MagickFalse };
+            CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ProfileImage), &args);
             if (rm_should_raise_exception(&image->exception, RetainExceptionRetention))
 #endif
             {
@@ -2695,10 +2982,12 @@ set_profile(VALUE self, const char *name, VALUE profile)
             if (profile_data)
             {
 #if defined(IMAGEMAGICK_7)
-                ProfileImage(image, name, GetStringInfoDatum(profile_data), GetStringInfoLength(profile_data), exception);
+                GVL_STRUCT_TYPE(ProfileImage) args = { image, name, GetStringInfoDatum(profile_data), GetStringInfoLength(profile_data), exception };
+                CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ProfileImage), &args);
                 if (rm_should_raise_exception(exception, RetainExceptionRetention))
 #else
-                ProfileImage(image, name, GetStringInfoDatum(profile_data), GetStringInfoLength(profile_data), MagickFalse);
+                GVL_STRUCT_TYPE(ProfileImage) args = { image, name, GetStringInfoDatum(profile_data), GetStringInfoLength(profile_data), MagickFalse };
+                CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ProfileImage), &args);
                 if (rm_should_raise_exception(&image->exception, RetainExceptionRetention))
 #endif
                 {
@@ -2847,12 +3136,14 @@ Image_color_flood_fill(VALUE self, VALUE target_color, VALUE fill_color,
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    FloodfillPaintImage(new_image, draw_info, &target_mpp, x, y, invert, exception);
+    GVL_STRUCT_TYPE(FloodfillPaintImage) args = { new_image, draw_info, &target_mpp, x, y, invert, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FloodfillPaintImage), &args);
     DestroyDrawInfo(draw_info);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    FloodfillPaintImage(new_image, DefaultChannels, draw_info, &target_mpp, x, y, invert);
+    GVL_STRUCT_TYPE(FloodfillPaintImage) args = { new_image, DefaultChannels, draw_info, &target_mpp, x, y, invert };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FloodfillPaintImage), &args);
 
     DestroyDrawInfo(draw_info);
     rm_check_image_exception(new_image, DestroyOnError);
@@ -2916,10 +3207,11 @@ Image_colorize(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
-    new_image = ColorizeImage(image, opacity, &target, exception);
+    GVL_STRUCT_TYPE(ColorizeImage) args = { image, opacity, &target, exception };
 #else
-    new_image = ColorizeImage(image, opacity, target, exception);
+    GVL_STRUCT_TYPE(ColorizeImage) args = { image, opacity, target, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ColorizeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -3029,7 +3321,7 @@ Image_colormap(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_colors(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, colors, ulong);
+    IMPLEMENT_TYPED_ATTR_READER(Image, colors, ulong, &rm_image_data_type);
 }
 
 /**
@@ -3069,11 +3361,13 @@ Image_colorspace_eq(VALUE self, VALUE colorspace)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    TransformImageColorspace(image, new_cs, exception);
+    GVL_STRUCT_TYPE(TransformImageColorspace) args = { image, new_cs, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TransformImageColorspace), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    TransformImageColorspace(image, new_cs);
+    GVL_STRUCT_TYPE(TransformImageColorspace) args = { image, new_cs };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TransformImageColorspace), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -3089,7 +3383,7 @@ Image_colorspace_eq(VALUE self, VALUE colorspace)
 VALUE
 Image_columns(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, columns, int);
+    IMPLEMENT_TYPED_ATTR_READER(Image, columns, int, &rm_image_data_type);
 }
 
 
@@ -3104,17 +3398,17 @@ Image_columns(VALUE self)
  *   @param channel [Magick::ChannelType] a ChannelType arguments.
  *
  * @overload compare_channel(image, metric, channel = Magick::AllChannels)
- *   If present a block, compare_channel yields to a block in which you can set optional arguments
- *   by setting attributes on self.
- *   - self.highlight_color = color
+ *   When a block is given, compare_channel yields with a block argument you can optionally use to
+ *   set attributes.
+ *   - options.highlight_color = color
  *     - Emphasize pixel differences with this color. The default is partially transparent red.
- *   - self.lowlight_color = color
+ *   - options.lowlight_color = color
  *     - Demphasize pixel differences with this color. The default is partially transparent white.
  *   @param image [Magick::Image, Magick::ImageList] Either an imagelist or an image. If an
  *     imagelist, uses the current image.
  *   @param metric [Magick::MetricType] The desired distortion metric.
  *   @param channel [Magick::ChannelType] a ChannelType arguments.
- *   @yield []
+ *   @yield [Magick::OptionalMethodArguments]
  *
  * @overload compare_channel(image, metric, *channels)
  *   @param image [Magick::Image, Magick::ImageList] Either an imagelist or an image. If an
@@ -3124,18 +3418,18 @@ Image_columns(VALUE self)
  *   @param *channels [Magick::ChannelType] one or more ChannelType arguments.
  *
  * @overload compare_channel(image, metric, *channels)
- *   If present a block, compare_channel yields to a block in which you can set optional arguments
- *   by setting attributes on self.
- *   - self.highlight_color = color
+ *   When a block is given, compare_channel yields with a block argument you can optionally use to
+ *   set attributes.
+ *   - options.highlight_color = color
  *     - Emphasize pixel differences with this color. The default is partially transparent red.
- *   - self.lowlight_color = color
+ *   - options.lowlight_color = color
  *     - Demphasize pixel differences with this color. The default is partially transparent white.
  *   @param image [Magick::Image, Magick::ImageList] Either an imagelist or an image. If an
  *     imagelist, uses the current image.
  *   @param metric [Magick::MetricType] The desired distortion metric.
  *   @param channel [Magick::ChannelType] a ChannelType arguments.
  *   @param *channels [Magick::ChannelType] one or more ChannelType arguments.
- *   @yield []
+ *   @yield [Magick::OptionalMethodArguments]
  *
  * @return [Array] The first element is a difference image, the second is a the value of the
  *   computed distortion represented as a Float.
@@ -3173,10 +3467,12 @@ Image_compare_channel(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    difference_image = CompareImages(image, r_image, metric_type, &distortion, exception);
+    GVL_STRUCT_TYPE(CompareImages) args = { image, r_image, metric_type, &distortion, exception };
+    difference_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompareImages), &args);
     END_CHANNEL_MASK(image);
 #else
-    difference_image = CompareImageChannels(image, r_image, channels, metric_type, &distortion, exception);
+    GVL_STRUCT_TYPE(CompareImageChannels) args = { image, r_image, channels, metric_type, &distortion, exception };
+    difference_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompareImageChannels), &args);
 #endif
     rm_check_exception(exception, difference_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -3374,12 +3670,14 @@ composite(int bang, int argc, VALUE *argv, VALUE self, ChannelType channels)
 #if defined(IMAGEMAGICK_7)
         exception = AcquireExceptionInfo();
         BEGIN_CHANNEL_MASK(image, channels);
-        CompositeImage(image, comp_image, operator, MagickTrue, x_offset, y_offset, exception);
+        GVL_STRUCT_TYPE(CompositeImage) args = { image, comp_image, operator, MagickTrue, x_offset, y_offset, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImage), &args);
         END_CHANNEL_MASK(image);
         CHECK_EXCEPTION();
         DestroyExceptionInfo(exception);
 #else
-        CompositeImageChannel(image, channels, operator, comp_image, x_offset, y_offset);
+        GVL_STRUCT_TYPE(CompositeImageChannel) args = { image, channels, operator, comp_image, x_offset, y_offset };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImageChannel), &args);
         rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -3392,12 +3690,14 @@ composite(int bang, int argc, VALUE *argv, VALUE self, ChannelType channels)
 #if defined(IMAGEMAGICK_7)
         exception = AcquireExceptionInfo();
         BEGIN_CHANNEL_MASK(new_image, channels);
-        CompositeImage(new_image, comp_image, operator, MagickTrue, x_offset, y_offset, exception);
+        GVL_STRUCT_TYPE(CompositeImage) args = { new_image, comp_image, operator, MagickTrue, x_offset, y_offset, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImage), &args);
         END_CHANNEL_MASK(new_image);
         rm_check_exception(exception, new_image, DestroyOnError);
         DestroyExceptionInfo(exception);
 #else
-        CompositeImageChannel(new_image, channels, operator, comp_image, x_offset, y_offset);
+        GVL_STRUCT_TYPE(CompositeImageChannel) args = { new_image, channels, operator, comp_image, x_offset, y_offset };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImageChannel), &args);
         rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -3511,11 +3811,13 @@ Image_composite_affine(VALUE self, VALUE source, VALUE affine_matrix)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    DrawAffineImage(new_image, composite_image, &affine, exception);
+    GVL_STRUCT_TYPE(DrawAffineImage) args = { new_image, composite_image, &affine, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(DrawAffineImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    DrawAffineImage(new_image, composite_image, &affine);
+    GVL_STRUCT_TYPE(DrawAffineImage) args = { new_image, composite_image, &affine };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(DrawAffineImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -3879,11 +4181,13 @@ composite_tiled(int bang, int argc, VALUE *argv, VALUE self)
         {
 #if defined(IMAGEMAGICK_7)
             BEGIN_CHANNEL_MASK(image, channels);
-            status = CompositeImage(image, comp_image, operator, MagickTrue, x, y, exception);
+            GVL_STRUCT_TYPE(CompositeImage) args = { image, comp_image, operator, MagickTrue, x, y, exception };
+            status = (MagickStatusType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImage), &args);
             END_CHANNEL_MASK(image);
             rm_check_exception(exception, image, bang ? RetainOnError: DestroyOnError);
 #else
-            status = CompositeImageChannel(image, channels, operator, comp_image, x, y);
+            GVL_STRUCT_TYPE(CompositeImageChannel) args = { image, channels, operator, comp_image, x, y };
+            status = (MagickStatusType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImageChannel), &args);
             rm_check_image_exception(image, bang ? RetainOnError: DestroyOnError);
 #endif
         }
@@ -3996,11 +4300,13 @@ Image_compress_colormap_bang(VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    okay = CompressImageColormap(image, exception);
+    GVL_STRUCT_TYPE(CompressImageColormap) args = { image, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompressImageColormap), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    okay = CompressImageColormap(image);
+    GVL_STRUCT_TYPE(CompressImageColormap) args = { image };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompressImageColormap), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
     if (!okay)
@@ -4130,9 +4436,11 @@ Image_constitute(VALUE class ATTRIBUTE_UNUSED, VALUE width_arg, VALUE height_arg
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SetImageExtent(new_image, width, height, exception);
+    GVL_STRUCT_TYPE(SetImageExtent) args_SetImageExtent = { new_image, width, height, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageExtent), &args_SetImageExtent);
 #else
-    SetImageExtent(new_image, width, height);
+    GVL_STRUCT_TYPE(SetImageExtent) args_SetImageExtent = { new_image, width, height };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageExtent), &args_SetImageExtent);
     exception = &new_image->exception;
 #endif
 
@@ -4148,9 +4456,11 @@ Image_constitute(VALUE class ATTRIBUTE_UNUSED, VALUE width_arg, VALUE height_arg
     }
 
 #if defined(IMAGEMAGICK_7)
-    SetImageBackgroundColor(new_image, exception);
+    GVL_STRUCT_TYPE(SetImageBackgroundColor) args_SetImageBackgroundColor = { new_image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageBackgroundColor), &args_SetImageBackgroundColor);
 #else
-    SetImageBackgroundColor(new_image);
+    GVL_STRUCT_TYPE(SetImageBackgroundColor) args_SetImageBackgroundColor = { new_image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageBackgroundColor), &args_SetImageBackgroundColor);
     exception = &new_image->exception;
 #endif
 
@@ -4166,12 +4476,14 @@ Image_constitute(VALUE class ATTRIBUTE_UNUSED, VALUE width_arg, VALUE height_arg
     }
 
 #if defined(IMAGEMAGICK_7)
-    ImportImagePixels(new_image, 0, 0, width, height, map, stg_type, (const void *)pixels.v, exception);
+    GVL_STRUCT_TYPE(ImportImagePixels) args_ImportImagePixels = { new_image, 0, 0, width, height, map, stg_type, (const void *)pixels.v, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ImportImagePixels), &args_ImportImagePixels);
     xfree(pixels.v);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    ImportImagePixels(new_image, 0, 0, width, height, map, stg_type, (const void *)pixels.v);
+    GVL_STRUCT_TYPE(ImportImagePixels) args_ImportImagePixels = { new_image, 0, 0, width, height, map, stg_type, (const void *)pixels.v };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ImportImagePixels), &args_ImportImagePixels);
     xfree(pixels.v);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
@@ -4338,12 +4650,14 @@ Image_contrast_stretch_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    ContrastStretchImage(new_image, black_point, white_point, exception);
+    GVL_STRUCT_TYPE(ContrastStretchImage) args = { new_image, black_point, white_point, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ContrastStretchImage), &args);
     END_CHANNEL_MASK(new_image);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    ContrastStretchImageChannel(new_image, channels, black_point, white_point);
+    GVL_STRUCT_TYPE(ContrastStretchImageChannel) args = { new_image, channels, black_point, white_point };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ContrastStretchImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -4413,17 +4727,19 @@ Image_morphology_channel(VALUE self, VALUE channel_v, VALUE method_v, VALUE iter
         rb_raise(rb_eArgError, "expected String or Magick::KernelInfo");
     }
 
-    Data_Get_Struct(kernel_v, KernelInfo, kernel);
+    TypedData_Get_Struct(kernel_v, KernelInfo, &rm_kernel_info_data_type, kernel);
 
     exception = AcquireExceptionInfo();
 
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channel);
-    new_image = MorphologyImage(image, method, NUM2LONG(iterations), kernel, exception);
+    GVL_STRUCT_TYPE(MorphologyImage) args = { image, method, NUM2LONG(iterations), kernel, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MorphologyImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #else
-    new_image = MorphologyImageChannel(image, channel, method, NUM2LONG(iterations), kernel, exception);
+    GVL_STRUCT_TYPE(MorphologyImageChannel) args = { image, channel, method, NUM2LONG(iterations), kernel, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(MorphologyImageChannel), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -4534,10 +4850,12 @@ Image_convolve(VALUE self, VALUE order_arg, VALUE kernel_arg)
     exception = AcquireExceptionInfo();
 
 #if defined(IMAGEMAGICK_7)
-    new_image = ConvolveImage(image, kernel, exception);
+    GVL_STRUCT_TYPE(ConvolveImage) args = { image, kernel, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ConvolveImage), &args);
     DestroyKernelInfo(kernel);
 #else
-    new_image = ConvolveImage(image, order, kernel, exception);
+    GVL_STRUCT_TYPE(ConvolveImage) args = { image, order, kernel, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ConvolveImage), &args);
     xfree((void *)kernel);
 #endif
 
@@ -4626,12 +4944,14 @@ Image_convolve_channel(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = ConvolveImage(image, kernel, exception);
+    GVL_STRUCT_TYPE(ConvolveImage) args = { image, kernel, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ConvolveImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
     DestroyKernelInfo(kernel);
 #else
-    new_image = ConvolveImageChannel(image, channels, order, kernel, exception);
+    GVL_STRUCT_TYPE(ConvolveImageChannel) args = { image, channels, order, kernel, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ConvolveImageChannel), &args);
     xfree((void *)kernel);
 #endif
 
@@ -4681,26 +5001,26 @@ Image_init_copy(VALUE copy, VALUE orig)
 /**
  * Extract a region of the image defined by width, height, x, y.
  *
- * @overload crop(reset = false, x, y, width, height)
- *   @param reset [Boolean] true if reset the cropped image page canvas and position
+ * @overload crop(x, y, width, height, reset = false)
  *   @param x [Numeric] x position of start of region
  *   @param y [Numeric] y position of start of region
  *   @param width [Numeric] width of region
  *   @param height [Numeric] height of region
- *
- * @overload crop(reset = false, gravity, width, height)
  *   @param reset [Boolean] true if reset the cropped image page canvas and position
+ *
+ * @overload crop(gravity, width, height, reset = false)
  *   @param gravity [Magick::GravityType] the gravity type
  *   @param width [Numeric] width of region
  *   @param height [Numeric] height of region
-
- * @overload crop(reset = false, gravity, x, y, width, height)
  *   @param reset [Boolean] true if reset the cropped image page canvas and position
+
+ * @overload crop(gravity, x, y, width, height, reset = false)
  *   @param gravity [Magick::GravityType] the gravity type
  *   @param x [Numeric] x position of start of region
  *   @param y [Numeric] y position of start of region
  *   @param width [Numeric] width of region
  *   @param height [Numeric] height of region
+ *   @param reset [Boolean] true if reset the cropped image page canvas and position
  *
  * @return [Magick::Image] a new image
  * @see Image#crop!
@@ -4774,11 +5094,13 @@ Image_cycle_colormap(VALUE self, VALUE amount)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    CycleColormapImage(new_image, amt, exception);
+    GVL_STRUCT_TYPE(CycleColormapImage) args = { new_image, amt, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CycleColormapImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    CycleColormapImage(new_image, amt);
+    GVL_STRUCT_TYPE(CycleColormapImage) args = { new_image, amt };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CycleColormapImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -4913,7 +5235,8 @@ Image_decipher(VALUE self, VALUE passphrase)
 
     new_image = rm_clone_image(image);
 
-    okay = DecipherImage(new_image, pf, exception);
+    GVL_STRUCT_TYPE(DecipherImage) args = { new_image, pf, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(DecipherImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     if (!okay)
     {
@@ -4980,7 +5303,7 @@ Image_define(VALUE self, VALUE artifact, VALUE value)
 VALUE
 Image_delay(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, delay, ulong);
+    IMPLEMENT_TYPED_ATTR_READER(Image, delay, ulong, &rm_image_data_type);
 }
 
 /**
@@ -4993,7 +5316,7 @@ Image_delay(VALUE self)
 VALUE
 Image_delay_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITER(Image, delay, ulong);
+    IMPLEMENT_TYPED_ATTR_WRITER(Image, delay, ulong, &rm_image_data_type);
 }
 
 
@@ -5015,11 +5338,13 @@ Image_delete_compose_mask(VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SetImageMask(image, CompositePixelMask, NULL, exception);
+    GVL_STRUCT_TYPE(SetImageMask) args = { image, CompositePixelMask, NULL, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageMask), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    SetImageMask(image, NULL);
+    GVL_STRUCT_TYPE(SetImageMask) args = { image, NULL };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageMask), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -5039,8 +5364,18 @@ VALUE
 Image_delete_profile(VALUE self, VALUE name)
 {
     Image *image = rm_check_frozen(self);
-    DeleteImageProfile(image, StringValueCStr(name));
 
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception = AcquireExceptionInfo();
+
+    GVL_STRUCT_TYPE(ProfileImage) args = { image, StringValueCStr(name), NULL, 0, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ProfileImage), &args);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+#else
+    GVL_STRUCT_TYPE(ProfileImage) args = { image, StringValueCStr(name), NULL, 0, MagickTrue };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ProfileImage), &args);
+#endif
     return self;
 }
 
@@ -5057,13 +5392,14 @@ VALUE
 Image_depth(VALUE self)
 {
     Image *image;
-    unsigned long depth = 0;
+    size_t depth = 0;
     ExceptionInfo *exception;
 
     image = rm_check_destroyed(self);
     exception = AcquireExceptionInfo();
 
-    depth = GetImageDepth(image, exception);
+    GVL_STRUCT_TYPE(GetImageDepth) args = { image, exception };
+    depth = (size_t)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageDepth), &args);
     CHECK_EXCEPTION();
 
     DestroyExceptionInfo(exception);
@@ -5110,7 +5446,8 @@ Image_deskew(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = DeskewImage(image, threshold, exception);
+    GVL_STRUCT_TYPE(DeskewImage) args = { image, threshold, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(DeskewImage), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 
@@ -5132,7 +5469,8 @@ Image_despeckle(VALUE self)
     image = rm_check_destroyed(self);
     exception = AcquireExceptionInfo();
 
-    new_image = DespeckleImage(image, exception);
+    GVL_STRUCT_TYPE(DespeckleImage) args = { image, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(DespeckleImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -5151,7 +5489,7 @@ Image_destroy_bang(VALUE self)
     Image *image;
 
     rb_check_frozen(self);
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
     rm_image_destroy(image);
     DATA_PTR(self) = NULL;
     return self;
@@ -5168,7 +5506,7 @@ Image_destroyed_q(VALUE self)
 {
     Image *image;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
     return image ? Qfalse : Qtrue;
 }
 
@@ -5197,6 +5535,7 @@ Image_difference(VALUE self, VALUE other)
     Image *image2;
     VALUE mean, nmean, nmax;
 #if defined(IMAGEMAGICK_7)
+    double distortion;
     ExceptionInfo *exception;
 #endif
 
@@ -5206,11 +5545,13 @@ Image_difference(VALUE self, VALUE other)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    IsImagesEqual(image, image2, exception);
+    GVL_STRUCT_TYPE(GetImageDistortion) args = { image, image2, MeanErrorPerPixelErrorMetric, &distortion, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageDistortion), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    IsImagesEqual(image, image2);
+    GVL_STRUCT_TYPE(IsImagesEqual) args = { image, image2 };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(IsImagesEqual), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -5234,7 +5575,7 @@ Image_difference(VALUE self, VALUE other)
 VALUE
 Image_directory(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, directory, str);
+    IMPLEMENT_TYPED_ATTR_READER(Image, directory, str, &rm_image_data_type);
 }
 
 
@@ -5359,10 +5700,11 @@ Image_dispatch(int argc, VALUE *argv, VALUE self)
     // Create the Ruby array for the pixels. Return this even if ExportImagePixels fails.
     pixels_ary = rb_ary_new();
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     exception = AcquireExceptionInfo();
-    okay = ExportImagePixels(image, x, y, columns, rows, map, stg_type, (void *)pixels.v, exception);
+    GVL_STRUCT_TYPE(ExportImagePixels) args = { image, x, y, columns, rows, map, stg_type, (void *)pixels.v, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ExportImagePixels), &args);
 
     if (!okay)
     {
@@ -5421,7 +5763,7 @@ Image_display(VALUE self)
     }
 
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
@@ -5551,17 +5893,16 @@ Image_dissolve(int argc, VALUE *argv, VALUE self)
  *     the source image will be taken into account in the mapping.
  *
  * @overload distort(type, points, bestfit = false)
- *   If present a block, distort yields to a block in which you can set optional arguments by
- *   setting attributes on self.
- *   - self.define("distort:viewport", "WxH+X+Y")
+ *   When a block is given, distort yields with a block argument you can optionally use to set attributes.
+ *   - options.define("distort:viewport", "WxH+X+Y")
  *     - Specify the size and offset of the generated viewport image of the distorted image space. W and
  *       H are the width and height, and X and Y are the offset.
- *   - self.define("distort:scale", N)
+ *   - options.define("distort:scale", N)
  *     - N is an integer factor. Scale the output image (viewport or otherwise) by that factor without
  *       changing the viewed contents of the distorted image. This can be used either for
  *       'super-sampling' the image for a higher quality result, or for panning and zooming around
  *       the image (with appropriate viewport changes, or post-distort cropping and resizing).
- *   - self.verbose(true)
+ *   - options.verbose(true)
  *     - Attempt to output the internal coefficients, and the -fx equivalent to the distortion, for
          expert study, and debugging purposes. This many not be available for all distorts.
  *   @param type [Magick::DistortMethod] a DistortMethod value
@@ -5570,13 +5911,13 @@ Image_dissolve(int argc, VALUE *argv, VALUE self)
  *     image is adjusted to ensure the whole source image will just fit within the final destination
  *     image, which will be sized and offset accordingly.  Also in many cases the virtual offset of
  *     the source image will be taken into account in the mapping.
- *   @yield []
+ *   @yield [Magick::OptionalMethodArguments]
  *
  * @return [Magick::Image] a new image
  * @example
- *   img.distort(Magick::ScaleRotateTranslateDistortion, [0]) do
- *     self.define "distort:viewport", "44x44+15+0"
- *     self.define "distort:scale", 2
+ *   img.distort(Magick::ScaleRotateTranslateDistortion, [0]) do |options|
+ *     options.define "distort:viewport", "44x44+15+0"
+ *     options.define "distort:scale", 2
  *   end
  */
 VALUE
@@ -5625,7 +5966,8 @@ Image_distort(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = DistortImage(image, distortion_method, npoints, points, bestfit, exception);
+    GVL_STRUCT_TYPE(DistortImage) args = { image, distortion_method, npoints, points, bestfit, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(DistortImage), &args);
     xfree(points);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -5684,11 +6026,13 @@ Image_distortion_channel(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    difference_image = CompareImages(image, reconstruct, metric, &distortion, exception);
+    GVL_STRUCT_TYPE(CompareImages) args = { image, reconstruct, metric, &distortion, exception };
+    difference_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompareImages), &args);
     END_CHANNEL_MASK(image);
     DestroyImage(difference_image);
 #else
-    GetImageChannelDistortion(image, reconstruct, channels, metric, &distortion, exception);
+    GVL_STRUCT_TYPE(GetImageChannelDistortion) args = { image, reconstruct, channels, metric, &distortion, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageChannelDistortion), &args);
 #endif
 
     CHECK_EXCEPTION();
@@ -5728,7 +6072,8 @@ Image__dump(VALUE self, VALUE depth ATTRIBUTE_UNUSED)
     strlcpy(info->magick, image->magick, sizeof(info->magick));
 
     exception = AcquireExceptionInfo();
-    blob = ImageToBlob(info, image, &length, exception);
+    GVL_STRUCT_TYPE(ImageToBlob) args = { info, image, &length, exception };
+    blob = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ImageToBlob), &args);
 
     // Free ImageInfo first - error handling may raise an exception
     DestroyImageInfo(info);
@@ -5774,7 +6119,7 @@ Image_dup(VALUE self)
     VALUE dup;
 
     rm_check_destroyed(self);
-    dup = Data_Wrap_Struct(CLASS_OF(self), NULL, rm_image_destroy, NULL);
+    dup = TypedData_Wrap_Struct(CLASS_OF(self), &rm_image_data_type, NULL);
     RB_GC_GUARD(dup);
 
     return rb_funcall(dup, rm_ID_initialize_copy, 1, self);
@@ -5856,7 +6201,8 @@ Image_edge(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 
-    new_image = EdgeImage(image, radius, exception);
+    GVL_STRUCT_TYPE(EdgeImage) args = { image, radius, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EdgeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -5864,6 +6210,9 @@ Image_edge(int argc, VALUE *argv, VALUE self)
 }
 
 
+// aliases for common use of structure types; BlurImage, CharcoalImage, EmbossImage, GaussianBlurImage, SharpenImage
+typedef GVL_STRUCT_TYPE(BlurImage) GVL_STRUCT_TYPE(effect_image);
+
 /**
  * Call one of the effects methods.
  *
@@ -5876,7 +6225,7 @@ Image_edge(int argc, VALUE *argv, VALUE self)
  * @return a new image
  */
 static VALUE
-effect_image(VALUE self, int argc, VALUE *argv, effector_t effector)
+effect_image(VALUE self, int argc, VALUE *argv, gvl_function_t fp)
 {
     Image *image, *new_image;
     ExceptionInfo *exception;
@@ -5903,7 +6252,8 @@ effect_image(VALUE self, int argc, VALUE *argv, effector_t effector)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = (effector)(image, radius, sigma, exception);
+    GVL_STRUCT_TYPE(effect_image) args = { image, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -5922,7 +6272,7 @@ effect_image(VALUE self, int argc, VALUE *argv, effector_t effector)
 VALUE
 Image_emboss(int argc, VALUE *argv, VALUE self)
 {
-    return effect_image(self, argc, argv, EmbossImage);
+    return effect_image(self, argc, argv, GVL_FUNC(EmbossImage));
 }
 
 
@@ -5948,7 +6298,8 @@ Image_encipher(VALUE self, VALUE passphrase)
 
     new_image = rm_clone_image(image);
 
-    okay = EncipherImage(new_image, pf, exception);
+    GVL_STRUCT_TYPE(EncipherImage) args = { new_image, pf, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EncipherImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     if (!okay)
     {
@@ -6004,7 +6355,8 @@ Image_enhance(VALUE self)
     image = rm_check_destroyed(self);
     exception = AcquireExceptionInfo();
 
-    new_image = EnhanceImage(image, exception);
+    GVL_STRUCT_TYPE(EnhanceImage) args = { image, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EnhanceImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -6030,11 +6382,13 @@ Image_equalize(VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    EqualizeImage(new_image, exception);
+    GVL_STRUCT_TYPE(EqualizeImage) args = { new_image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EqualizeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    EqualizeImage(new_image);
+    GVL_STRUCT_TYPE(EqualizeImage) args = { new_image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EqualizeImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -6074,12 +6428,14 @@ Image_equalize_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    EqualizeImage(new_image, exception);
+    GVL_STRUCT_TYPE(EqualizeImage) args = { new_image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EqualizeImage), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    EqualizeImageChannel(new_image, channels);
+    GVL_STRUCT_TYPE(EqualizeImageChannel) args = { new_image, channels };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EqualizeImageChannel), &args);
 
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
@@ -6105,11 +6461,13 @@ Image_erase_bang(VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SetImageBackgroundColor(image, exception);
+    GVL_STRUCT_TYPE(SetImageBackgroundColor) args = { image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageBackgroundColor), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    SetImageBackgroundColor(image);
+    GVL_STRUCT_TYPE(SetImageBackgroundColor) args = { image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageBackgroundColor), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -6151,10 +6509,11 @@ excerpt(int bang, VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
     rect.width = NUM2ULONG(width);
     rect.height = NUM2ULONG(height);
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     exception = AcquireExceptionInfo();
-    new_image = ExcerptImage(image, &rect, exception);
+    GVL_STRUCT_TYPE(ExcerptImage) args = { image, &rect, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ExcerptImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -6242,7 +6601,7 @@ Image_export_pixels(int argc, VALUE *argv, VALUE self)
     long x_off = 0L, y_off = 0L;
     unsigned long cols, rows;
     long n, npixels;
-    unsigned int okay;
+    MagickBooleanType okay;
     const char *map = "RGB";
     Quantum *pixels;
     VALUE ary;
@@ -6289,7 +6648,8 @@ Image_export_pixels(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 
-    okay = ExportImagePixels(image, x_off, y_off, cols, rows, map, QuantumPixel, (void *)pixels, exception);
+    GVL_STRUCT_TYPE(ExportImagePixels) args = { image, x_off, y_off, cols, rows, map, QuantumPixel, (void *)pixels, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ExportImagePixels), &args);
     if (!okay)
     {
         xfree((void *)pixels);
@@ -6371,10 +6731,11 @@ Image_extent(int argc, VALUE *argv, VALUE self)
     }
 
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
     exception = AcquireExceptionInfo();
 
-    new_image = ExtentImage(image, &geometry, exception);
+    GVL_STRUCT_TYPE(ExtentImage) args = { image, &geometry, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ExtentImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -6406,7 +6767,7 @@ Image_export_pixels_to_str(int argc, VALUE *argv, VALUE self)
     unsigned long cols, rows;
     unsigned long npixels;
     size_t sz;
-    unsigned int okay;
+    MagickBooleanType okay;
     const char *map = "RGB";
     StorageType type = CharPixel;
     VALUE string;
@@ -6479,7 +6840,8 @@ Image_export_pixels_to_str(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 
-    okay = ExportImagePixels(image, x_off, y_off, cols, rows, map, type, (void *)RSTRING_PTR(string), exception);
+    GVL_STRUCT_TYPE(ExportImagePixels) args = { image, x_off, y_off, cols, rows, map, type, (void *)RSTRING_PTR(string), exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ExportImagePixels), &args);
     if (!okay)
     {
         // Let GC have the string buffer.
@@ -6534,7 +6896,7 @@ Image_extract_info_eq(VALUE self, VALUE rect)
 VALUE
 Image_filename(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, filename, str);
+    IMPLEMENT_TYPED_ATTR_READER(Image, filename, str, &rm_image_data_type);
 }
 
 
@@ -6601,7 +6963,7 @@ Image_find_similar_region(int argc, VALUE *argv, VALUE self)
     VALUE region, targ;
     ssize_t x = 0L, y = 0L;
     ExceptionInfo *exception;
-    unsigned int okay;
+    MagickBooleanType okay;
 
     image = rm_check_destroyed(self);
 
@@ -6621,7 +6983,13 @@ Image_find_similar_region(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    okay = IsEquivalentImage(image, target, &x, &y, exception);
+#if defined(IMAGEMAGICK_7)
+    GVL_STRUCT_TYPE(IsEquivalentImage) args = { image, target, &x, &y, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(IsEquivalentImage), &args);
+#else
+    GVL_STRUCT_TYPE(IsImageSimilar) args = { image, target, &x, &y, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(IsImageSimilar), &args);
+#endif
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 
@@ -6641,6 +7009,9 @@ Image_find_similar_region(int argc, VALUE *argv, VALUE self)
 }
 
 
+// aliases for common use of structure types; FlopImage, FlipImage
+typedef GVL_STRUCT_TYPE(FlipImage) GVL_STRUCT_TYPE(flipflop);
+
 /**
  * Call a flipflopper (a function that either flips or flops the image).
  *
@@ -6656,15 +7027,16 @@ Image_find_similar_region(int argc, VALUE *argv, VALUE self)
  * @see Image_flop_bang
  */
 static VALUE
-flipflop(int bang, VALUE self, flipper_t flipflopper)
+flipflop(int bang, VALUE self, gvl_function_t fp)
 {
     Image *image, *new_image;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
     exception = AcquireExceptionInfo();
 
-    new_image = (flipflopper)(image, exception);
+    GVL_STRUCT_TYPE(flipflop) args = { image, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -6692,7 +7064,7 @@ VALUE
 Image_flip(VALUE self)
 {
     rm_check_destroyed(self);
-    return flipflop(False, self, FlipImage);
+    return flipflop(False, self, GVL_FUNC(FlipImage));
 }
 
 
@@ -6709,7 +7081,7 @@ VALUE
 Image_flip_bang(VALUE self)
 {
     rm_check_frozen(self);
-    return flipflop(True, self, FlipImage);
+    return flipflop(True, self, GVL_FUNC(FlipImage));
 }
 
 
@@ -6725,7 +7097,7 @@ VALUE
 Image_flop(VALUE self)
 {
     rm_check_destroyed(self);
-    return flipflop(False, self, FlopImage);
+    return flipflop(False, self, GVL_FUNC(FlopImage));
 }
 
 
@@ -6742,7 +7114,7 @@ VALUE
 Image_flop_bang(VALUE self)
 {
     rm_check_frozen(self);
-    return flipflop(True, self, FlopImage);
+    return flipflop(True, self, GVL_FUNC(FlopImage));
 }
 
 
@@ -6862,10 +7234,11 @@ Image_frame(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
-    new_image = FrameImage(image, &frame_info, image->compose, exception);
+    GVL_STRUCT_TYPE(FrameImage) args = { image, &frame_info, image->compose, exception };
 #else
-    new_image = FrameImage(image, &frame_info, exception);
+    GVL_STRUCT_TYPE(FrameImage) args = { image, &frame_info, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FrameImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -6882,7 +7255,7 @@ Image_frame(int argc, VALUE *argv, VALUE self)
  * @overload from_blob(blob)
  *   This yields {Magick::Image::Info} to block with its object's scope.
  *   @param blob [String] the blob data
- *   @yield []
+ *   @yield [Magick::Image::Info]
  *
  * @return [Array<Magick::Image>] an array of new images
  * @see Image#to_blob
@@ -6901,10 +7274,11 @@ Image_from_blob(VALUE class ATTRIBUTE_UNUSED, VALUE blob_arg)
 
     // Get a new Info object - run the parm block if supplied
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
 
     exception = AcquireExceptionInfo();
-    images = BlobToImage(info,  blob, (size_t)length, exception);
+    GVL_STRUCT_TYPE(BlobToImage) args = { info,  blob, (size_t)length, exception };
+    images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlobToImage), &args);
     rm_check_exception(exception, images, DestroyOnError);
 
     DestroyExceptionInfo(exception);
@@ -7004,10 +7378,12 @@ Image_function_channel(int argc, VALUE *argv, VALUE self)
     new_image = rm_clone_image(image);
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(new_image, channels);
-    FunctionImage(new_image, function, nparms, parms, exception);
+    GVL_STRUCT_TYPE(FunctionImage) args = { new_image, function, nparms, parms, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FunctionImage), &args);
     END_CHANNEL_MASK(new_image);
 #else
-    FunctionImageChannel(new_image, channels, function, nparms, parms, exception);
+    GVL_STRUCT_TYPE(FunctionImageChannel) args = { new_image, channels, function, nparms, parms, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FunctionImageChannel), &args);
 #endif
     xfree(parms);
     rm_check_exception(exception, new_image, DestroyOnError);
@@ -7028,7 +7404,7 @@ Image_function_channel(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_fuzz(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, fuzz, dbl);
+    IMPLEMENT_TYPED_ATTR_READER(Image, fuzz, dbl, &rm_image_data_type);
 }
 
 
@@ -7088,11 +7464,13 @@ Image_fx(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = FxImage(image, expression, exception);
+    GVL_STRUCT_TYPE(FxImage) args = { image, expression, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FxImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #else
-    new_image = FxImageChannel(image, channels, expression, exception);
+    GVL_STRUCT_TYPE(FxImageChannel) args = { image, channels, expression, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FxImageChannel), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -7108,7 +7486,7 @@ Image_fx(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_gamma(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, gamma, dbl);
+    IMPLEMENT_TYPED_ATTR_READER(Image, gamma, dbl, &rm_image_data_type);
 }
 
 /**
@@ -7120,7 +7498,7 @@ Image_gamma(VALUE self)
 VALUE
 Image_gamma_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITER(Image, gamma, dbl);
+    IMPLEMENT_TYPED_ATTR_WRITER(Image, gamma, dbl, &rm_image_data_type);
 }
 
 
@@ -7168,12 +7546,14 @@ Image_gamma_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    GammaImage(new_image, gamma, exception);
+    GVL_STRUCT_TYPE(GammaImage) args = { new_image, gamma, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImage), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    GammaImageChannel(new_image, channels, gamma);
+    GVL_STRUCT_TYPE(GammaImageChannel) args = { new_image, channels, gamma };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -7229,30 +7609,40 @@ Image_gamma_correct(int argc, VALUE *argv, VALUE self)
     {
 #if defined(IMAGEMAGICK_7)
         BEGIN_CHANNEL_MASK(new_image, (ChannelType) (RedChannel | GreenChannel | BlueChannel));
-        GammaImage(new_image, red_gamma, exception);
+        GVL_STRUCT_TYPE(GammaImage) args = { new_image, red_gamma, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImage), &args);
         END_CHANNEL_MASK(new_image);
 #else
-        GammaImageChannel(new_image, (ChannelType) (RedChannel | GreenChannel | BlueChannel), red_gamma);
+        GVL_STRUCT_TYPE(GammaImageChannel) args = { new_image, (ChannelType) (RedChannel | GreenChannel | BlueChannel), red_gamma };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImageChannel), &args);
 #endif
     }
     else
     {
 #if defined(IMAGEMAGICK_7)
         BEGIN_CHANNEL_MASK(new_image, RedChannel);
-        GammaImage(new_image, red_gamma, exception);
+        GVL_STRUCT_TYPE(GammaImage) args1 = { new_image, red_gamma, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImage), &args1);
         END_CHANNEL_MASK(new_image);
 
         BEGIN_CHANNEL_MASK(new_image, GreenChannel);
-        GammaImage(new_image, green_gamma, exception);
+        GVL_STRUCT_TYPE(GammaImage) args2 = { new_image, green_gamma, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImage), &args2);
         END_CHANNEL_MASK(new_image);
 
         BEGIN_CHANNEL_MASK(new_image, BlueChannel);
-        GammaImage(new_image, blue_gamma, exception);
+        GVL_STRUCT_TYPE(GammaImage) args3 = { new_image, blue_gamma, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImage), &args3);
         END_CHANNEL_MASK(new_image);
 #else
-        GammaImageChannel(new_image, RedChannel, red_gamma);
-        GammaImageChannel(new_image, GreenChannel, green_gamma);
-        GammaImageChannel(new_image, BlueChannel, blue_gamma);
+        GVL_STRUCT_TYPE(GammaImageChannel) args1 = { new_image, RedChannel, red_gamma };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImageChannel), &args1);
+
+        GVL_STRUCT_TYPE(GammaImageChannel) args2 = { new_image, GreenChannel, green_gamma };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImageChannel), &args2);
+
+        GVL_STRUCT_TYPE(GammaImageChannel) args3 = { new_image, BlueChannel, blue_gamma };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GammaImageChannel), &args3);
 #endif
     }
 
@@ -7278,7 +7668,7 @@ Image_gamma_correct(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_gaussian_blur(int argc, VALUE *argv, VALUE self)
 {
-    return effect_image(self, argc, argv, GaussianBlurImage);
+    return effect_image(self, argc, argv, GVL_FUNC(GaussianBlurImage));
 }
 
 
@@ -7326,12 +7716,14 @@ Image_gaussian_blur_channel(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = GaussianBlurImage(image, radius, sigma, exception);
+    GVL_STRUCT_TYPE(GaussianBlurImage) args = { image, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GaussianBlurImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
     rm_check_exception(exception, new_image, DestroyOnError);
 #else
-    new_image = GaussianBlurImageChannel(image, channels, radius, sigma, exception);
+    GVL_STRUCT_TYPE(GaussianBlurImageChannel) args = { image, channels, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GaussianBlurImageChannel), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
 #endif
 
@@ -7350,7 +7742,7 @@ Image_gaussian_blur_channel(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_geometry(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, geometry, str);
+    IMPLEMENT_TYPED_ATTR_READER(Image, geometry, str, &rm_image_data_type);
 }
 
 
@@ -7434,7 +7826,8 @@ Image_get_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg, VALUE row
     // Cast AcquireImagePixels to get rid of the const qualifier. We're not going
     // to change the pixels but I don't want to make "pixels" const.
     exception = AcquireExceptionInfo();
-    pixels = GetVirtualPixels(image, x, y, columns, rows, exception);
+    GVL_STRUCT_TYPE(GetVirtualPixels) args = { image, x, y, columns, rows, exception };
+    pixels = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetVirtualPixels), &args);
     CHECK_EXCEPTION();
 
     DestroyExceptionInfo(exception);
@@ -7611,10 +8004,11 @@ Image_implode(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 
 #if defined(IMAGEMAGICK_7)
-    new_image = ImplodeImage(image, amount, image->interpolate, exception);
+    GVL_STRUCT_TYPE(ImplodeImage) args = { image, amount, image->interpolate, exception };
 #else
-    new_image = ImplodeImage(image, amount, exception);
+    GVL_STRUCT_TYPE(ImplodeImage) args = { image, amount, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ImplodeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -7654,7 +8048,7 @@ Image_import_pixels(int argc, VALUE *argv, VALUE self)
     Quantum *pixels = NULL;
     double *fpixels = NULL;
     void *buffer;
-    unsigned int okay;
+    MagickBooleanType okay;
 #if defined(IMAGEMAGICK_7)
     ExceptionInfo *exception;
 #endif
@@ -7791,10 +8185,11 @@ Image_import_pixels(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    okay = ImportImagePixels(image, x_off, y_off, cols, rows, map, stg_type, buffer, exception);
+    GVL_STRUCT_TYPE(ImportImagePixels) args = { image, x_off, y_off, cols, rows, map, stg_type, buffer, exception };
 #else
-    okay = ImportImagePixels(image, x_off, y_off, cols, rows, map, stg_type, buffer);
+    GVL_STRUCT_TYPE(ImportImagePixels) args = { image, x_off, y_off, cols, rows, map, stg_type, buffer };
 #endif
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ImportImagePixels), &args);
 
     // Free pixel array before checking for errors.
     if (pixels)
@@ -7981,7 +8376,7 @@ Image_inspect(VALUE self)
     Image *image;
     char buffer[MaxTextExtent];          // image description buffer
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
     if (!image)
     {
         return rb_str_new2("#<Magick::Image: (destroyed)>");
@@ -8074,12 +8469,12 @@ Image_iptc_profile_eq(VALUE self, VALUE profile)
 VALUE
 Image_iterations(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, iterations, int);
+    IMPLEMENT_TYPED_ATTR_READER(Image, iterations, int, &rm_image_data_type);
 }
 VALUE
 Image_iterations_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITER(Image, iterations, int);
+    IMPLEMENT_TYPED_ATTR_WRITER(Image, iterations, int, &rm_image_data_type);
 }
 
 /**
@@ -8130,12 +8525,14 @@ Image_level2(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    LevelImage(new_image, black_point, white_point, gamma_val, exception);
+    GVL_STRUCT_TYPE(LevelImage) args = { new_image, black_point, white_point, gamma_val, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LevelImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
     snprintf(level, sizeof(level), "%gx%g+%g", black_point, white_point, gamma_val);
-    LevelImage(new_image, level);
+    GVL_STRUCT_TYPE(LevelImage) args = { new_image, level };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LevelImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -8194,12 +8591,14 @@ Image_level_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channel);
-    LevelImage(new_image, black_point, white_point, gamma_val, exception);
+    GVL_STRUCT_TYPE(LevelImage) args = { new_image, black_point, white_point, gamma_val, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LevelImage), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    LevelImageChannel(new_image, channel, black_point, white_point, gamma_val);
+    GVL_STRUCT_TYPE(LevelImageChannel) args = { new_image, channel, black_point, white_point, gamma_val };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LevelImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -8275,12 +8674,14 @@ Image_level_colors(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    status = LevelImageColors(new_image, &black_color, &white_color, invert, exception);
+    GVL_STRUCT_TYPE(LevelImageColors) args = { new_image, &black_color, &white_color, invert, exception };
+    status = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LevelImageColors), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    status = LevelColorsImageChannel(new_image, channels, &black_color, &white_color, invert);
+    GVL_STRUCT_TYPE(LevelColorsImageChannel) args = { new_image, channels, &black_color, &white_color, invert };
+    status = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LevelColorsImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
     if (!status)
@@ -8350,12 +8751,14 @@ Image_levelize_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    status = LevelizeImage(new_image, black_point, white_point, gamma, exception);
+    GVL_STRUCT_TYPE(LevelizeImage) args = { new_image, black_point, white_point, gamma, exception };
+    status = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LevelizeImage), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    status = LevelizeImageChannel(new_image, channels, black_point, white_point, gamma);
+    GVL_STRUCT_TYPE(LevelizeImageChannel) args = { new_image, channels, black_point, white_point, gamma };
+    status = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LevelizeImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -8396,11 +8799,13 @@ Image_linear_stretch(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    LinearStretchImage(new_image, black_point, white_point, exception);
+    GVL_STRUCT_TYPE(LinearStretchImage) args = { new_image, black_point, white_point, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LinearStretchImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    LinearStretchImage(new_image, black_point, white_point);
+    GVL_STRUCT_TYPE(LinearStretchImage) args = { new_image, black_point, white_point };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LinearStretchImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -8446,7 +8851,8 @@ Image_liquid_rescale(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = LiquidRescaleImage(image, cols, rows, delta_x, rigidity, exception);
+    GVL_STRUCT_TYPE(LiquidRescaleImage) args = { image, cols, rows, delta_x, rigidity, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(LiquidRescaleImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -8514,7 +8920,8 @@ Image__load(VALUE class ATTRIBUTE_UNUSED, VALUE str)
 
     blob += offsetof(DumpedImage, magick) + mi.len;
     length -= offsetof(DumpedImage, magick) + mi.len;
-    image = BlobToImage(info, blob, (size_t) length, exception);
+    GVL_STRUCT_TYPE(BlobToImage) args = { info, blob, (size_t)length, exception };
+    image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlobToImage), &args);
     DestroyImageInfo(info);
 
     rm_check_exception(exception, image, DestroyOnError);
@@ -8524,6 +8931,9 @@ Image__load(VALUE class ATTRIBUTE_UNUSED, VALUE str)
 }
 
 
+// aliases for common use of structure types; MagnifyImage, MinifyImage
+typedef GVL_STRUCT_TYPE(MagnifyImage) GVL_STRUCT_TYPE(magnify);
+
 /**
  * Scale an image proportionally to twice its size.
  *
@@ -8535,16 +8945,17 @@ Image__load(VALUE class ATTRIBUTE_UNUSED, VALUE str)
  * @return self if bang, otherwise a new image
  */
 static VALUE
-magnify(int bang, VALUE self, magnifier_t magnifier)
+magnify(int bang, VALUE self, gvl_function_t fp)
 {
     Image *image;
     Image *new_image;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
     exception = AcquireExceptionInfo();
 
-    new_image = (magnifier)(image, exception);
+    GVL_STRUCT_TYPE(magnify) args = { image, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     DestroyExceptionInfo(exception);
@@ -8571,7 +8982,7 @@ VALUE
 Image_magnify(VALUE self)
 {
     rm_check_destroyed(self);
-    return magnify(False, self, MagnifyImage);
+    return magnify(False, self, GVL_FUNC(MagnifyImage));
 }
 
 
@@ -8586,7 +8997,7 @@ VALUE
 Image_magnify_bang(VALUE self)
 {
     rm_check_frozen(self);
-    return magnify(True, self, MagnifyImage);
+    return magnify(True, self, GVL_FUNC(MagnifyImage));
 }
 
 
@@ -8618,7 +9029,8 @@ Image_marshal_dump(VALUE self)
     rb_ary_store(ary, 0, rb_str_new2(image->filename));
 
     exception = AcquireExceptionInfo();
-    blob = ImageToBlob(info, image, &length, exception);
+    GVL_STRUCT_TYPE(ImageToBlob) args = { info, image, &length, exception };
+    blob = (unsigned char *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ImageToBlob), &args);
 
     // Destroy info before raising an exception
     DestroyImageInfo(info);
@@ -8663,7 +9075,8 @@ Image_marshal_load(VALUE self, VALUE ary)
     {
         strlcpy(info->filename, RSTRING_PTR(filename), sizeof(info->filename));
     }
-    image = BlobToImage(info, RSTRING_PTR(blob), RSTRING_LEN(blob), exception);
+    GVL_STRUCT_TYPE(BlobToImage) args = { info, RSTRING_PTR(blob), RSTRING_LEN(blob), exception };
+    image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlobToImage), &args);
 
     // Destroy info before raising an exception
     DestroyImageInfo(info);
@@ -8696,9 +9109,11 @@ get_image_mask(Image *image)
 
     // The returned clip mask is a clone, ours to keep.
 #if defined(IMAGEMAGICK_7)
-    mask = GetImageMask(image, WritePixelMask, exception);
+    GVL_STRUCT_TYPE(GetImageMask) args = { image, WritePixelMask, exception };
+    mask = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageMask), &args);
 #else
-    mask = GetImageClipMask(image, exception);
+    GVL_STRUCT_TYPE(GetImageClipMask) args = { image, exception };
+    mask = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetImageClipMask), &args);
 #endif
     rm_check_exception(exception, mask, DestroyOnError);
 
@@ -8736,19 +9151,22 @@ set_image_mask(Image *image, VALUE mask)
         // Resize if necessary
         if (clip_mask->columns != image->columns || clip_mask->rows != image->rows)
         {
-            resized_image = ResizeImage(clip_mask, image->columns, image->rows, image->filter, exception);
+            GVL_STRUCT_TYPE(ResizeImage) args = { clip_mask, image->columns, image->rows, image->filter, exception };
+            resized_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResizeImage), &args);
             DestroyImage(clip_mask);
             rm_check_exception(exception, resized_image, DestroyOnError);
             rm_ensure_result(resized_image);
             clip_mask = resized_image;
         }
 
-        SetImageMask(image, WritePixelMask, clip_mask, exception);
+        GVL_STRUCT_TYPE(SetImageMask) args = { image, WritePixelMask, clip_mask, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageMask), &args);
         DestroyImage(clip_mask);
     }
     else
     {
-        SetImageMask(image, WritePixelMask, NULL, exception);
+        GVL_STRUCT_TYPE(SetImageMask) args = { image, WritePixelMask, NULL, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageMask), &args);
     }
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
@@ -8776,8 +9194,8 @@ set_image_mask(Image *image, VALUE mask)
         if (clip_mask->columns != image->columns || clip_mask->rows != image->rows)
         {
             exception = AcquireExceptionInfo();
-            resized_image = ResizeImage(clip_mask, image->columns, image->rows,
-                                        UndefinedFilter, 0.0, exception);
+            GVL_STRUCT_TYPE(ResizeImage) args = { clip_mask, image->columns, image->rows, UndefinedFilter, 0.0, exception };
+            resized_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResizeImage), &args);
             rm_check_exception(exception, resized_image, DestroyOnError);
             DestroyExceptionInfo(exception);
             rm_ensure_result(resized_image);
@@ -8790,7 +9208,8 @@ set_image_mask(Image *image, VALUE mask)
 
         for (y = 0; y < (long) clip_mask->rows; y++)
         {
-            q = GetAuthenticPixels(clip_mask, 0, y, clip_mask->columns, 1, exception);
+            GVL_STRUCT_TYPE(GetAuthenticPixels) args_GetAuthenticPixels = { clip_mask, 0, y, clip_mask->columns, 1, exception };
+            q = (PixelPacket *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetAuthenticPixels), &args_GetAuthenticPixels);
             rm_check_exception(exception, clip_mask, DestroyOnError);
 
             if (!q)
@@ -8809,12 +9228,14 @@ set_image_mask(Image *image, VALUE mask)
                 q += 1;
             }
 
-            SyncAuthenticPixels(clip_mask, exception);
+            GVL_STRUCT_TYPE(SyncAuthenticPixels) args_SyncAuthenticPixels = { clip_mask, exception };
+            CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args_SyncAuthenticPixels);
             rm_check_exception(exception, clip_mask, DestroyOnError);
         }
         DestroyExceptionInfo(exception);
 
-        SetImageStorageClass(clip_mask, DirectClass);
+        GVL_STRUCT_TYPE(SetImageStorageClass) args_SetImageStorageClass = { clip_mask, DirectClass };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args_SetImageStorageClass);
         rm_check_image_exception(clip_mask, DestroyOnError);
 
         clip_mask->matte = MagickTrue;
@@ -8822,12 +9243,14 @@ set_image_mask(Image *image, VALUE mask)
         // SetImageClipMask clones the clip_mask image. We can
         // destroy our copy after SetImageClipMask is done with it.
 
-        SetImageClipMask(image, clip_mask);
+        GVL_STRUCT_TYPE(SetImageClipMask) args_SetImageClipMask = { image, clip_mask };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageClipMask), &args_SetImageClipMask);
         DestroyImage(clip_mask);
     }
     else
     {
-        SetImageClipMask(image, NULL);
+        GVL_STRUCT_TYPE(SetImageClipMask) args_SetImageClipMask = { image, NULL };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageClipMask), &args_SetImageClipMask);
     }
 
     RB_GC_GUARD(mask);
@@ -8968,7 +9391,7 @@ Image_matte_flood_fill(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eNoMemError, "not enough memory to continue");
     }
 #if defined(IMAGEMAGICK_7)
-    draw_info->fill.alpha = alpha;
+    rm_set_pixelinfo_alpha(&draw_info->fill, alpha);
 #else
     draw_info->fill.opacity = QuantumRange - alpha;
 #endif
@@ -8979,6 +9402,11 @@ Image_matte_flood_fill(int argc, VALUE *argv, VALUE self)
         target_mpp.red   = (MagickRealType) image->border_color.red;
         target_mpp.green = (MagickRealType) image->border_color.green;
         target_mpp.blue  = (MagickRealType) image->border_color.blue;
+#if defined(IMAGEMAGICK_7)
+        rm_set_pixelinfo_alpha(&target_mpp, (MagickRealType) image->border_color.alpha);
+#else
+        target_mpp.opacity = (MagickRealType) image->border_color.opacity;
+#endif
     }
     else
     {
@@ -8986,18 +9414,25 @@ Image_matte_flood_fill(int argc, VALUE *argv, VALUE self)
         target_mpp.red   = (MagickRealType) target.red;
         target_mpp.green = (MagickRealType) target.green;
         target_mpp.blue  = (MagickRealType) target.blue;
+#if defined(IMAGEMAGICK_7)
+        rm_set_pixelinfo_alpha(&target_mpp, (MagickRealType) target.alpha);
+#else
+        target_mpp.opacity = (MagickRealType) target.opacity;
+#endif
     }
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, OpacityChannel);
-    FloodfillPaintImage(new_image, draw_info, &target_mpp, x, y, invert, exception);
+    GVL_STRUCT_TYPE(FloodfillPaintImage) args = { new_image, draw_info, &target_mpp, x, y, invert, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FloodfillPaintImage), &args);
     END_CHANNEL_MASK(new_image);
     DestroyDrawInfo(draw_info);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    FloodfillPaintImage(new_image, OpacityChannel, draw_info, &target_mpp, x, y, invert);
+    GVL_STRUCT_TYPE(FloodfillPaintImage) args = { new_image, OpacityChannel, draw_info, &target_mpp, x, y, invert };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FloodfillPaintImage), &args);
     DestroyDrawInfo(draw_info);
 
     rm_check_image_exception(new_image, DestroyOnError);
@@ -9035,7 +9470,8 @@ Image_median_filter(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = StatisticImage(image, MedianStatistic, (size_t)radius, (size_t)radius, exception);
+    GVL_STRUCT_TYPE(StatisticImage) args = { image, MedianStatistic, (size_t)radius, (size_t)radius, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(StatisticImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -9051,7 +9487,7 @@ Image_median_filter(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_mean_error_per_pixel(VALUE self)
 {
-    IMPLEMENT_ATTR_READERF(Image, mean_error_per_pixel, error.mean_error_per_pixel, dbl);
+    IMPLEMENT_TYPED_ATTR_READERF(Image, mean_error_per_pixel, error.mean_error_per_pixel, dbl, &rm_image_data_type);
 }
 
 
@@ -9094,7 +9530,7 @@ VALUE
 Image_minify(VALUE self)
 {
     rm_check_destroyed(self);
-    return magnify(False, self, MinifyImage);
+    return magnify(False, self, GVL_FUNC(MinifyImage));
 }
 
 
@@ -9108,7 +9544,7 @@ VALUE
 Image_minify_bang(VALUE self)
 {
     rm_check_frozen(self);
-    return magnify(True, self, MinifyImage);
+    return magnify(True, self, GVL_FUNC(MinifyImage));
 }
 
 
@@ -9160,11 +9596,13 @@ Image_modulate(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    ModulateImage(new_image, modulate, exception);
+    GVL_STRUCT_TYPE(ModulateImage) args = { new_image, modulate, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ModulateImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    ModulateImage(new_image, modulate);
+    GVL_STRUCT_TYPE(ModulateImage) args = { new_image, modulate };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ModulateImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -9172,39 +9610,6 @@ Image_modulate(int argc, VALUE *argv, VALUE self)
 }
 
 
-/**
- * Establish a progress monitor.
- *
- * - A progress monitor is a callable object. Save the monitor proc as the client_data and establish
- *   `progress_monitor' as the monitor exit. When `progress_monitor' is called, retrieve the proc
- *   and call it.
- *
- * @param monitor [Proc] the progress monitor
- * @return [Proc] the given value
- * @example
- *   img.monitor = Proc.new do |method, offset, span|
- *     print "%s is %3.0f%% complete.\n", method, (offset.to_f/span)*100)
- *     true
- *   end
- */
-VALUE
-Image_monitor_eq(VALUE self, VALUE monitor)
-{
-    Image *image = rm_check_frozen(self);
-
-    if (NIL_P(monitor))
-    {
-        image->progress_monitor = NULL;
-    }
-    else
-    {
-        SetImageProgressMonitor(image, rm_progress_monitor, (void *)monitor);
-    }
-
-    return monitor;
-}
-
-
 /**
  * Return true if all the pixels in the image have the same red, green, and blue intensities and the
  * intensity is either 0 or {Magick::QuantumRange}.
@@ -9230,10 +9635,13 @@ Image_monochrome_q(VALUE self)
 VALUE
 Image_montage(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, montage, str);
+    IMPLEMENT_TYPED_ATTR_READER(Image, montage, str, &rm_image_data_type);
 }
 
 
+// aliases for common use of structure types; MotionBlurImage, SketchImage
+typedef GVL_STRUCT_TYPE(MotionBlurImage) GVL_STRUCT_TYPE(motion_blur);
+
 /**
  * Called from Image_motion_blur and Image_sketch.
  *
@@ -9248,8 +9656,7 @@ Image_montage(VALUE self)
  * @see Image_sketch
  */
 static VALUE
-motion_blur(int argc, VALUE *argv, VALUE self,
-            Image *fp(const Image *, const double, const double, const double, ExceptionInfo *))
+motion_blur(int argc, VALUE *argv, VALUE self, gvl_function_t fp)
 {
     Image *image, *new_image;
     double radius = 0.0;
@@ -9277,10 +9684,11 @@ motion_blur(int argc, VALUE *argv, VALUE self,
         rb_raise(rb_eArgError, "sigma must be != 0.0");
     }
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     exception = AcquireExceptionInfo();
-    new_image = (fp)(image, radius, sigma, angle, exception);
+    GVL_STRUCT_TYPE(motion_blur) args = { image, radius, sigma, angle, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -9304,7 +9712,7 @@ VALUE
 Image_motion_blur(int argc, VALUE *argv, VALUE self)
 {
     rm_check_destroyed(self);
-    return motion_blur(argc, argv, self, MotionBlurImage);
+    return motion_blur(argc, argv, self, GVL_FUNC(MotionBlurImage));
 }
 
 
@@ -9339,11 +9747,13 @@ Image_negate(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    NegateImage(new_image, grayscale, exception);
+    GVL_STRUCT_TYPE(NegateImage) args = { new_image, grayscale, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NegateImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    NegateImage(new_image, grayscale);
+    GVL_STRUCT_TYPE(NegateImage) args = { new_image, grayscale };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NegateImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -9396,12 +9806,14 @@ Image_negate_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    NegateImage(new_image, grayscale, exception);
+    GVL_STRUCT_TYPE(NegateImage) args = { new_image, grayscale, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NegateImage), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    NegateImageChannel(new_image, channels, grayscale);
+    GVL_STRUCT_TYPE(NegateImageChannel) args = { new_image, channels, grayscale };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NegateImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -9419,7 +9831,7 @@ Image_alloc(VALUE class)
 {
     VALUE image_obj;
 
-    image_obj = Data_Wrap_Struct(class, NULL, rm_image_destroy, NULL);
+    image_obj = TypedData_Wrap_Struct(class, &rm_image_data_type, NULL);
 
     RB_GC_GUARD(image_obj);
 
@@ -9463,7 +9875,7 @@ Image_initialize(int argc, VALUE *argv, VALUE self)
 
     // Create a new Info object to use when creating this image.
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
 
     image = rm_acquire_image(info);
     if (!image)
@@ -9478,11 +9890,13 @@ Image_initialize(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SetImageExtent(image, cols, rows, exception);
+    GVL_STRUCT_TYPE(SetImageExtent) args = { image, cols, rows, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageExtent), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    SetImageExtent(image, cols, rows);
+    GVL_STRUCT_TYPE(SetImageExtent) args = { image, cols, rows };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageExtent), &args);
 #endif
 
     // If the caller did not supply a fill argument, call SetImageBackgroundColor
@@ -9492,11 +9906,13 @@ Image_initialize(int argc, VALUE *argv, VALUE self)
     {
 #if defined(IMAGEMAGICK_7)
         exception = AcquireExceptionInfo();
-        SetImageBackgroundColor(image, exception);
+        GVL_STRUCT_TYPE(SetImageBackgroundColor) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageBackgroundColor), &args);
         CHECK_EXCEPTION();
         DestroyExceptionInfo(exception);
 #else
-        SetImageBackgroundColor(image);
+        GVL_STRUCT_TYPE(SetImageBackgroundColor) args = { image };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageBackgroundColor), &args);
 #endif
     }
     // fillobj.fill(self)
@@ -9529,9 +9945,7 @@ rm_image_new(Image *image)
 {
     rm_ensure_result(image);
 
-    rm_trace_creation(image);
-
-    return Data_Wrap_Struct(Class_Image, NULL, rm_image_destroy, image);
+    return TypedData_Wrap_Struct(Class_Image, &rm_image_data_type, image);
 }
 
 
@@ -9554,11 +9968,13 @@ Image_normalize(VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    NormalizeImage(new_image, exception);
+    GVL_STRUCT_TYPE(NormalizeImage) args = { new_image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NormalizeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    NormalizeImage(new_image);
+    GVL_STRUCT_TYPE(NormalizeImage) args = { new_image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NormalizeImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -9596,12 +10012,14 @@ Image_normalize_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    NormalizeImage(new_image, exception);
+    GVL_STRUCT_TYPE(NormalizeImage) args = { new_image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NormalizeImage), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    NormalizeImageChannel(new_image, channels);
+    GVL_STRUCT_TYPE(NormalizeImageChannel) args = { new_image, channels };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(NormalizeImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -9617,7 +10035,7 @@ Image_normalize_channel(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_normalized_mean_error(VALUE self)
 {
-    IMPLEMENT_ATTR_READERF(Image, normalized_mean_error, error.normalized_mean_error, dbl);
+    IMPLEMENT_TYPED_ATTR_READERF(Image, normalized_mean_error, error.normalized_mean_error, dbl, &rm_image_data_type);
 }
 
 /**
@@ -9628,7 +10046,7 @@ Image_normalized_mean_error(VALUE self)
 VALUE
 Image_normalized_maximum_error(VALUE self)
 {
-    IMPLEMENT_ATTR_READERF(Image, normalized_maximum_error, error.normalized_maximum_error, dbl);
+    IMPLEMENT_TYPED_ATTR_READERF(Image, normalized_maximum_error, error.normalized_maximum_error, dbl, &rm_image_data_type);
 }
 
 
@@ -9642,12 +10060,13 @@ Image_number_colors(VALUE self)
 {
     Image *image;
     ExceptionInfo *exception;
-    unsigned long n = 0;
+    size_t n = 0;
 
     image = rm_check_destroyed(self);
     exception = AcquireExceptionInfo();
 
-    n = (unsigned long) GetNumberColors(image, NULL, exception);
+    GVL_STRUCT_TYPE(GetNumberColors) args = { image, NULL, exception };
+    n = (size_t)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetNumberColors), &args);
     CHECK_EXCEPTION();
 
     DestroyExceptionInfo(exception);
@@ -9664,7 +10083,7 @@ Image_number_colors(VALUE self)
 VALUE
 Image_offset(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, offset, long);
+    IMPLEMENT_TYPED_ATTR_READER(Image, offset, long, &rm_image_data_type);
 }
 
 /**
@@ -9676,7 +10095,7 @@ Image_offset(VALUE self)
 VALUE
 Image_offset_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITER(Image, offset, long);
+    IMPLEMENT_TYPED_ATTR_WRITER(Image, offset, long, &rm_image_data_type);
 }
 
 
@@ -9712,10 +10131,11 @@ Image_oil_paint(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 
 #if defined(IMAGEMAGICK_7)
-    new_image = OilPaintImage(image, radius, sigma, exception);
+    GVL_STRUCT_TYPE(OilPaintImage) args = { image, radius, sigma, exception };
 #else
-    new_image = OilPaintImage(image, radius, exception);
+    GVL_STRUCT_TYPE(OilPaintImage) args = { image, radius, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OilPaintImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -9756,11 +10176,13 @@ Image_opaque(VALUE self, VALUE target, VALUE fill)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    okay = OpaquePaintImage(new_image, &target_pp, &fill_pp, MagickFalse, exception);
+    GVL_STRUCT_TYPE(OpaquePaintImage) args = { new_image, &target_pp, &fill_pp, MagickFalse, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OpaquePaintImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    okay = OpaquePaintImageChannel(new_image, DefaultChannels, &target_pp, &fill_pp, MagickFalse);
+    GVL_STRUCT_TYPE(OpaquePaintImageChannel) args = { new_image, DefaultChannels, &target_pp, &fill_pp, MagickFalse };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OpaquePaintImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -9846,13 +10268,15 @@ Image_opaque_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    okay = OpaquePaintImage(new_image, &target_pp, &fill_pp, invert, exception);
+    GVL_STRUCT_TYPE(OpaquePaintImage) args = { new_image, &target_pp, &fill_pp, invert, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OpaquePaintImage), &args);
     END_CHANNEL_MASK(new_image);
     new_image->fuzz = keep;
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    okay = OpaquePaintImageChannel(new_image, channels, &target_pp, &fill_pp, invert);
+    GVL_STRUCT_TYPE(OpaquePaintImageChannel) args = { new_image, channels, &target_pp, &fill_pp, invert };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OpaquePaintImageChannel), &args);
 
     new_image->fuzz = keep;
     rm_check_image_exception(new_image, DestroyOnError);
@@ -9937,7 +10361,13 @@ Image_ordered_dither(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 
-    OrderedDitherImage(new_image, threshold_map, exception);
+#if defined(IMAGEMAGICK_7)
+    GVL_STRUCT_TYPE(OrderedDitherImage) args = { new_image, threshold_map, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OrderedDitherImage), &args);
+#else
+    GVL_STRUCT_TYPE(OrderedPosterizeImage) args = { new_image, threshold_map, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(OrderedPosterizeImage), &args);
+#endif
     rm_check_exception(exception, new_image, DestroyOnError);
 
     DestroyExceptionInfo(exception);
@@ -10072,12 +10502,14 @@ Image_paint_transparent(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    okay = TransparentPaintImage(new_image, (const MagickPixel *)&color, alpha, invert, exception);
+    GVL_STRUCT_TYPE(TransparentPaintImage) args = { new_image, (const MagickPixel *)&color, alpha, invert, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TransparentPaintImage), &args);
     new_image->fuzz = keep;
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    okay = TransparentPaintImage(new_image, (const MagickPixel *)&color, QuantumRange - alpha, invert);
+    GVL_STRUCT_TYPE(TransparentPaintImage) args = { new_image, (const MagickPixel *)&color, QuantumRange - alpha, invert };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TransparentPaintImage), &args);
     new_image->fuzz = keep;
 
     // Is it possible for TransparentPaintImage to silently fail?
@@ -10120,7 +10552,7 @@ Image_palette_q(VALUE self)
 VALUE
 Image_ping(VALUE class, VALUE file_arg)
 {
-    return rd_image(class, file_arg, PingImage);
+    return rd_image(class, file_arg, GVL_FUNC(PingImage));
 }
 
 
@@ -10186,7 +10618,8 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
     if (!set)
     {
         exception = AcquireExceptionInfo();
-        old_pixel = GetVirtualPixels(image, x, y, 1, 1, exception);
+        GVL_STRUCT_TYPE(GetVirtualPixels) args = { image, x, y, 1, 1, exception };
+        old_pixel = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetVirtualPixels), &args);
         CHECK_EXCEPTION();
 
         DestroyExceptionInfo(exception);
@@ -10238,7 +10671,8 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
     if (image->storage_class == PseudoClass)
     {
 #if defined(IMAGEMAGICK_7)
-        okay = SetImageStorageClass(image, DirectClass, exception);
+        GVL_STRUCT_TYPE(SetImageStorageClass) args = { image, DirectClass, exception };
+        okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args);
         CHECK_EXCEPTION();
         if (!okay)
         {
@@ -10246,7 +10680,8 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
             rb_raise(Class_ImageMagickError, "SetImageStorageClass failed. Can't set pixel color.");
         }
 #else
-        okay = SetImageStorageClass(image, DirectClass);
+        GVL_STRUCT_TYPE(SetImageStorageClass) args = { image, DirectClass };
+        okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args);
         rm_check_image_exception(image, RetainOnError);
         if (!okay)
         {
@@ -10259,7 +10694,8 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #endif
 
-    pixel = GetAuthenticPixels(image, x, y, 1, 1, exception);
+    GVL_STRUCT_TYPE(GetAuthenticPixels) args = { image, x, y, 1, 1, exception };
+    pixel = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetAuthenticPixels), &args);
     CHECK_EXCEPTION();
 
     if (pixel)
@@ -10294,7 +10730,8 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
         }
 #endif
 
-        SyncAuthenticPixels(image, exception);
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
         CHECK_EXCEPTION();
     }
 
@@ -10349,11 +10786,11 @@ Image_pixel_interpolation_method_eq(VALUE self, VALUE method)
  *   If present a block, optional arguments may be specified in a block associated with the method.
  *   These arguments control the shadow color and how the label is rendered.
  *   By default the shadow color is gray75. To specify a different shadow color,
- *   use self.shadow_color.
- *   To specify a different border color (that is, the color of the image border) use self.border_color.
+ *   use options.shadow_color.
+ *   To specify a different border color (that is, the color of the image border) use options.border_color.
  *   Both of these methods accept either a color name or a Pixel argument.
  *   @param angle [Float] The resulting image is rotated by this amount, measured in degrees.
- *   @yield []
+ *   @yield [Magick::Image::Info]
  *
  * @return [Magick::Image] a new image
  */
@@ -10383,7 +10820,7 @@ Image_polaroid(int argc, VALUE *argv, VALUE self)
     }
 
     options = rm_polaroid_new();
-    Data_Get_Struct(options, Draw, draw);
+    TypedData_Get_Struct(options, Draw, &rm_draw_data_type, draw);
 
     clone = rm_clone_image(image);
     clone->background_color = draw->shadow_color;
@@ -10392,9 +10829,11 @@ Image_polaroid(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     caption = GetImageProperty(clone, "Caption", exception);
-    new_image = PolaroidImage(clone, draw->info, caption, angle, image->interpolate, exception);
+    GVL_STRUCT_TYPE(PolaroidImage) args = { clone, draw->info, caption, angle, image->interpolate, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(PolaroidImage), &args);
 #else
-    new_image = PolaroidImage(clone, draw->info, angle, exception);
+    GVL_STRUCT_TYPE(PolaroidImage) args = { clone, draw->info, angle, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(PolaroidImage), &args);
 #endif
     rm_check_exception(exception, clone, DestroyOnError);
 
@@ -10446,11 +10885,13 @@ Image_posterize(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     dither_method = dither ? RiemersmaDitherMethod : NoDitherMethod;
-    PosterizeImage(new_image, levels, dither_method, exception);
+    GVL_STRUCT_TYPE(PosterizeImage) args = { new_image, levels, dither_method, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(PosterizeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    PosterizeImage(new_image, levels, dither);
+    GVL_STRUCT_TYPE(PosterizeImage) args = { new_image, levels, dither };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(PosterizeImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -10476,7 +10917,8 @@ Image_preview(VALUE self, VALUE preview)
     VALUE_TO_ENUM(preview, preview_type, PreviewType);
 
     exception = AcquireExceptionInfo();
-    new_image = PreviewImage(image, preview_type, exception);
+    GVL_STRUCT_TYPE(PreviewImage) args = { image, preview_type, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(PreviewImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     DestroyExceptionInfo(exception);
@@ -10517,7 +10959,7 @@ Image_profile_bang(VALUE self, VALUE name, VALUE profile)
 VALUE
 Image_quality(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, quality, ulong);
+    IMPLEMENT_TYPED_ATTR_READER(Image, quality, ulong, &rm_image_data_type);
 }
 
 
@@ -10703,10 +11145,12 @@ Image_quantum_operator(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channel);
-    EvaluateImage(image, qop, rvalue, exception);
+    GVL_STRUCT_TYPE(EvaluateImage) args = { image, qop, rvalue, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EvaluateImage), &args);
     END_CHANNEL_MASK(image);
 #else
-    EvaluateImageChannel(image, channel, qop, rvalue, exception);
+    GVL_STRUCT_TYPE(EvaluateImageChannel) args = { image, channel, qop, rvalue, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(EvaluateImageChannel), &args);
 #endif
     CHECK_EXCEPTION();
 
@@ -10783,11 +11227,13 @@ Image_quantize(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    QuantizeImage(&quantize_info, new_image, exception);
+    GVL_STRUCT_TYPE(QuantizeImage) args = { &quantize_info, new_image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(QuantizeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    QuantizeImage(&quantize_info, new_image);
+    GVL_STRUCT_TYPE(QuantizeImage) args = { &quantize_info, new_image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(QuantizeImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -10812,9 +11258,11 @@ Image_radial_blur(VALUE self, VALUE angle_obj)
     exception = AcquireExceptionInfo();
 
 #if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
-    new_image = RotationalBlurImage(image, angle, exception);
+    GVL_STRUCT_TYPE(RotationalBlurImage) args = { image, angle, exception };
+    new_image = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RotationalBlurImage), &args);
 #else
-    new_image = RadialBlurImage(image, angle, exception);
+    GVL_STRUCT_TYPE(RadialBlurImage) args = { image, angle, exception };
+    new_image = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RadialBlurImage), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -10862,13 +11310,16 @@ Image_radial_blur_channel(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = RotationalBlurImage(image, angle, exception);
+    GVL_STRUCT_TYPE(RotationalBlurImage) args = { image, angle, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RotationalBlurImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #elif defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
-    new_image = RotationalBlurImageChannel(image, channels, angle, exception);
+    GVL_STRUCT_TYPE(RotationalBlurImageChannel) args = { image, channels, angle, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RotationalBlurImageChannel), &args);
 #else
-    new_image = RadialBlurImageChannel(image, channels, angle, exception);
+    GVL_STRUCT_TYPE(RadialBlurImageChannel) args = { image, channels, angle, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RadialBlurImageChannel), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -10929,11 +11380,13 @@ Image_random_threshold_channel(int argc, VALUE *argv, VALUE self)
         GeometryInfo geometry_info;
 
         ParseGeometry(thresholds, &geometry_info);
-        RandomThresholdImage(new_image, geometry_info.rho, geometry_info.sigma, exception);
+        GVL_STRUCT_TYPE(RandomThresholdImage) args = { new_image, geometry_info.rho, geometry_info.sigma, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RandomThresholdImage), &args);
     }
     END_CHANNEL_MASK(new_image);
 #else
-    RandomThresholdImageChannel(new_image, channels, thresholds, exception);
+    GVL_STRUCT_TYPE(RandomThresholdImageChannel) args = { new_image, channels, thresholds, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RandomThresholdImageChannel), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
 
@@ -10990,11 +11443,13 @@ Image_raise(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    RaiseImage(new_image, &rect, raised, exception);
+    GVL_STRUCT_TYPE(RaiseImage) args = { new_image, &rect, raised, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RaiseImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    RaiseImage(new_image, &rect, raised);
+    GVL_STRUCT_TYPE(RaiseImage) args = { new_image, &rect, raised };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RaiseImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -11011,7 +11466,7 @@ Image_raise(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_read(VALUE class, VALUE file_arg)
 {
-    return rd_image(class, file_arg, ReadImage);
+    return rd_image(class, file_arg, GVL_FUNC(ReadImage));
 }
 
 
@@ -11031,6 +11486,9 @@ file_arg_rescue(VALUE arg, VALUE raised_exc ATTRIBUTE_UNUSED)
 }
 
 
+// aliases for common use of structure types; PingImage, ReadImage
+typedef GVL_STRUCT_TYPE(PingImage) GVL_STRUCT_TYPE(rd_image);
+
 /**
  * Transform arguments, call either ReadImage or PingImage.
  *
@@ -11056,7 +11514,7 @@ void sig_handler(int sig ATTRIBUTE_UNUSED)
 #endif
 
 static VALUE
-rd_image(VALUE class ATTRIBUTE_UNUSED, VALUE file, reader_t reader)
+rd_image(VALUE class ATTRIBUTE_UNUSED, VALUE file, gvl_function_t fp)
 {
     char *filename;
     long filename_l;
@@ -11067,7 +11525,7 @@ rd_image(VALUE class ATTRIBUTE_UNUSED, VALUE file, reader_t reader)
 
     // Create a new Info structure for this read/ping
     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)
     {
@@ -11107,7 +11565,8 @@ rd_image(VALUE class ATTRIBUTE_UNUSED, VALUE file, reader_t reader)
     }
 #endif
 
-    images = (reader)(info, exception);
+    GVL_STRUCT_TYPE(rd_image) args = { info, exception };
+    images = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
 
 #if defined(__APPLE__) || defined(__FreeBSD__)
     if (sigaction(SIGCHLD, &oldact, NULL) < 0)
@@ -11192,7 +11651,8 @@ Image_recolor(VALUE self, VALUE color_matrix)
     kernel_info->height = order;
     kernel_info->values = (double *) matrix;
 
-    new_image = ColorMatrixImage(image, kernel_info, exception);
+    GVL_STRUCT_TYPE(ColorMatrixImage) args = { image, kernel_info, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ColorMatrixImage), &args);
     kernel_info->values = (double *) NULL;
     DestroyKernelInfo(kernel_info);
     xfree((void *) matrix);
@@ -11239,7 +11699,8 @@ Image_read_inline(VALUE self ATTRIBUTE_UNUSED, VALUE content)
         image_data += x + 1;
     }
 
-    blob = Base64Decode(image_data, &blob_l);
+    GVL_STRUCT_TYPE(Base64Decode) args_Base64Decode = { image_data, &blob_l };
+    blob = (unsigned char *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(Base64Decode), &args_Base64Decode);
     if (blob_l == 0)
     {
         rb_raise(rb_eArgError, "can't decode image");
@@ -11250,9 +11711,10 @@ Image_read_inline(VALUE self ATTRIBUTE_UNUSED, VALUE content)
     // Create a new Info structure for this read. About the
     // only useful attribute that can be set is `format'.
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
 
-    images = BlobToImage(info, blob, blob_l, exception);
+    GVL_STRUCT_TYPE(BlobToImage) args_BlobToImage = { info, blob, blob_l, exception };
+    images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlobToImage), &args_BlobToImage);
     magick_free((void *)blob);
 
     rm_check_exception(exception, images, DestroyOnError);
@@ -11314,7 +11776,8 @@ Image_reduce_noise(VALUE self, VALUE radius)
     image = rm_check_destroyed(self);
 
     exception = AcquireExceptionInfo();
-    new_image = StatisticImage(image, NonpeakStatistic, radius_size, radius_size, exception);
+    GVL_STRUCT_TYPE(StatisticImage) args = { image, NonpeakStatistic, radius_size, radius_size, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(StatisticImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     DestroyExceptionInfo(exception);
@@ -11366,11 +11829,13 @@ Image_remap(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    RemapImage(&quantize_info, image, remap_image, exception);
+    GVL_STRUCT_TYPE(RemapImage) args = { &quantize_info, image, remap_image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RemapImage), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    RemapImage(&quantize_info, image, remap_image);
+    GVL_STRUCT_TYPE(RemapImage) args = { &quantize_info, image, remap_image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RemapImage), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -11425,11 +11890,13 @@ blurred_image(Image* image, double blur)
     exception = AcquireExceptionInfo();
     if (blur > 1.0)
     {
-        new_image = BlurImage(image, blur, blur, exception);
+        GVL_STRUCT_TYPE(BlurImage) args = { image, blur, blur, exception };
+        new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlurImage), &args);
     }
     else
     {
-        new_image = SharpenImage(image, blur, blur, exception);
+        GVL_STRUCT_TYPE(SharpenImage) args = { image, blur, blur, exception };
+        new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SharpenImage), &args);
     }
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -11462,7 +11929,7 @@ resample(int bang, int argc, VALUE *argv, VALUE self)
     double width, height;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     // Set up defaults
     filter  = image->filter;
@@ -11522,10 +11989,12 @@ resample(int bang, int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     Image *preprocess = blurred_image(image, blur);
-    new_image = ResampleImage(preprocess, x_resolution, y_resolution, filter, exception);
+    GVL_STRUCT_TYPE(ResampleImage) args = { preprocess, x_resolution, y_resolution, filter, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResampleImage), &args);
     DestroyImage(preprocess);
 #else
-    new_image = ResampleImage(image, x_resolution, y_resolution, filter, blur, exception);
+    GVL_STRUCT_TYPE(ResampleImage) args = { image, x_resolution, y_resolution, filter, blur, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResampleImage), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
 
@@ -11612,7 +12081,7 @@ resize(int bang, int argc, VALUE *argv, VALUE self)
     double blur, drows, dcols;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     // Set up defaults
     filter  = image->filter;
@@ -11661,13 +12130,15 @@ resize(int bang, int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     Image *preprocess = (argc == 4) ? blurred_image(image, blur) : image;
-    new_image = ResizeImage(preprocess, columns, rows, filter, exception);
+    GVL_STRUCT_TYPE(ResizeImage) args = { preprocess, columns, rows, filter, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResizeImage), &args);
     if (argc == 4)
     {
         DestroyImage(preprocess);
     }
 #else
-    new_image = ResizeImage(image, columns, rows, filter, blur, exception);
+    GVL_STRUCT_TYPE(ResizeImage) args = { image, columns, rows, filter, blur, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResizeImage), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
 
@@ -11753,7 +12224,8 @@ Image_roll(VALUE self, VALUE x_offset, VALUE y_offset)
     image = rm_check_destroyed(self);
 
     exception = AcquireExceptionInfo();
-    new_image = RollImage(image, x, y, exception);
+    GVL_STRUCT_TYPE(RollImage) args = { image, x, y, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RollImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -11783,7 +12255,7 @@ rotate(int bang, int argc, VALUE *argv, VALUE self)
     long arrow_l;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     switch (argc)
     {
@@ -11811,7 +12283,8 @@ rotate(int bang, int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 
-    new_image = RotateImage(image, degrees, exception);
+    GVL_STRUCT_TYPE(RotateImage) args = { image, degrees, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(RotateImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -11884,7 +12357,7 @@ Image_rotate_bang(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_rows(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, rows, int);
+    IMPLEMENT_TYPED_ATTR_READER(Image, rows, int, &rm_image_data_type);
 }
 
 
@@ -11908,7 +12381,7 @@ VALUE
 Image_sample(int argc, VALUE *argv, VALUE self)
 {
     rm_check_destroyed(self);
-    return scale(False, argc, argv, self, SampleImage);
+    return scale(False, argc, argv, self, GVL_FUNC(SampleImage));
 }
 
 
@@ -11932,7 +12405,7 @@ VALUE
 Image_sample_bang(int argc, VALUE *argv, VALUE self)
 {
     rm_check_frozen(self);
-    return scale(True, argc, argv, self, SampleImage);
+    return scale(True, argc, argv, self, GVL_FUNC(SampleImage));
 }
 
 
@@ -11956,7 +12429,7 @@ VALUE
 Image_scale(int argc, VALUE *argv, VALUE self)
 {
     rm_check_destroyed(self);
-    return scale(False, argc, argv, self, ScaleImage);
+    return scale(False, argc, argv, self, GVL_FUNC(ScaleImage));
 }
 
 
@@ -11980,10 +12453,13 @@ VALUE
 Image_scale_bang(int argc, VALUE *argv, VALUE self)
 {
     rm_check_frozen(self);
-    return scale(True, argc, argv, self, ScaleImage);
+    return scale(True, argc, argv, self, GVL_FUNC(ScaleImage));
 }
 
 
+// aliases for common use of structure types; SampleImage, ScaleImage,
+typedef GVL_STRUCT_TYPE(SampleImage) GVL_STRUCT_TYPE(scale);
+
 /**
  * Call ScaleImage or SampleImage
  *
@@ -12005,14 +12481,14 @@ Image_scale_bang(int argc, VALUE *argv, VALUE self)
  * @see Image_scale_bang
  */
 static VALUE
-scale(int bang, int argc, VALUE *argv, VALUE self, scaler_t scaler)
+scale(int bang, int argc, VALUE *argv, VALUE self, gvl_function_t fp)
 {
     Image *image, *new_image;
     unsigned long columns, rows;
     double scale_arg, drows, dcols;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     switch (argc)
     {
@@ -12045,7 +12521,8 @@ scale(int bang, int argc, VALUE *argv, VALUE self, scaler_t scaler)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = (scaler)(image, columns, rows, exception);
+    GVL_STRUCT_TYPE(scale) args = { image, columns, rows, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -12070,7 +12547,7 @@ scale(int bang, int argc, VALUE *argv, VALUE self, scaler_t scaler)
 VALUE
 Image_scene(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, scene, ulong);
+    IMPLEMENT_TYPED_ATTR_READER(Image, scene, ulong, &rm_image_data_type);
 }
 
 
@@ -12121,11 +12598,13 @@ Image_selective_blur_channel(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = SelectiveBlurImage(image, radius, sigma, threshold, exception);
+    GVL_STRUCT_TYPE(SelectiveBlurImage) args = { image, radius, sigma, threshold, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SelectiveBlurImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #else
-    new_image = SelectiveBlurImageChannel(image, channels, radius, sigma, threshold, exception);
+    GVL_STRUCT_TYPE(SelectiveBlurImageChannel) args = { image, channels, radius, sigma, threshold, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SelectiveBlurImageChannel), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -12159,12 +12638,14 @@ Image_set_channel_depth(VALUE self, VALUE channel_arg, VALUE depth)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(image, channel);
-    SetImageDepth(image, channel_depth, exception);
+    GVL_STRUCT_TYPE(SetImageDepth) args = { image, channel_depth, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageDepth), &args);
     END_CHANNEL_MASK(image);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    SetImageChannelDepth(image, channel, channel_depth);
+    GVL_STRUCT_TYPE(SetImageChannelDepth) args = { image, channel, channel_depth };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageChannelDepth), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -12202,11 +12683,13 @@ Image_separate(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_images = SeparateImages(image, exception);
+    GVL_STRUCT_TYPE(SeparateImages) args = { image, exception };
+    new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SeparateImages), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_images);
     END_CHANNEL_MASK(image);
 #else
-    new_images = SeparateImages(image, channels, exception);
+    GVL_STRUCT_TYPE(SeparateImages) args = { image, channels, exception };
+    new_images = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SeparateImages), &args);
 #endif
     rm_check_exception(exception, new_images, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -12245,7 +12728,8 @@ Image_sepiatone(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = SepiaToneImage(image, threshold, exception);
+    GVL_STRUCT_TYPE(SepiaToneImage) args = { image, threshold, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SepiaToneImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -12303,11 +12787,13 @@ Image_segment(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SegmentImage(new_image, colorspace, verbose, cluster_threshold, smoothing_threshold, exception);
+    GVL_STRUCT_TYPE(SegmentImage) args = { new_image, colorspace, verbose, cluster_threshold, smoothing_threshold, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SegmentImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    SegmentImage(new_image, colorspace, verbose, cluster_threshold, smoothing_threshold);
+    GVL_STRUCT_TYPE(SegmentImage) args = { new_image, colorspace, verbose, cluster_threshold, smoothing_threshold };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SegmentImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -12325,7 +12811,7 @@ Image_segment(int argc, VALUE *argv, VALUE self)
  *   @return [Hash] the properties
  *
  * @overload properties
- *   @yield []
+ *   @yield [Magick::Image::Info]
  *   @return [Magick::Image] self
  */
 VALUE
@@ -12443,7 +12929,8 @@ Image_shade(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = ShadeImage(image, shading, azimuth, elevation, exception);
+    GVL_STRUCT_TYPE(ShadeImage) args = { image, shading, azimuth, elevation, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ShadeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -12501,7 +12988,8 @@ Image_shadow(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = ShadowImage(image, alpha, sigma, x_offset, y_offset, exception);
+    GVL_STRUCT_TYPE(ShadowImage) args = { image, alpha, sigma, x_offset, y_offset, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ShadowImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -12520,7 +13008,7 @@ Image_shadow(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_sharpen(int argc, VALUE *argv, VALUE self)
 {
-    return effect_image(self, argc, argv, SharpenImage);
+    return effect_image(self, argc, argv, GVL_FUNC(SharpenImage));
 }
 
 
@@ -12568,11 +13056,13 @@ Image_sharpen_channel(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = SharpenImage(image, radius, sigma, exception);
+    GVL_STRUCT_TYPE(SharpenImage) args = { image, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SharpenImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #else
-    new_image = SharpenImageChannel(image, channels, radius, sigma, exception);
+    GVL_STRUCT_TYPE(SharpenImageChannel) args = { image, channels, radius, sigma, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SharpenImageChannel), &args);
 #endif
 
     rm_check_exception(exception, new_image, DestroyOnError);
@@ -12595,7 +13085,7 @@ VALUE
 Image_shave(VALUE self, VALUE width, VALUE height)
 {
     rm_check_destroyed(self);
-    return xform_image(False, self, INT2FIX(0), INT2FIX(0), width, height, ShaveImage);
+    return xform_image(False, self, INT2FIX(0), INT2FIX(0), width, height, GVL_FUNC(ShaveImage));
 }
 
 
@@ -12613,7 +13103,7 @@ VALUE
 Image_shave_bang(VALUE self, VALUE width, VALUE height)
 {
     rm_check_frozen(self);
-    return xform_image(True, self, INT2FIX(0), INT2FIX(0), width, height, ShaveImage);
+    return xform_image(True, self, INT2FIX(0), INT2FIX(0), width, height, GVL_FUNC(ShaveImage));
 }
 
 
@@ -12640,7 +13130,8 @@ Image_shear(VALUE self, VALUE x_shear, VALUE y_shear)
     image = rm_check_destroyed(self);
 
     exception = AcquireExceptionInfo();
-    new_image = ShearImage(image, x, y, exception);
+    GVL_STRUCT_TYPE(ShearImage) args = { image, x, y, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ShearImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -12711,12 +13202,14 @@ Image_sigmoidal_contrast_channel(int argc, VALUE *argv, VALUE self)
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
     BEGIN_CHANNEL_MASK(new_image, channels);
-    SigmoidalContrastImage(new_image, sharpen, contrast, midpoint, exception);
+    GVL_STRUCT_TYPE(SigmoidalContrastImage) args = { new_image, sharpen, contrast, midpoint, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SigmoidalContrastImage), &args);
     END_CHANNEL_MASK(new_image);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    SigmoidalContrastImageChannel(new_image, channels, sharpen, contrast, midpoint);
+    GVL_STRUCT_TYPE(SigmoidalContrastImageChannel) args = { new_image, channels, sharpen, contrast, midpoint };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SigmoidalContrastImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -12743,11 +13236,13 @@ Image_signature(VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SignatureImage(image, exception);
+    GVL_STRUCT_TYPE(SignatureImage) args = { image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SignatureImage), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    SignatureImage(image);
+    GVL_STRUCT_TYPE(SignatureImage) args = { image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SignatureImage), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
     signature = rm_get_property(image, "signature");
@@ -12773,7 +13268,7 @@ VALUE
 Image_sketch(int argc, VALUE *argv, VALUE self)
 {
     rm_check_destroyed(self);
-    return motion_blur(argc, argv, self, SketchImage);
+    return motion_blur(argc, argv, self, GVL_FUNC(SketchImage));
 }
 
 
@@ -12816,11 +13311,13 @@ Image_solarize(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SolarizeImage(new_image, threshold, exception);
+    GVL_STRUCT_TYPE(SolarizeImage) args = { new_image, threshold, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SolarizeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    SolarizeImage(new_image, threshold);
+    GVL_STRUCT_TYPE(SolarizeImage) args = { new_image, threshold };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SolarizeImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -12856,14 +13353,18 @@ Image_spaceship(VALUE self, VALUE other)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    SignatureImage(imageA, exception);
+    GVL_STRUCT_TYPE(SignatureImage) args1 = { imageA, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SignatureImage), &args1);
     CHECK_EXCEPTION();
-    SignatureImage(imageB, exception);
+    GVL_STRUCT_TYPE(SignatureImage) args2 = { imageB, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SignatureImage), &args2);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    SignatureImage(imageA);
-    SignatureImage(imageB);
+    GVL_STRUCT_TYPE(SignatureImage) args1 = { imageA };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SignatureImage), &args1);
+    GVL_STRUCT_TYPE(SignatureImage) args2 = { imageB };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SignatureImage), &args2);
 #endif
     sigA = rm_get_property(imageA, "signature");
     sigB = rm_get_property(imageB, "signature");
@@ -13040,11 +13541,13 @@ Image_sparse_color(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = SparseColorImage(image, method, nargs, args, exception);
+    GVL_STRUCT_TYPE(SparseColorImage) args_SparseColorImage = { image, method, nargs, args, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SparseColorImage), &args_SparseColorImage);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #else
-    new_image = SparseColorImage(image, channels, method, nargs, args, exception);
+    GVL_STRUCT_TYPE(SparseColorImage) args_SparseColorImage = { image, channels, method, nargs, args, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SparseColorImage), &args_SparseColorImage);
 #endif
     xfree((void *) args);
     rm_check_exception(exception, new_image, DestroyOnError);
@@ -13103,7 +13606,8 @@ Image_splice(int argc, VALUE *argv, VALUE self)
     // Swap in color for the duration of this call.
     old_color = image->background_color;
     image->background_color = color;
-    new_image = SpliceImage(image, &rectangle, exception);
+    GVL_STRUCT_TYPE(SpliceImage) args = { image, &rectangle, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SpliceImage), &args);
     image->background_color = old_color;
 
     rm_check_exception(exception, new_image, DestroyOnError);
@@ -13141,10 +13645,11 @@ Image_spread(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
-    new_image = SpreadImage(image, image->interpolate, radius, exception);
+    GVL_STRUCT_TYPE(SpreadImage) args = { image, image->interpolate, radius, exception };
 #else
-    new_image = SpreadImage(image, radius, exception);
+    GVL_STRUCT_TYPE(SpreadImage) args = { image, radius, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SpreadImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -13160,7 +13665,7 @@ Image_spread(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_start_loop(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, start_loop, boolean);
+    IMPLEMENT_TYPED_ATTR_READER(Image, start_loop, boolean, &rm_image_data_type);
 }
 
 /**
@@ -13172,7 +13677,7 @@ Image_start_loop(VALUE self)
 VALUE
 Image_start_loop_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITER(Image, start_loop, boolean);
+    IMPLEMENT_TYPED_ATTR_WRITER(Image, start_loop, boolean, &rm_image_data_type);
 }
 
 
@@ -13204,7 +13709,8 @@ Image_stegano(VALUE self, VALUE watermark_image, VALUE offset)
     image->offset = NUM2LONG(offset);
 
     exception = AcquireExceptionInfo();
-    new_image = SteganoImage(image, watermark, exception);
+    GVL_STRUCT_TYPE(SteganoImage) args = { image, watermark, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SteganoImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     DestroyExceptionInfo(exception);
@@ -13236,7 +13742,8 @@ Image_stereo(VALUE self, VALUE offset_image_arg)
     offset = rm_check_destroyed(offset_image);
 
     exception = AcquireExceptionInfo();
-    new_image = StereoImage(image, offset, exception);
+    GVL_STRUCT_TYPE(StereoImage) args = { image, offset, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(StereoImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     DestroyExceptionInfo(exception);
@@ -13294,10 +13801,12 @@ Image_class_type_eq(VALUE self, VALUE new_class_type)
     if (image->storage_class == PseudoClass && class_type == DirectClass)
     {
 #if defined(IMAGEMAGICK_7)
-        SyncImage(image, exception);
+        GVL_STRUCT_TYPE(SyncImage) args = { image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncImage), &args);
         CHECK_EXCEPTION();
 #else
-        SyncImage(image);
+        GVL_STRUCT_TYPE(SyncImage) args = { image };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncImage), &args);
 #endif
         magick_free(image->colormap);
         image->colormap = NULL;
@@ -13307,19 +13816,23 @@ Image_class_type_eq(VALUE self, VALUE new_class_type)
         GetQuantizeInfo(&qinfo);
         qinfo.number_colors = QuantumRange+1;
 #if defined(IMAGEMAGICK_7)
-        QuantizeImage(&qinfo, image, exception);
+        GVL_STRUCT_TYPE(QuantizeImage) args = { &qinfo, image, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(QuantizeImage), &args);
         CHECK_EXCEPTION();
 #else
-        QuantizeImage(&qinfo, image);
+        GVL_STRUCT_TYPE(QuantizeImage) args = { &qinfo, image };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(QuantizeImage), &args);
 #endif
     }
 
 #if defined(IMAGEMAGICK_7)
-    SetImageStorageClass(image, class_type, exception);
+    GVL_STRUCT_TYPE(SetImageStorageClass) args = { image, class_type, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    SetImageStorageClass(image, class_type);
+    GVL_STRUCT_TYPE(SetImageStorageClass) args = { image, class_type };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args);
 #endif
     return new_class_type;
 }
@@ -13348,7 +13861,7 @@ Image_store_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg,
     long n, size;
     long x, y;
     unsigned long cols, rows;
-    unsigned int okay;
+    MagickBooleanType okay;
     ExceptionInfo *exception;
 #if defined(IMAGEMAGICK_7)
     Quantum *pixels;
@@ -13374,7 +13887,8 @@ Image_store_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg,
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    okay = SetImageStorageClass(image, DirectClass, exception);
+    GVL_STRUCT_TYPE(SetImageStorageClass) args = { image, DirectClass, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args);
     CHECK_EXCEPTION();
     if (!okay)
     {
@@ -13382,7 +13896,8 @@ Image_store_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg,
         rb_raise(Class_ImageMagickError, "SetImageStorageClass failed. Can't store pixels.");
     }
 #else
-    okay = SetImageStorageClass(image, DirectClass);
+    GVL_STRUCT_TYPE(SetImageStorageClass) args = { image, DirectClass };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args);
     rm_check_image_exception(image, RetainOnError);
     if (!okay)
     {
@@ -13394,7 +13909,8 @@ Image_store_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg,
     // Get a pointer to the pixels. Replace the values with the PixelPackets
     // from the pixels argument.
     {
-        pixels = GetAuthenticPixels(image, x, y, cols, rows, exception);
+        GVL_STRUCT_TYPE(GetAuthenticPixels) args = { image, x, y, cols, rows, exception };
+        pixels = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetAuthenticPixels), &args);
         CHECK_EXCEPTION();
 
         if (pixels)
@@ -13410,7 +13926,7 @@ Image_store_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg,
                     DestroyExceptionInfo(exception);
                     rb_raise(rb_eTypeError, "Item in array should be a Pixel.");
                 }
-                Data_Get_Struct(new_pixel, Pixel, pixel);
+                TypedData_Get_Struct(new_pixel, Pixel, &rm_pixel_data_type, pixel);
 #if defined(IMAGEMAGICK_7)
                 SetPixelRed(image,   pixel->red,   pixels);
                 SetPixelGreen(image, pixel->green, pixels);
@@ -13430,7 +13946,8 @@ Image_store_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg,
                 pixels++;
 #endif
             }
-            SyncAuthenticPixels(image, exception);
+            GVL_STRUCT_TYPE(SyncAuthenticPixels) args = { image, exception };
+            CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args);
             CHECK_EXCEPTION();
         }
 
@@ -13490,10 +14007,11 @@ Image_swirl(VALUE self, VALUE degrees_obj)
     exception = AcquireExceptionInfo();
 
 #if defined(IMAGEMAGICK_7)
-    new_image = SwirlImage(image, degrees, image->interpolate, exception);
+    GVL_STRUCT_TYPE(SwirlImage) args = { image, degrees, image->interpolate, exception };
 #else
-    new_image = SwirlImage(image, degrees, exception);
+    GVL_STRUCT_TYPE(SwirlImage) args = { image, degrees, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SwirlImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -13584,12 +14102,14 @@ Image_texture_flood_fill(VALUE self, VALUE color_obj, VALUE texture_obj,
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    FloodfillPaintImage(new_image, draw_info, &color_mpp, x, y, invert, exception);
+    GVL_STRUCT_TYPE(FloodfillPaintImage) args = { new_image, draw_info, &color_mpp, x, y, invert, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FloodfillPaintImage), &args);
     DestroyDrawInfo(draw_info);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    FloodfillPaintImage(new_image, DefaultChannels, draw_info, &color_mpp, x, y, invert);
+    GVL_STRUCT_TYPE(FloodfillPaintImage) args = { new_image, DefaultChannels, draw_info, &color_mpp, x, y, invert };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FloodfillPaintImage), &args);
 
     DestroyDrawInfo(draw_info);
     rm_check_image_exception(new_image, DestroyOnError);
@@ -13622,11 +14142,13 @@ Image_threshold(VALUE self, VALUE threshold_obj)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    BilevelImage(new_image, threshold, exception);
+    GVL_STRUCT_TYPE(BilevelImage) args = { new_image, threshold, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BilevelImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    BilevelImageChannel(new_image, DefaultChannels, threshold);
+    GVL_STRUCT_TYPE(BilevelImageChannel) args = { new_image, DefaultChannels, threshold };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BilevelImageChannel), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -13634,6 +14156,9 @@ Image_threshold(VALUE self, VALUE threshold_obj)
 }
 
 
+// aliases for common use of structure types; WhiteThresholdImage
+typedef GVL_STRUCT_TYPE(WhiteThresholdImage) GVL_STRUCT_TYPE(threshold_image);
+
 /**
  * Call one of the xxxxThresholdImage methods.
  *
@@ -13645,8 +14170,8 @@ Image_threshold(VALUE self, VALUE threshold_obj)
  * @param thresholder which xxxxThresholdImage method to call
  * @return a new image
  */
-static
-VALUE threshold_image(int argc, VALUE *argv, VALUE self, thresholder_t thresholder)
+static VALUE
+threshold_image(int argc, VALUE *argv, VALUE self, gvl_function_t fp)
 {
     Image *image, *new_image;
     double red, green, blue, alpha;
@@ -13689,11 +14214,13 @@ VALUE threshold_image(int argc, VALUE *argv, VALUE self, thresholder_t threshold
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    (thresholder)(new_image, ctarg, exception);
+    GVL_STRUCT_TYPE(threshold_image) args = { new_image, ctarg, exception };
+    CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    (thresholder)(new_image, ctarg);
+    GVL_STRUCT_TYPE(threshold_image) args = { new_image, ctarg };
+    CALL_FUNC_WITHOUT_GVL(fp, &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
 
@@ -13727,7 +14254,7 @@ thumbnail(int bang, int argc, VALUE *argv, VALUE self)
     RectangleInfo geometry;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     switch (argc)
     {
@@ -13765,7 +14292,8 @@ thumbnail(int bang, int argc, VALUE *argv, VALUE self)
     ParseRegionGeometry(image, image_geometry, &geometry, exception);
     rm_check_exception(exception, image, RetainOnError);
 
-    new_image = ThumbnailImage(image, geometry.width, geometry.height, exception);
+    GVL_STRUCT_TYPE(ThumbnailImage) args = { image, geometry.width, geometry.height, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ThumbnailImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -13923,10 +14451,11 @@ Image_tint(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 
 #if defined(IMAGEMAGICK_7)
-    new_image = TintImage(image, alpha, &tint, exception);
+    GVL_STRUCT_TYPE(TintImage) args = { image, alpha, &tint, exception };
 #else
-    new_image = TintImage(image, alpha, tint, exception);
+    GVL_STRUCT_TYPE(TintImage) args = { image, alpha, tint, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TintImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -13959,7 +14488,7 @@ Image_to_blob(VALUE self)
     // both) and the image format by setting the depth and format
     // values in the info parm block.
     info_obj = rm_info_new();
-    Data_Get_Struct(info_obj, Info, info);
+    TypedData_Get_Struct(info_obj, Info, &rm_info_data_type, info);
 
     image = rm_check_destroyed(self);
 
@@ -13969,10 +14498,12 @@ Image_to_blob(VALUE self)
     if (info->depth != 0)
     {
 #if defined(IMAGEMAGICK_7)
-        SetImageDepth(image, info->depth, exception);
+        GVL_STRUCT_TYPE(SetImageDepth) args = { image, info->depth, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageDepth), &args);
         CHECK_EXCEPTION();
 #else
-        SetImageDepth(image, info->depth);
+        GVL_STRUCT_TYPE(SetImageDepth) args = { image, info->depth };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageDepth), &args);
         rm_check_image_exception(image, RetainOnError);
 #endif
     }
@@ -14006,7 +14537,8 @@ Image_to_blob(VALUE self)
 
     rm_sync_image_options(image, info);
 
-    blob = ImageToBlob(info, image, &length, exception);
+    GVL_STRUCT_TYPE(ImageToBlob) args = { info, image, &length, exception };
+    blob = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ImageToBlob), &args);
     CHECK_EXCEPTION();
 
     DestroyExceptionInfo(exception);
@@ -14152,11 +14684,13 @@ Image_transparent(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    okay = TransparentPaintImage(new_image, &color, alpha, MagickFalse, exception);
+    GVL_STRUCT_TYPE(TransparentPaintImage) args = { new_image, &color, alpha, MagickFalse, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TransparentPaintImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    okay = TransparentPaintImage(new_image, &color, QuantumRange - alpha, MagickFalse);
+    GVL_STRUCT_TYPE(TransparentPaintImage) args = { new_image, &color, QuantumRange - alpha, MagickFalse };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TransparentPaintImage), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
     if (!okay)
@@ -14226,11 +14760,13 @@ Image_transparent_chroma(int argc, VALUE *argv, VALUE self)
 
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    okay = TransparentPaintImageChroma(new_image, &low, &high, alpha, invert, exception);
+    GVL_STRUCT_TYPE(TransparentPaintImageChroma) args = { new_image, &low, &high, alpha, invert, exception };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TransparentPaintImageChroma), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    okay = TransparentPaintImageChroma(new_image, &low, &high, QuantumRange - alpha, invert);
+    GVL_STRUCT_TYPE(TransparentPaintImageChroma) args = { new_image, &low, &high, QuantumRange - alpha, invert };
+    okay = (MagickBooleanType)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TransparentPaintImageChroma), &args);
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
     if (!okay)
@@ -14283,7 +14819,7 @@ VALUE
 Image_transpose(VALUE self)
 {
     rm_check_destroyed(self);
-    return crisscross(False, self, TransposeImage);
+    return crisscross(False, self, GVL_FUNC(TransposeImage));
 }
 
 
@@ -14299,7 +14835,7 @@ VALUE
 Image_transpose_bang(VALUE self)
 {
     rm_check_frozen(self);
-    return crisscross(True, self, TransposeImage);
+    return crisscross(True, self, GVL_FUNC(TransposeImage));
 }
 
 
@@ -14314,7 +14850,7 @@ VALUE
 Image_transverse(VALUE self)
 {
     rm_check_destroyed(self);
-    return crisscross(False, self, TransverseImage);
+    return crisscross(False, self, GVL_FUNC(TransverseImage));
 }
 
 /**
@@ -14329,7 +14865,7 @@ VALUE
 Image_transverse_bang(VALUE self)
 {
     rm_check_frozen(self);
-    return crisscross(True, self, TransverseImage);
+    return crisscross(True, self, GVL_FUNC(TransverseImage));
 }
 
 
@@ -14367,10 +14903,11 @@ trimmer(int bang, int argc, VALUE *argv, VALUE self)
             break;
     }
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
     exception = AcquireExceptionInfo();
-    new_image = TrimImage(image, exception);
+    GVL_STRUCT_TYPE(TrimImage) args = { image, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(TrimImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -14551,7 +15088,8 @@ Image_unique_colors(VALUE self)
     image = rm_check_destroyed(self);
     exception = AcquireExceptionInfo();
 
-    new_image = UniqueImageColors(image, exception);
+    GVL_STRUCT_TYPE(UniqueImageColors) args = { image, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(UniqueImageColors), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -14717,7 +15255,8 @@ Image_unsharp_mask(int argc, VALUE *argv, VALUE self)
     unsharp_mask_args(argc, argv, &radius, &sigma, &amount, &threshold);
 
     exception = AcquireExceptionInfo();
-    new_image = UnsharpMaskImage(image, radius, sigma, amount, threshold, exception);
+    GVL_STRUCT_TYPE(UnsharpMaskImage) args = { image, radius, sigma, amount, threshold, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(UnsharpMaskImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -14772,11 +15311,13 @@ Image_unsharp_mask_channel(int argc, VALUE *argv, VALUE self)
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
     BEGIN_CHANNEL_MASK(image, channels);
-    new_image = UnsharpMaskImage(image, radius, sigma, amount, threshold, exception);
+    GVL_STRUCT_TYPE(UnsharpMaskImage) args = { image, radius, sigma, amount, threshold, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(UnsharpMaskImage), &args);
     CHANGE_RESULT_CHANNEL_MASK(new_image);
     END_CHANNEL_MASK(image);
 #else
-    new_image = UnsharpMaskImageChannel(image, channels, radius, sigma, amount, threshold, exception);
+    GVL_STRUCT_TYPE(UnsharpMaskImageChannel) args = { image, channels, radius, sigma, amount, threshold, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(UnsharpMaskImageChannel), &args);
 #endif
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
@@ -14827,7 +15368,8 @@ Image_vignette(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 
-    new_image = VignetteImage(image, radius, sigma, horz_radius, vert_radius, exception);
+    GVL_STRUCT_TYPE(VignetteImage) args = { image, radius, sigma, horz_radius, vert_radius, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(VignetteImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -14973,11 +15515,13 @@ Image_watermark(int argc, VALUE *argv, VALUE self)
     new_image = rm_clone_image(image);
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    CompositeImage(new_image, overlay, ModulateCompositeOp, MagickTrue, x_offset, y_offset, exception);
+    GVL_STRUCT_TYPE(CompositeImage) args = { new_image, overlay, ModulateCompositeOp, MagickTrue, x_offset, y_offset, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 #else
-    CompositeImage(new_image, ModulateCompositeOp, overlay, x_offset, y_offset);
+    GVL_STRUCT_TYPE(CompositeImage) args = { new_image, ModulateCompositeOp, overlay, x_offset, y_offset };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CompositeImage), &args);
 
     rm_check_image_exception(new_image, DestroyOnError);
 #endif
@@ -15020,10 +15564,11 @@ Image_wave(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
-    new_image = WaveImage(image, amplitude, wavelength, image->interpolate, exception);
+    GVL_STRUCT_TYPE(WaveImage) args = { image, amplitude, wavelength, image->interpolate, exception };
 #else
-    new_image = WaveImage(image, amplitude, wavelength, exception);
+    GVL_STRUCT_TYPE(WaveImage) args = { image, amplitude, wavelength, exception };
 #endif
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(WaveImage), &args);
     rm_check_exception(exception, new_image, DestroyOnError);
     DestroyExceptionInfo(exception);
 
@@ -15119,7 +15664,8 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
 
 
     exception = AcquireExceptionInfo();
-    flip_image = FlipImage(image, exception);
+    GVL_STRUCT_TYPE(FlipImage) args_FlipImage = { image, exception };
+    flip_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(FlipImage), &args_FlipImage);
     CHECK_EXCEPTION();
 
 
@@ -15127,18 +15673,22 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
     geometry.y = 0;
     geometry.width = image->columns;
     geometry.height = max_rows;
-    reflection = CropImage(flip_image, &geometry, exception);
+    GVL_STRUCT_TYPE(CropImage) args_CropImage = { flip_image, &geometry, exception };
+    reflection = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(CropImage), &args_CropImage);
     DestroyImage(flip_image);
     CHECK_EXCEPTION();
 
 
 #if defined(IMAGEMAGICK_7)
-    SetImageStorageClass(reflection, DirectClass, exception);
+    GVL_STRUCT_TYPE(SetImageStorageClass) args_SetImageStorageClass = { reflection, DirectClass, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args_SetImageStorageClass);
     rm_check_exception(exception, reflection, DestroyOnError);
-    SetImageAlphaChannel(reflection, ActivateAlphaChannel, exception);
+    GVL_STRUCT_TYPE(SetImageAlphaChannel) args_SetImageAlphaChannel = { reflection, ActivateAlphaChannel, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageAlphaChannel), &args_SetImageAlphaChannel);
     rm_check_exception(exception, reflection, DestroyOnError);
 #else
-    SetImageStorageClass(reflection, DirectClass);
+    GVL_STRUCT_TYPE(SetImageStorageClass) args_SetImageStorageClass = { reflection, DirectClass };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SetImageStorageClass), &args_SetImageStorageClass);
     rm_check_image_exception(reflection, DestroyOnError);
 
 
@@ -15160,7 +15710,8 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
         }
 #endif
 
-        p = GetVirtualPixels(reflection, 0, y, image->columns, 1, exception);
+        GVL_STRUCT_TYPE(GetVirtualPixels) args_GetVirtualPixels = { reflection, 0, y, image->columns, 1, exception };
+        p = CALL_FUNC_WITHOUT_GVL(GVL_FUNC(GetVirtualPixels), &args_GetVirtualPixels);
         rm_check_exception(exception, reflection, DestroyOnError);
         if (!p)
         {
@@ -15192,8 +15743,8 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
 #endif
         }
 
-
-        SyncAuthenticPixels(reflection, exception);
+        GVL_STRUCT_TYPE(SyncAuthenticPixels) args_SyncAuthenticPixels = { reflection, exception };
+        CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SyncAuthenticPixels), &args_SyncAuthenticPixels);
         rm_check_exception(exception, reflection, DestroyOnError);
 
         opacity += step;
@@ -15226,7 +15777,7 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_white_threshold(int argc, VALUE *argv, VALUE self)
 {
-    return threshold_image(argc, argv, self, WhiteThresholdImage);
+    return threshold_image(argc, argv, self, GVL_FUNC(WhiteThresholdImage));
 }
 
 
@@ -15253,6 +15804,10 @@ void add_format_prefix(Info *info, VALUE file)
     char *p;
 
     // Convert arg to string. If an exception occurs raise an error condition.
+    if (rb_respond_to(file, rb_intern("path")))
+    {
+        FilePathStringValue(file);
+    }
     file = rb_rescue(rb_String, file, file_arg_rescue, file);
 
     filename = rm_str2cstr(file, &filename_l);
@@ -15339,7 +15894,7 @@ Image_write(VALUE self, VALUE file)
     image = rm_check_destroyed(self);
 
     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)
     {
@@ -15348,32 +15903,32 @@ Image_write(VALUE self, VALUE file)
         // Ensure file is open - raise error if not
         GetOpenFile(file, fptr);
         rb_io_check_writable(fptr);
-#if defined(_WIN32)
         add_format_prefix(info, fptr->pathv);
-        strlcpy(image->filename, info->filename, sizeof(image->filename));
+#if defined(_WIN32)
         SetImageInfoFile(info, NULL);
 #else
         SetImageInfoFile(info, rb_io_stdio_file(fptr));
-        memset(image->filename, 0, sizeof(image->filename));
 #endif
     }
     else
     {
         add_format_prefix(info, file);
-        strlcpy(image->filename, info->filename, sizeof(image->filename));
         SetImageInfoFile(info, NULL);
     }
+    strlcpy(image->filename, info->filename, sizeof(image->filename));
 
     rm_sync_image_options(image, info);
 
     info->adjoin = MagickFalse;
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    WriteImage(info, image, exception);
+    GVL_STRUCT_TYPE(WriteImage) args = { info, image, exception };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(WriteImage), &args);
     CHECK_EXCEPTION();
     DestroyExceptionInfo(exception);
 #else
-    WriteImage(info, image);
+    GVL_STRUCT_TYPE(WriteImage) args = { info, image };
+    CALL_FUNC_WITHOUT_GVL(GVL_FUNC(WriteImage), &args);
     rm_check_image_exception(image, RetainOnError);
 #endif
 
@@ -15391,7 +15946,7 @@ Image_write(VALUE self, VALUE file)
 VALUE
 Image_x_resolution(VALUE self)
 {
-    IMPLEMENT_ATTR_READERF(Image, x_resolution, resolution.x, dbl);
+    IMPLEMENT_TYPED_ATTR_READERF(Image, x_resolution, resolution.x, dbl, &rm_image_data_type);
 }
 
 /**
@@ -15403,7 +15958,7 @@ Image_x_resolution(VALUE self)
 VALUE
 Image_x_resolution_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITERF(Image, x_resolution, resolution.x, dbl);
+    IMPLEMENT_TYPED_ATTR_WRITERF(Image, x_resolution, resolution.x, dbl, &rm_image_data_type);
 }
 
 /**
@@ -15414,7 +15969,7 @@ Image_x_resolution_eq(VALUE self, VALUE val)
 VALUE
 Image_y_resolution(VALUE self)
 {
-    IMPLEMENT_ATTR_READERF(Image, y_resolution, resolution.y, dbl);
+    IMPLEMENT_TYPED_ATTR_READERF(Image, y_resolution, resolution.y, dbl, &rm_image_data_type);
 }
 
 /**
@@ -15426,7 +15981,7 @@ Image_y_resolution(VALUE self)
 VALUE
 Image_y_resolution_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITERF(Image, y_resolution, resolution.y, dbl);
+    IMPLEMENT_TYPED_ATTR_WRITERF(Image, y_resolution, resolution.y, dbl, &rm_image_data_type);
 }
 #else
 /**
@@ -15437,7 +15992,7 @@ Image_y_resolution_eq(VALUE self, VALUE val)
 VALUE
 Image_x_resolution(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, x_resolution, dbl);
+    IMPLEMENT_TYPED_ATTR_READER(Image, x_resolution, dbl, &rm_image_data_type);
 }
 
 /**
@@ -15449,7 +16004,7 @@ Image_x_resolution(VALUE self)
 VALUE
 Image_x_resolution_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITER(Image, x_resolution, dbl);
+    IMPLEMENT_TYPED_ATTR_WRITER(Image, x_resolution, dbl, &rm_image_data_type);
 }
 
 /**
@@ -15460,7 +16015,7 @@ Image_x_resolution_eq(VALUE self, VALUE val)
 VALUE
 Image_y_resolution(VALUE self)
 {
-    IMPLEMENT_ATTR_READER(Image, y_resolution, dbl);
+    IMPLEMENT_TYPED_ATTR_READER(Image, y_resolution, dbl, &rm_image_data_type);
 }
 
 /**
@@ -15472,7 +16027,7 @@ Image_y_resolution(VALUE self)
 VALUE
 Image_y_resolution_eq(VALUE self, VALUE val)
 {
-    IMPLEMENT_ATTR_WRITER(Image, y_resolution, dbl);
+    IMPLEMENT_TYPED_ATTR_WRITER(Image, y_resolution, dbl, &rm_image_data_type);
 }
 #endif
 
@@ -15531,7 +16086,7 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
     switch (argc)
     {
         case 5:
-            Data_Get_Struct(self, Image, image);
+            TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
             VALUE_TO_ENUM(argv[0], gravity, GravityType);
 
@@ -15598,7 +16153,7 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
             columns = NUM2ULONG(width);
             rows    = NUM2ULONG(height);
 
-            Data_Get_Struct(self, Image, image);
+            TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
 
             switch (gravity)
             {
@@ -15661,10 +16216,10 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
             break;
     }
 
-    cropped = xform_image(bang, self, x, y, width, height, CropImage);
+    cropped = xform_image(bang, self, x, y, width, height, GVL_FUNC(CropImage));
     if (reset_page)
     {
-        Data_Get_Struct(cropped, Image, image);
+        TypedData_Get_Struct(cropped, Image, &rm_image_data_type, image);
         ResetImagePage(image, "0x0+0+0");
     }
 
@@ -15677,6 +16232,9 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
 }
 
 
+// aliases for common use of structure types; ChopImage, CropImage, ShaveImage
+typedef GVL_STRUCT_TYPE(ChopImage) GVL_STRUCT_TYPE(xform_image);
+
 /**
  * Call one of the image transformation functions.
  *
@@ -15692,13 +16250,13 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
  * @return self if bang, otherwise a new image
  */
 static VALUE
-xform_image(int bang, VALUE self, VALUE x, VALUE y, VALUE width, VALUE height, xformer_t xformer)
+xform_image(int bang, VALUE self, VALUE x, VALUE y, VALUE width, VALUE height, gvl_function_t fp)
 {
     Image *image, *new_image;
     RectangleInfo rect;
     ExceptionInfo *exception;
 
-    Data_Get_Struct(self, Image, image);
+    TypedData_Get_Struct(self, Image, &rm_image_data_type, image);
     rect.x      = NUM2LONG(x);
     rect.y      = NUM2LONG(y);
     rect.width  = NUM2ULONG(width);
@@ -15706,7 +16264,8 @@ xform_image(int bang, VALUE self, VALUE x, VALUE y, VALUE width, VALUE height, x
 
     exception = AcquireExceptionInfo();
 
-    new_image = (xformer)(image, &rect, exception);
+    GVL_STRUCT_TYPE(xform_image) args = { image, &rect, exception };
+    new_image = (Image *)CALL_FUNC_WITHOUT_GVL(fp, &args);
 
     // An exception can occur in either the old or the new images
     rm_check_exception(exception, new_image, DestroyOnError);
@@ -15792,75 +16351,6 @@ raise_ChannelType_error(VALUE arg)
 }
 
 
-
-/**
- * If Magick.trace_proc is not nil, build an argument list and call the proc.
- *
- * No Ruby usage (internal function)
- *
- * @param image the image
- * @param which which operation the proc is being called for
- */
-static void call_trace_proc(Image *image, const char *which)
-{
-    VALUE trace;
-    VALUE trace_args[4];
-
-    if (rb_ivar_defined(Module_Magick, rm_ID_trace_proc) == Qtrue)
-    {
-        trace = rb_ivar_get(Module_Magick, rm_ID_trace_proc);
-        if (!NIL_P(trace))
-        {
-            // Maybe the stack won't get extended until we need the space.
-            char buffer[MaxTextExtent];
-
-            trace_args[0] = ID2SYM(rb_intern(which));
-
-            build_inspect_string(image, buffer, sizeof(buffer));
-            trace_args[1] = rb_str_new2(buffer);
-
-            snprintf(buffer, sizeof(buffer), "%p", (void *)image);
-            trace_args[2] = rb_str_new2(buffer+2);      // don't use leading 0x
-            trace_args[3] = ID2SYM(rb_frame_this_func());
-            rb_funcall2(trace, rm_ID_call, 4, (VALUE *)trace_args);
-        }
-    }
-
-    RB_GC_GUARD(trace);
-}
-
-
-static VALUE
-rm_trace_creation_body(VALUE img)
-{
-    Image *image = (Image *)img;
-    call_trace_proc(image, "c");
-    return Qnil;
-}
-
-static VALUE
-rm_trace_creation_handle_exception(VALUE img, VALUE exc)
-{
-    Image *image = (Image *)img;
-    DestroyImage(image);
-    rb_exc_raise(exc);
-}
-
-/**
- * Trace image creation
- *
- * No Ruby usage (internal function)
- *
- * @param image the image
- * @see call_trace_proc
- */
-void rm_trace_creation(Image *image)
-{
-    rb_rescue(rm_trace_creation_body, (VALUE)image, rm_trace_creation_handle_exception, (VALUE)image);
-}
-
-
-
 /**
  * Destroy an image. Called from GC when all references to the image have gone
  * out of scope.
@@ -15879,9 +16369,19 @@ void rm_image_destroy(void *img)
 
     if (img != NULL)
     {
-        call_trace_proc(image, "d");
         DestroyImage(image);
     }
 }
 
-
+/**
+  * Get Image object size.
+  *
+  * No Ruby usage (internal function)
+  *
+  * @param ptr pointer to the Image object
+  */
+static size_t
+rm_image_memsize(const void *ptr)
+{
+    return sizeof(Image);
+}