text: #include <stdlib.h>
  #include <string.h>
  #include <vips/vips.h>
  #include <vips/foreign.h>
  #include <vips/vips7compat.h>
  
  /**
   * Starting libvips 7.41, VIPS_ANGLE_x has been renamed to VIPS_ANGLE_Dx
   * "to help python". So we provide the macro to correctly build for versions
   * before 7.41.x.
   * https://github.com/jcupitt/libvips/blob/master/ChangeLog#L128
   */
  
  #if (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 41)
  #define VIPS_ANGLE_D0 VIPS_ANGLE_0
  #define VIPS_ANGLE_D90 VIPS_ANGLE_90
  #define VIPS_ANGLE_D180 VIPS_ANGLE_180
  #define VIPS_ANGLE_D270 VIPS_ANGLE_270
  #endif
  
  #define EXIF_IFD0_ORIENTATION "exif-ifd0-Orientation"
  
  #define INT_TO_GBOOLEAN(bool) (bool > 0 ? TRUE : FALSE)
  
  
  enum types {
  	UNKNOWN = 0,
  	JPEG,
  	WEBP,
  	PNG,
  	TIFF,
  	GIF,
  	PDF,
  	SVG,
  	MAGICK,
  #if (VIPS_MAJOR_VERSION > 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION >= 8))
  	HEIF,
  #endif
  };
  
  typedef struct {
  	const char *Text;
  	const char *Font;
  } WatermarkTextOptions;
  
  typedef struct {
  	int    Left;
  	int    Top;
  	int    Width;
  	int    DPI;
  	int    Margin;
  	int    NoReplicate;
  	float  Opacity;
  	double Background[3];
  } WatermarkOptions;
  
  typedef struct {
  	int    Left;
  	int    Top;
  	float    Opacity;
  } WatermarkImageOptions;
  
  static unsigned long
  has_profile_embed(VipsImage *image) {
  	return vips_image_get_typeof(image, VIPS_META_ICC_NAME);
  }
  
  static void
  remove_profile(VipsImage *image) {
  	vips_image_remove(image, VIPS_META_ICC_NAME);
  }
  
  static int
  has_alpha_channel(VipsImage *image) {
  	return (
  		(image->Bands == 2 && image->Type == VIPS_INTERPRETATION_B_W) ||
  		(image->Bands == 4 && image->Type != VIPS_INTERPRETATION_CMYK) ||
  		(image->Bands == 5 && image->Type == VIPS_INTERPRETATION_CMYK)
  	) ? 1 : 0;
  }
  
  /**
   * This method is here to handle the weird initialization of the vips lib.
   * libvips use a macro VIPS_INIT() that call vips__init() in version < 7.41,
   * or calls vips_init() in version >= 7.41.
   *
   * Anyway, it's not possible to build bimg on Debian Jessie with libvips 7.40.x,
   * as vips_init() is a macro to VIPS_INIT(), which is also a macro, hence, cgo
   * is unable to determine the return type of vips_init(), making the build impossible.
   * In order to correctly build bimg, for version < 7.41, we should undef vips_init and
   * creates a vips_init() method that calls VIPS_INIT().
   */
  
  #if (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 41)
  #undef vips_init
  int
  vips_init(const char *argv0)
  {
  	return VIPS_INIT(argv0);
  }
  #endif
  
  void
  vips_enable_cache_set_trace() {
  	vips_cache_set_trace(TRUE);
  }
  
  int
  vips_affine_interpolator(VipsImage *in, VipsImage **out, double a, double b, double c, double d, VipsInterpolate *interpolator) {
  	return vips_affine(in, out, a, b, c, d, "interpolate", interpolator, NULL);
  }
  
  int
  vips_jpegload_buffer_shrink(void *buf, size_t len, VipsImage **out, int shrink) {
  	return vips_jpegload_buffer(buf, len, out, "shrink", shrink, NULL);
  }
  
  int
  vips_webpload_buffer_shrink(void *buf, size_t len, VipsImage **out, int shrink) {
  	return vips_webpload_buffer(buf, len, out, "shrink", shrink, NULL);
  }
  
  int
  vips_flip_bridge(VipsImage *in, VipsImage **out, int direction) {
  	return vips_flip(in, out, direction, NULL);
  }
  
  int
  vips_shrink_bridge(VipsImage *in, VipsImage **out, double xshrink, double yshrink) {
  	return vips_shrink(in, out, xshrink, yshrink, NULL);
  }
  
  int
  vips_reduce_bridge(VipsImage *in, VipsImage **out, double xshrink, double yshrink) {
  	return vips_reduce(in, out, xshrink, yshrink, NULL);
  }
  
  int
  vips_type_find_bridge(int t) {
  	if (t == GIF) {
  		return vips_type_find("VipsOperation", "gifload");
  	}
  	if (t == PDF) {
  		return vips_type_find("VipsOperation", "pdfload");
  	}
  	if (t == TIFF) {
  		return vips_type_find("VipsOperation", "tiffload");
  	}
  	if (t == SVG) {
  		return vips_type_find("VipsOperation", "svgload");
  	}
  	if (t == WEBP) {
  		return vips_type_find("VipsOperation", "webpload");
  	}
  	if (t == PNG) {
  		return vips_type_find("VipsOperation", "pngload");
  	}
  	if (t == JPEG) {
  		return vips_type_find("VipsOperation", "jpegload");
  	}
  	if (t == MAGICK) {
  		return vips_type_find("VipsOperation", "magickload");
  	}
  #if (VIPS_MAJOR_VERSION > 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION >= 8))
  	if (t == HEIF) {
  		return vips_type_find("VipsOperation", "heifload");
  	}
  #endif
  	return 0;
  }
  
  int
  vips_type_find_save_bridge(int t) {
  	if (t == TIFF) {
  		return vips_type_find("VipsOperation", "tiffsave_buffer");
  	}
  	if (t == WEBP) {
  		return vips_type_find("VipsOperation", "webpsave_buffer");
  	}
  	if (t == PNG) {
  		return vips_type_find("VipsOperation", "pngsave_buffer");
  	}
  	if (t == JPEG) {
  		return vips_type_find("VipsOperation", "jpegsave_buffer");
  	}
  #if (VIPS_MAJOR_VERSION > 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION >= 8))
  	if (t == HEIF) {
  		return vips_type_find("VipsOperation", "heifsave_buffer");
  	}
  #endif
  	return 0;
  }
  
  int
  vips_rotate_bimg(VipsImage *in, VipsImage **out, int angle) {
  	int rotate = VIPS_ANGLE_D0;
  
  	angle %= 360;
  
  	if (angle == 45) {
  		rotate = VIPS_ANGLE45_D45;
  	} else if (angle == 90) {
  		rotate = VIPS_ANGLE_D90;
  	} else if (angle == 135) {
  		rotate = VIPS_ANGLE45_D135;
  	} else if (angle == 180) {
  		rotate = VIPS_ANGLE_D180;
  	} else if (angle == 225) {
  		rotate = VIPS_ANGLE45_D225;
  	} else if (angle == 270) {
  		rotate = VIPS_ANGLE_D270;
  	} else if (angle == 315) {
  		rotate = VIPS_ANGLE45_D315;
  	} else {
  		angle = 0;
  	}
  
  	if (angle > 0 && angle % 90 != 0) {
  		return vips_rot45(in, out, "angle", rotate, NULL);
  	} else {
  		return vips_rot(in, out, rotate, NULL);
  	}
  }
  
  int
  vips_exif_orientation(VipsImage *image) {
  	int orientation = 0;
  	const char *exif;
  	if (
  		vips_image_get_typeof(image, EXIF_IFD0_ORIENTATION) != 0 &&
  		!vips_image_get_string(image, EXIF_IFD0_ORIENTATION, &exif)
  	) {
  		orientation = atoi(&exif[0]);
  	}
  	return orientation;
  }
  
  int
  interpolator_window_size(char const *name) {
  	VipsInterpolate *interpolator = vips_interpolate_new(name);
  	int window_size = vips_interpolate_get_window_size(interpolator);
  	g_object_unref(interpolator);
  	return window_size;
  }
  
  const char *
  vips_enum_nick_bridge(VipsImage *image) {
  	return vips_enum_nick(VIPS_TYPE_INTERPRETATION, image->Type);
  }
  
  int
  vips_zoom_bridge(VipsImage *in, VipsImage **out, int xfac, int yfac) {
  	return vips_zoom(in, out, xfac, yfac, NULL);
  }
  
  int
  vips_embed_bridge(VipsImage *in, VipsImage **out, int left, int top, int width, int height, int extend, double r, double g, double b) {
  	if (extend == VIPS_EXTEND_BACKGROUND) {
  		double background[3] = {r, g, b};
  		VipsArrayDouble *vipsBackground = vips_array_double_new(background, 3);
  		return vips_embed(in, out, left, top, width, height, "extend", extend, "background", vipsBackground, NULL);
  	}
  	return vips_embed(in, out, left, top, width, height, "extend", extend, NULL);
  }
  
  int
  vips_extract_area_bridge(VipsImage *in, VipsImage **out, int left, int top, int width, int height) {
  	return vips_extract_area(in, out, left, top, width, height, NULL);
  }
  
  int
  vips_colourspace_issupported_bridge(VipsImage *in) {
  	return vips_colourspace_issupported(in) ? 1 : 0;
  }
  
  VipsInterpretation
  vips_image_guess_interpretation_bridge(VipsImage *in) {
  	return vips_image_guess_interpretation(in);
  }
  
  int
  vips_colourspace_bridge(VipsImage *in, VipsImage **out, VipsInterpretation space) {
  	return vips_colourspace(in, out, space, NULL);
  }
  
  int
  vips_icc_transform_bridge (VipsImage *in, VipsImage **out, const char *output_icc_profile) {
  	// `output_icc_profile` represents the absolute path to the output ICC profile file
  	return vips_icc_transform(in, out, output_icc_profile, "embedded", TRUE, NULL);
  }
  
  int
  vips_jpegsave_bridge(VipsImage *in, void **buf, size_t *len, int strip, int quality, int interlace) {
  	return vips_jpegsave_buffer(in, buf, len,
  		"strip", INT_TO_GBOOLEAN(strip),
  		"Q", quality,
  		"optimize_coding", TRUE,
  		"interlace", INT_TO_GBOOLEAN(interlace),
  		NULL
  	);
  }
  
  int
  vips_pngsave_bridge(VipsImage *in, void **buf, size_t *len, int strip, int compression, int quality, int interlace) {
  #if (VIPS_MAJOR_VERSION >= 8 || (VIPS_MAJOR_VERSION >= 7 && VIPS_MINOR_VERSION >= 42))
  	return vips_pngsave_buffer(in, buf, len,
  		"strip", INT_TO_GBOOLEAN(strip),
  		"compression", compression,
  		"interlace", INT_TO_GBOOLEAN(interlace),
  		"filter", VIPS_FOREIGN_PNG_FILTER_ALL,
  		NULL
  	);
  #else
  	return vips_pngsave_buffer(in, buf, len,
  		"strip", INT_TO_GBOOLEAN(strip),
  		"compression", compression,
  		"interlace", INT_TO_GBOOLEAN(interlace),
  		NULL
  	);
  #endif
  }
  
  int
  vips_webpsave_bridge(VipsImage *in, void **buf, size_t *len, int strip, int quality, int lossless) {
  	return vips_webpsave_buffer(in, buf, len,
  		"strip", INT_TO_GBOOLEAN(strip),
  		"Q", quality,
  		"lossless", INT_TO_GBOOLEAN(lossless),
  		NULL
  	);
  }
  
  int
  vips_tiffsave_bridge(VipsImage *in, void **buf, size_t *len) {
  #if (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 5)
  	return vips_tiffsave_buffer(in, buf, len, NULL);
  #else
  	return 0;
  #endif
  }
  
  int
  vips_heifsave_bridge(VipsImage *in, void **buf, size_t *len, int strip, int quality, int lossless) {
  #if (VIPS_MAJOR_VERSION > 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION >= 8))
  	return vips_heifsave_buffer(in, buf, len,
  		"strip", INT_TO_GBOOLEAN(strip),
  		"Q", quality,
  		"lossless", INT_TO_GBOOLEAN(lossless),
  		NULL
  	);
  #else
  	return 0;
  #endif
  }
  
  int
  vips_is_16bit (VipsInterpretation interpretation) {
  	return interpretation == VIPS_INTERPRETATION_RGB16 || interpretation == VIPS_INTERPRETATION_GREY16;
  }
  
  int
  vips_flatten_background_brigde(VipsImage *in, VipsImage **out, double r, double g, double b) {
  	if (vips_is_16bit(in->Type)) {
  		r = 65535 * r / 255;
  		g = 65535 * g / 255;
  		b = 65535 * b / 255;
  	}
  
  	double background[3] = {r, g, b};
  	VipsArrayDouble *vipsBackground = vips_array_double_new(background, 3);
  
  	return vips_flatten(in, out,
  		"background", vipsBackground,
  		"max_alpha", vips_is_16bit(in->Type) ? 65535.0 : 255.0,
  		NULL
  	);
  }
  
  int
  vips_init_image (void *buf, size_t len, int imageType, VipsImage **out) {
  	int code = 1;
  
  	if (imageType == JPEG) {
  		code = vips_jpegload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  	} else if (imageType == PNG) {
  		code = vips_pngload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  	} else if (imageType == WEBP) {
  		code = vips_webpload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  	} else if (imageType == TIFF) {
  		code = vips_tiffload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  #if (VIPS_MAJOR_VERSION >= 8)
  #if (VIPS_MINOR_VERSION >= 3)
  	} else if (imageType == GIF) {
  		code = vips_gifload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  	} else if (imageType == PDF) {
  		code = vips_pdfload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  	} else if (imageType == SVG) {
  		code = vips_svgload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  #endif
  	} else if (imageType == MAGICK) {
  		code = vips_magickload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  #endif
  #if (VIPS_MAJOR_VERSION > 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION >= 8))
  	} else if (imageType == HEIF) {
  		code = vips_heifload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
  #endif
  	}
  
  	return code;
  }
  
  int
  vips_watermark_replicate (VipsImage *orig, VipsImage *in, VipsImage **out) {
  	VipsImage *cache = vips_image_new();
  
  	if (
  		vips_replicate(in, &cache,
  			1 + orig->Xsize / in->Xsize,
  			1 + orig->Ysize / in->Ysize, NULL) ||
  		vips_crop(cache, out, 0, 0, orig->Xsize, orig->Ysize, NULL)
  	) {
  		g_object_unref(cache);
  		return 1;
  	}
  
  	g_object_unref(cache);
  	return 0;
  }
  
  int
  vips_watermark(VipsImage *in, VipsImage **out, WatermarkTextOptions *to, WatermarkOptions *o) {
  	double ones[3] = { 1, 1, 1 };
  
  	VipsImage *base = vips_image_new();
  	VipsImage **t = (VipsImage **) vips_object_local_array(VIPS_OBJECT(base), 10);
  	t[0] = in;
  
  	// Make the mask.
  	if (
  		vips_text(&t[1], to->Text,
  			"width", o->Width,
  			"dpi", o->DPI,
  			"font", to->Font,
  			NULL) ||
  		vips_linear1(t[1], &t[2], o->Opacity, 0.0, NULL) ||
  		vips_cast(t[2], &t[3], VIPS_FORMAT_UCHAR, NULL) ||
  		vips_embed(t[3], &t[4], o->Left, o->Top, t[3]->Xsize + o->Margin + o->Left, t[3]->Ysize + o->Margin +  o->Top, NULL)
  		) {
  		g_object_unref(base);
  		return 1;
  	}
  
  	// Replicate if necessary
  	if (o->NoReplicate != 1) {
  		VipsImage *cache = vips_image_new();
  		if (vips_watermark_replicate(t[0], t[4], &cache)) {
  			g_object_unref(cache);
  			g_object_unref(base);
  			return 1;
  		}
  		g_object_unref(t[4]);
  		t[4] = cache;
  	}
  
  	// Make the constant image to paint the text with.
  	if (
  		vips_black(&t[5], 1, 1, NULL) ||
  		vips_linear(t[5], &t[6], ones, o->Background, 3, NULL) ||
  		vips_cast(t[6], &t[7], VIPS_FORMAT_UCHAR, NULL) ||
  		vips_copy(t[7], &t[8], "interpretation", t[0]->Type, NULL) ||
  		vips_embed(t[8], &t[9], 0, 0, t[0]->Xsize, t[0]->Ysize, "extend", VIPS_EXTEND_COPY, NULL)
  		) {
  		g_object_unref(base);
  		return 1;
  	}
  
  	// Blend the mask and text and write to output.
  	if (vips_ifthenelse(t[4], t[9], t[0], out, "blend", TRUE, NULL)) {
  		g_object_unref(base);
  		return 1;
  	}
  
  	g_object_unref(base);
  	return 0;
  }
  
  int
  vips_gaussblur_bridge(VipsImage *in, VipsImage **out, double sigma, double min_ampl) {
  #if (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 41)
  	return vips_gaussblur(in, out, (int) sigma, NULL);
  #else
  	return vips_gaussblur(in, out, sigma, NULL, "min_ampl", min_ampl, NULL);
  #endif
  }
  
  int
  vips_sharpen_bridge(VipsImage *in, VipsImage **out, int radius, double x1, double y2, double y3, double m1, double m2) {
  #if (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 41)
  	return vips_sharpen(in, out, radius, x1, y2, y3, m1, m2, NULL);
  #else
  	return vips_sharpen(in, out, "radius", radius, "x1", x1, "y2", y2, "y3", y3, "m1", m1, "m2", m2, NULL);
  #endif
  }
  
  int
  vips_add_band(VipsImage *in, VipsImage **out, double c) {
  #if (VIPS_MAJOR_VERSION > 8 || (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 2))
  	return vips_bandjoin_const1(in, out, c, NULL);
  #else
  	VipsImage *base = vips_image_new();
  	if (
  		vips_black(&base, in->Xsize, in->Ysize, NULL) ||
  		vips_linear1(base, &base, 1, c, NULL)) {
  			g_object_unref(base);
  			return 1;
  		}
  	g_object_unref(base);
  	return vips_bandjoin2(in, base, out, c, NULL);
  #endif
  }
  
  int
  vips_watermark_image(VipsImage *in, VipsImage *sub, VipsImage **out, WatermarkImageOptions *o) {
  	VipsImage *base = vips_image_new();
  	VipsImage **t = (VipsImage **) vips_object_local_array(VIPS_OBJECT(base), 10);
  
    // add in and sub for unreffing and later use
  	t[0] = in;
  	t[1] = sub;
  
    if (has_alpha_channel(in) == 0) {
  		vips_add_band(in, &t[0], 255.0);
  		// in is no longer in the array and won't be unreffed, so add it at the end
  		t[8] = in;
  	}
  
  	if (has_alpha_channel(sub) == 0) {
  		vips_add_band(sub, &t[1], 255.0);
  		// sub is no longer in the array and won't be unreffed, so add it at the end
  		t[9] = sub;
  	}
  
  	// Place watermark image in the right place and size it to the size of the
  	// image that should be watermarked
  	if (
  		vips_embed(t[1], &t[2], o->Left, o->Top, t[0]->Xsize, t[0]->Ysize, NULL)) {
  			g_object_unref(base);
  		return 1;
  	}
  
  	// Create a mask image based on the alpha band from the watermark image
  	// and place it in the right position
  	if (
  		vips_extract_band(t[1], &t[3], t[1]->Bands - 1, "n", 1, NULL) ||
  		vips_linear1(t[3], &t[4], o->Opacity, 0.0, NULL) ||
  		vips_cast(t[4], &t[5], VIPS_FORMAT_UCHAR, NULL) ||
  		vips_copy(t[5], &t[6], "interpretation", t[0]->Type, NULL) ||
  		vips_embed(t[6], &t[7], o->Left, o->Top, t[0]->Xsize, t[0]->Ysize, NULL))	{
  			g_object_unref(base);
  		return 1;
  	}
  
  	// Blend the mask and watermark image and write to output.
  	if (vips_ifthenelse(t[7], t[2], t[0], out, "blend", TRUE, NULL)) {
  		g_object_unref(base);
  		return 1;
  	}
  
  	g_object_unref(base);
  	return 0;
  }
  
  int
  vips_smartcrop_bridge(VipsImage *in, VipsImage **out, int width, int height) {
  #if (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 5)
  	return vips_smartcrop(in, out, width, height, NULL);
  #else
  	return 0;
  #endif
  }
  
  int vips_find_trim_bridge(VipsImage *in, int *top, int *left, int *width, int *height, double r, double g, double b, double threshold) {
  #if (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 6)
  	if (vips_is_16bit(in->Type)) {
  		r = 65535 * r / 255;
  		g = 65535 * g / 255;
  		b = 65535 * b / 255;
  	}
  
  	double background[3] = {r, g, b};
  	VipsArrayDouble *vipsBackground = vips_array_double_new(background, 3);
  	return vips_find_trim(in, top, left, width, height, "background", vipsBackground, "threshold", threshold, NULL);
  #else
  	return 0;
  #endif
  }
  
  int vips_gamma_bridge(VipsImage *in, VipsImage **out, double exponent)
  {
    return vips_gamma(in, out, "exponent", 1.0 / exponent, NULL);
  }
  