vips_sys/bindings/

prebuilt.rs

/* automatically generated by rust-bindgen (vips-sys)
 *
 * Pregenerated FFI declarations for the public libvips C API.
 * Part of vips-sys (MIT). The libvips library itself is LGPL-2.1;
 * linking/distributing against it requires LGPL-2.1 compliance.
 * See README “License”.
 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    fn extract_bit(byte: u8, index: usize) -> bool {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        Self::extract_bit(byte, index)
    }
    #[inline]
    pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
        };
        Self::extract_bit(byte, index)
    }
    #[inline]
    fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val { byte | mask } else { byte & !mask }
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        *byte = Self::change_bit(*byte, index, val);
    }
    #[inline]
    pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
        };
        unsafe { *byte = Self::change_bit(*byte, index, val) };
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len());
        if bit_width == 0 {
            return 0;
        }
        let mut val = 0u64;
        let storage = self.storage.as_ref();
        let start_byte = bit_offset / 8;
        let bit_shift = bit_offset % 8;
        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
        if cfg!(target_endian = "big") {
            for i in 0..bytes_needed {
                val |= (storage[start_byte + i].reverse_bits() as u64) << (i * 8);
            }
        } else {
            for i in 0..bytes_needed {
                val |= (storage[start_byte + i] as u64) << (i * 8);
            }
        }
        val >>= bit_shift;
        if bit_width < 64 {
            val &= (1u64 << bit_width) - 1;
        }
        if cfg!(target_endian = "big") {
            val = val.reverse_bits() >> (64 - bit_width as usize);
        }
        val
    }
    #[inline]
    pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!(
            (bit_offset + (bit_width as usize) + 7) / 8 <= core::mem::size_of::<Storage>()
        );
        if bit_width == 0 {
            return 0;
        }
        let mut val = 0u64;
        let start_byte = bit_offset / 8;
        let bit_shift = bit_offset % 8;
        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
        let storage_ptr = unsafe { core::ptr::addr_of!((*this).storage) as *const u8 };
        if cfg!(target_endian = "big") {
            for i in 0..bytes_needed {
                let byte = unsafe { *storage_ptr.add(start_byte + i) };
                val |= (byte.reverse_bits() as u64) << (i * 8);
            }
        } else {
            for i in 0..bytes_needed {
                let byte = unsafe { *storage_ptr.add(start_byte + i) };
                val |= (byte as u64) << (i * 8);
            }
        }
        val >>= bit_shift;
        if bit_width < 64 {
            val &= (1u64 << bit_width) - 1;
        }
        if cfg!(target_endian = "big") {
            val = val.reverse_bits() >> (64 - bit_width as usize);
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len());
        if bit_width == 0 {
            return;
        }
        let mut val = val;
        if bit_width < 64 {
            val &= (1u64 << bit_width) - 1;
        }
        if cfg!(target_endian = "big") {
            val = val.reverse_bits() >> (64 - bit_width as usize);
        }
        let storage = self.storage.as_mut();
        let start_byte = bit_offset / 8;
        let bit_shift = bit_offset % 8;
        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
        val <<= bit_shift;
        let field_mask = if bit_width as usize + bit_shift >= 64 {
            !0u64 << bit_shift
        } else {
            ((1u64 << bit_width) - 1) << bit_shift
        };
        for i in 0..bytes_needed {
            let byte_val = (val >> (i * 8)) as u8;
            let byte_mask = (field_mask >> (i * 8)) as u8;
            if cfg!(target_endian = "big") {
                let byte = storage[start_byte + i].reverse_bits();
                let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                storage[start_byte + i] = new_byte.reverse_bits();
            } else {
                storage[start_byte + i] =
                    (storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
            }
        }
    }
    #[inline]
    pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!(
            (bit_offset + (bit_width as usize) + 7) / 8 <= core::mem::size_of::<Storage>()
        );
        if bit_width == 0 {
            return;
        }
        let mut val = val;
        if bit_width < 64 {
            val &= (1u64 << bit_width) - 1;
        }
        if cfg!(target_endian = "big") {
            val = val.reverse_bits() >> (64 - bit_width as usize);
        }
        let start_byte = bit_offset / 8;
        let bit_shift = bit_offset % 8;
        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
        val <<= bit_shift;
        let field_mask = if bit_width as usize + bit_shift >= 64 {
            !0u64 << bit_shift
        } else {
            ((1u64 << bit_width) - 1) << bit_shift
        };
        let storage_ptr = unsafe { core::ptr::addr_of_mut!((*this).storage) as *mut u8 };
        for i in 0..bytes_needed {
            let byte_val = (val >> (i * 8)) as u8;
            let byte_mask = (field_mask >> (i * 8)) as u8;
            let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
            if cfg!(target_endian = "big") {
                let byte = unsafe { (*byte_ptr).reverse_bits() };
                let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                unsafe { *byte_ptr = new_byte.reverse_bits() };
            } else {
                unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
            }
        }
    }
}
#[doc = " Const-generic methods for efficient bitfield access when offset and width"]
#[doc = " are known at compile time."]
impl<const N: usize> __BindgenBitfieldUnit<[u8; N]> {
    #[doc = " Get a field using const generics for compile-time optimization."]
    #[doc = " Uses native word size operations when the field fits in usize."]
    #[inline]
    pub const fn get_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(&self) -> u64 {
        debug_assert!(BIT_WIDTH <= 64);
        debug_assert!(BIT_OFFSET / 8 < N);
        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
        if BIT_WIDTH == 0 {
            return 0;
        }
        let start_byte = BIT_OFFSET / 8;
        let bit_shift = BIT_OFFSET % 8;
        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
            let mut val = 0usize;
            if cfg!(target_endian = "big") {
                let mut i = 0;
                while i < bytes_needed {
                    val |= (self.storage[start_byte + i].reverse_bits() as usize) << (i * 8);
                    i += 1;
                }
            } else {
                let mut i = 0;
                while i < bytes_needed {
                    val |= (self.storage[start_byte + i] as usize) << (i * 8);
                    i += 1;
                }
            }
            val >>= bit_shift;
            if (BIT_WIDTH as u32) < usize::BITS {
                val &= (1usize << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
            }
            val as u64
        } else {
            let mut val = 0u64;
            if cfg!(target_endian = "big") {
                let mut i = 0;
                while i < bytes_needed {
                    val |= (self.storage[start_byte + i].reverse_bits() as u64) << (i * 8);
                    i += 1;
                }
            } else {
                let mut i = 0;
                while i < bytes_needed {
                    val |= (self.storage[start_byte + i] as u64) << (i * 8);
                    i += 1;
                }
            }
            val >>= bit_shift;
            if BIT_WIDTH < 64 {
                val &= (1u64 << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
            }
            val
        }
    }
    #[doc = " Set a field using const generics for compile-time optimization."]
    #[doc = " Uses native word size operations when the field fits in usize."]
    #[inline]
    pub fn set_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(&mut self, val: u64) {
        debug_assert!(BIT_WIDTH <= 64);
        debug_assert!(BIT_OFFSET / 8 < N);
        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
        if BIT_WIDTH == 0 {
            return;
        }
        let start_byte = BIT_OFFSET / 8;
        let bit_shift = BIT_OFFSET % 8;
        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
            let mut val = val as usize;
            if (BIT_WIDTH as u32) < usize::BITS {
                val &= (1usize << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
            }
            val <<= bit_shift;
            let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize {
                !0usize << bit_shift
            } else {
                ((1usize << BIT_WIDTH) - 1) << bit_shift
            };
            let mut i = 0;
            while i < bytes_needed {
                let byte_val = (val >> (i * 8)) as u8;
                let byte_mask = (field_mask >> (i * 8)) as u8;
                if cfg!(target_endian = "big") {
                    let byte = self.storage[start_byte + i].reverse_bits();
                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                    self.storage[start_byte + i] = new_byte.reverse_bits();
                } else {
                    self.storage[start_byte + i] =
                        (self.storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
                }
                i += 1;
            }
        } else {
            let mut val = val;
            if BIT_WIDTH < 64 {
                val &= (1u64 << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
            }
            val <<= bit_shift;
            let field_mask = if BIT_WIDTH as usize + bit_shift >= 64 {
                !0u64 << bit_shift
            } else {
                ((1u64 << BIT_WIDTH) - 1) << bit_shift
            };
            let mut i = 0;
            while i < bytes_needed {
                let byte_val = (val >> (i * 8)) as u8;
                let byte_mask = (field_mask >> (i * 8)) as u8;
                if cfg!(target_endian = "big") {
                    let byte = self.storage[start_byte + i].reverse_bits();
                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                    self.storage[start_byte + i] = new_byte.reverse_bits();
                } else {
                    self.storage[start_byte + i] =
                        (self.storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
                }
                i += 1;
            }
        }
    }
    #[doc = " Raw pointer get using const generics for compile-time optimization."]
    #[doc = " Uses native word size operations when the field fits in usize."]
    #[inline]
    pub const unsafe fn raw_get_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(
        this: *const Self,
    ) -> u64 {
        debug_assert!(BIT_WIDTH <= 64);
        debug_assert!(BIT_OFFSET / 8 < N);
        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
        if BIT_WIDTH == 0 {
            return 0;
        }
        let start_byte = BIT_OFFSET / 8;
        let bit_shift = BIT_OFFSET % 8;
        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
        let storage_ptr = unsafe { core::ptr::addr_of!((*this).storage) as *const u8 };
        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
            let mut val = 0usize;
            if cfg!(target_endian = "big") {
                let mut i = 0;
                while i < bytes_needed {
                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
                    val |= (byte.reverse_bits() as usize) << (i * 8);
                    i += 1;
                }
            } else {
                let mut i = 0;
                while i < bytes_needed {
                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
                    val |= (byte as usize) << (i * 8);
                    i += 1;
                }
            }
            val >>= bit_shift;
            if (BIT_WIDTH as u32) < usize::BITS {
                val &= (1usize << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
            }
            val as u64
        } else {
            let mut val = 0u64;
            if cfg!(target_endian = "big") {
                let mut i = 0;
                while i < bytes_needed {
                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
                    val |= (byte.reverse_bits() as u64) << (i * 8);
                    i += 1;
                }
            } else {
                let mut i = 0;
                while i < bytes_needed {
                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
                    val |= (byte as u64) << (i * 8);
                    i += 1;
                }
            }
            val >>= bit_shift;
            if BIT_WIDTH < 64 {
                val &= (1u64 << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
            }
            val
        }
    }
    #[doc = " Raw pointer set using const generics for compile-time optimization."]
    #[doc = " Uses native word size operations when the field fits in usize."]
    #[inline]
    pub unsafe fn raw_set_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(
        this: *mut Self,
        val: u64,
    ) {
        debug_assert!(BIT_WIDTH <= 64);
        debug_assert!(BIT_OFFSET / 8 < N);
        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
        if BIT_WIDTH == 0 {
            return;
        }
        let start_byte = BIT_OFFSET / 8;
        let bit_shift = BIT_OFFSET % 8;
        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
        let storage_ptr = this.cast::<[u8; N]>().cast::<u8>();
        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
            let mut val = val as usize;
            if (BIT_WIDTH as u32) < usize::BITS {
                val &= (1usize << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
            }
            val <<= bit_shift;
            let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize {
                !0usize << bit_shift
            } else {
                ((1usize << BIT_WIDTH) - 1) << bit_shift
            };
            let mut i = 0;
            while i < bytes_needed {
                let byte_val = (val >> (i * 8)) as u8;
                let byte_mask = (field_mask >> (i * 8)) as u8;
                let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
                if cfg!(target_endian = "big") {
                    let byte = unsafe { (*byte_ptr).reverse_bits() };
                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                    unsafe { *byte_ptr = new_byte.reverse_bits() };
                } else {
                    unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
                }
                i += 1;
            }
        } else {
            let mut val = val;
            if BIT_WIDTH < 64 {
                val &= (1u64 << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
            }
            val <<= bit_shift;
            let field_mask = if BIT_WIDTH as usize + bit_shift >= 64 {
                !0u64 << bit_shift
            } else {
                ((1u64 << BIT_WIDTH) - 1) << bit_shift
            };
            let mut i = 0;
            while i < bytes_needed {
                let byte_val = (val >> (i * 8)) as u8;
                let byte_mask = (field_mask >> (i * 8)) as u8;
                let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
                if cfg!(target_endian = "big") {
                    let byte = unsafe { (*byte_ptr).reverse_bits() };
                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                    unsafe { *byte_ptr = new_byte.reverse_bits() };
                } else {
                    unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
                }
                i += 1;
            }
        }
    }
}
pub const VIPS_PI: f64 = 3.141592653589793;
pub const VIPS_PATH_MAX: u32 = 4096;
pub const VIPS_TARGET_BUFFER_SIZE: u32 = 8500;
pub const VIPS_TARGET_CUSTOM_BUFFER_SIZE: u32 = 4096;
pub const VIPS_SBUF_BUFFER_SIZE: u32 = 4096;
pub const VIPS_VERSION: &[u8; 7] = b"8.18.7\0";
pub const VIPS_VERSION_STRING: &[u8; 7] = b"8.18.7\0";
pub const VIPS_MAJOR_VERSION: u32 = 8;
pub const VIPS_MINOR_VERSION: u32 = 18;
pub const VIPS_MICRO_VERSION: u32 = 7;
pub const VIPS_LIBRARY_CURRENT: u32 = 62;
pub const VIPS_LIBRARY_REVISION: u32 = 7;
pub const VIPS_LIBRARY_AGE: u32 = 20;
pub const VIPS_CONFIG: &[u8; 29] = b"vendored headers for bindgen\0";
pub const VIPS_ENABLE_DEPRECATED: u32 = 1;
pub const VIPS_SPARE: u32 = 8;
pub const VIPS_SIZEOF_HEADER: u32 = 64;
pub const VIPS__TILE_WIDTH: u32 = 128;
pub const VIPS__TILE_HEIGHT: u32 = 128;
pub const VIPS__THINSTRIP_HEIGHT: u32 = 1;
pub const VIPS__FATSTRIP_HEIGHT: u32 = 16;
pub const VIPS_MAGIC_INTEL: u32 = 3064394248;
pub const VIPS_MAGIC_SPARC: u32 = 150120118;
pub const VIPS_DEFAULT_MAX_COORD: u32 = 100000000;
pub const VIPS_TRANSFORM_SHIFT: u32 = 6;
pub const VIPS_TRANSFORM_SCALE: u32 = 64;
pub const VIPS_INTERPOLATE_SHIFT: u32 = 12;
pub const VIPS_INTERPOLATE_SCALE: u32 = 4096;
pub const VIPS_META_EXIF_NAME: &[u8; 10] = b"exif-data\0";
pub const VIPS_META_XMP_NAME: &[u8; 9] = b"xmp-data\0";
pub const VIPS_META_IPTC_NAME: &[u8; 10] = b"iptc-data\0";
pub const VIPS_META_PHOTOSHOP_NAME: &[u8; 15] = b"photoshop-data\0";
pub const VIPS_META_ICC_NAME: &[u8; 17] = b"icc-profile-data\0";
pub const VIPS_META_IMAGEDESCRIPTION: &[u8; 18] = b"image-description\0";
pub const VIPS_META_RESOLUTION_UNIT: &[u8; 16] = b"resolution-unit\0";
pub const VIPS_META_BITS_PER_SAMPLE: &[u8; 16] = b"bits-per-sample\0";
pub const VIPS_META_PALETTE: &[u8; 8] = b"palette\0";
pub const VIPS_META_LOADER: &[u8; 12] = b"vips-loader\0";
pub const VIPS_META_SEQUENTIAL: &[u8; 16] = b"vips-sequential\0";
pub const VIPS_META_ORIENTATION: &[u8; 12] = b"orientation\0";
pub const VIPS_META_PAGE_HEIGHT: &[u8; 12] = b"page-height\0";
pub const VIPS_META_N_PAGES: &[u8; 8] = b"n-pages\0";
pub const VIPS_META_N_SUBIFDS: &[u8; 10] = b"n-subifds\0";
pub const VIPS_META_CONCURRENCY: &[u8; 12] = b"concurrency\0";
pub const VIPS_META_TILE_WIDTH: &[u8; 11] = b"tile-width\0";
pub const VIPS_META_TILE_HEIGHT: &[u8; 12] = b"tile-height\0";
pub const VIPS_D93_X0: f64 = 89.74;
pub const VIPS_D93_Y0: f64 = 100.0;
pub const VIPS_D93_Z0: f64 = 130.77;
pub const VIPS_D75_X0: f64 = 94.9682;
pub const VIPS_D75_Y0: f64 = 100.0;
pub const VIPS_D75_Z0: f64 = 122.571;
pub const VIPS_D65_X0: f64 = 95.047;
pub const VIPS_D65_Y0: f64 = 100.0;
pub const VIPS_D65_Z0: f64 = 108.8827;
pub const VIPS_D55_X0: f64 = 95.6831;
pub const VIPS_D55_Y0: f64 = 100.0;
pub const VIPS_D55_Z0: f64 = 92.0871;
pub const VIPS_D50_X0: f64 = 96.425;
pub const VIPS_D50_Y0: f64 = 100.0;
pub const VIPS_D50_Z0: f64 = 82.468;
pub const VIPS_A_X0: f64 = 109.8503;
pub const VIPS_A_Y0: f64 = 100.0;
pub const VIPS_A_Z0: f64 = 35.5849;
pub const VIPS_B_X0: f64 = 99.072;
pub const VIPS_B_Y0: f64 = 100.0;
pub const VIPS_B_Z0: f64 = 85.223;
pub const VIPS_C_X0: f64 = 98.07;
pub const VIPS_C_Y0: f64 = 100.0;
pub const VIPS_C_Z0: f64 = 118.23;
pub const VIPS_E_X0: f64 = 100.0;
pub const VIPS_E_Y0: f64 = 100.0;
pub const VIPS_E_Z0: f64 = 100.0;
pub const VIPS_D3250_X0: f64 = 105.659;
pub const VIPS_D3250_Y0: f64 = 100.0;
pub const VIPS_D3250_Z0: f64 = 45.8501;
pub const VIPS_META_IPCT_NAME: &[u8; 10] = b"iptc-data\0";
pub const VIPS_EXEEXT: &[u8; 1] = b"\0";
pub const VIPS_VECTOR_SOURCE_MAX: u32 = 10;
pub const VIPS_SAVEABLE_LAST: u32 = 99;
pub type guint8 = core::ffi::c_uchar;
pub type guint32 = core::ffi::c_uint;
pub type gint64 = core::ffi::c_longlong;
pub type guint64 = core::ffi::c_ulonglong;
pub type gssize = isize;
pub type gsize = usize;
pub type __int64_t = core::ffi::c_longlong;
pub type __darwin_off_t = __int64_t;
pub type gchar = core::ffi::c_char;
pub type glong = core::ffi::c_long;
pub type gint = core::ffi::c_int;
pub type gboolean = gint;
pub type gulong = core::ffi::c_ulong;
pub type guint = core::ffi::c_uint;
pub type gfloat = f32;
pub type gdouble = f64;
pub type gpointer = *mut core::ffi::c_void;
pub type GFunc = ::core::option::Option<unsafe extern "C" fn(data: gpointer, user_data: gpointer)>;
pub type GByteArray = _GByteArray;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GByteArray {
    pub data: *mut guint8,
    pub len: guint,
}
pub type va_list = __builtin_va_list;
pub type GQuark = guint32;
pub type GError = _GError;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GError {
    pub domain: GQuark,
    pub code: gint,
    pub message: *mut gchar,
}
pub type GThreadFunc = ::core::option::Option<unsafe extern "C" fn(data: gpointer) -> gpointer>;
pub type GThread = _GThread;
pub type GMutex = _GMutex;
pub type GCond = _GCond;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GMutex {
    pub p: gpointer,
    pub i: [guint; 2usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GCond {
    pub p: gpointer,
    pub i: [guint; 2usize],
}
#[repr(C)]
#[derive(Debug)]
pub struct _GData {
    _unused: [u8; 0],
}
pub type GData = _GData;
unsafe extern "C" {
    pub fn g_free(mem: gpointer);
}
pub type GList = _GList;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GList {
    pub data: gpointer,
    pub next: *mut GList,
    pub prev: *mut GList,
}
#[repr(C)]
#[derive(Debug)]
pub struct _GHashTable {
    _unused: [u8; 0],
}
pub type GHashTable = _GHashTable;
pub type GSList = _GSList;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GSList {
    pub data: gpointer,
    pub next: *mut GSList,
}
pub type GString = _GString;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GString {
    pub str_: *mut gchar,
    pub len: gsize,
    pub allocated_len: gsize,
}
#[repr(C)]
#[derive(Debug)]
pub struct _GOptionGroup {
    _unused: [u8; 0],
}
pub type GOptionGroup = _GOptionGroup;
pub type GQueue = _GQueue;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GQueue {
    pub head: *mut GList,
    pub tail: *mut GList,
    pub length: guint,
}
#[repr(C)]
#[derive(Debug)]
pub struct _GTimer {
    _unused: [u8; 0],
}
pub type GTimer = _GTimer;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GThreadPriority {
    G_THREAD_PRIORITY_LOW = 0,
    G_THREAD_PRIORITY_NORMAL = 1,
    G_THREAD_PRIORITY_HIGH = 2,
    G_THREAD_PRIORITY_URGENT = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GThread {
    pub func: GThreadFunc,
    pub data: gpointer,
    pub joinable: gboolean,
    pub priority: GThreadPriority,
}
pub type off_t = __darwin_off_t;
pub type fpos_t = __darwin_off_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sbuf {
    pub _base: *mut core::ffi::c_uchar,
    pub _size: core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug)]
pub struct __sFILEX {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sFILE {
    pub _p: *mut core::ffi::c_uchar,
    pub _r: core::ffi::c_int,
    pub _w: core::ffi::c_int,
    pub _flags: core::ffi::c_short,
    pub _file: core::ffi::c_short,
    pub _bf: __sbuf,
    pub _lbfsize: core::ffi::c_int,
    pub _cookie: *mut core::ffi::c_void,
    pub _close: ::core::option::Option<
        unsafe extern "C" fn(arg1: *mut core::ffi::c_void) -> core::ffi::c_int,
    >,
    pub _read: ::core::option::Option<
        unsafe extern "C" fn(
            arg1: *mut core::ffi::c_void,
            arg2: *mut core::ffi::c_char,
            __n: core::ffi::c_int,
        ) -> core::ffi::c_int,
    >,
    pub _seek: ::core::option::Option<
        unsafe extern "C" fn(
            arg1: *mut core::ffi::c_void,
            arg2: fpos_t,
            arg3: core::ffi::c_int,
        ) -> fpos_t,
    >,
    pub _write: ::core::option::Option<
        unsafe extern "C" fn(
            arg1: *mut core::ffi::c_void,
            arg2: *const core::ffi::c_char,
            __n: core::ffi::c_int,
        ) -> core::ffi::c_int,
    >,
    pub _ub: __sbuf,
    pub _extra: *mut __sFILEX,
    pub _ur: core::ffi::c_int,
    pub _ubuf: [core::ffi::c_uchar; 3usize],
    pub _nbuf: [core::ffi::c_uchar; 1usize],
    pub _lb: __sbuf,
    pub _blksize: core::ffi::c_int,
    pub _offset: fpos_t,
}
pub type FILE = __sFILE;
pub type GType = gsize;
pub type GValue = _GValue;
pub type GTypeClass = _GTypeClass;
pub type GTypeInstance = _GTypeInstance;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GTypeClass {
    pub g_type: GType,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GTypeInstance {
    pub g_class: *mut GTypeClass,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GValue {
    pub g_type: GType,
    pub data: [_GValue__bindgen_ty_1; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GValue__bindgen_ty_1 {
    pub v_int: gint,
    pub v_uint: guint,
    pub v_long: glong,
    pub v_ulong: gulong,
    pub v_int64: gint64,
    pub v_uint64: guint64,
    pub v_float: gfloat,
    pub v_double: gdouble,
    pub v_pointer: gpointer,
}
impl GParamFlags {
    pub const G_PARAM_PRIVATE: GParamFlags = GParamFlags::G_PARAM_STATIC_NAME;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GParamFlags {
    G_PARAM_READABLE = 1,
    G_PARAM_WRITABLE = 2,
    G_PARAM_READWRITE = 3,
    G_PARAM_CONSTRUCT = 4,
    G_PARAM_CONSTRUCT_ONLY = 8,
    G_PARAM_LAX_VALIDATION = 16,
    G_PARAM_STATIC_NAME = 32,
    G_PARAM_STATIC_NICK = 64,
    G_PARAM_STATIC_BLURB = 128,
    G_PARAM_EXPLICIT_NOTIFY = 1073741824,
    G_PARAM_DEPRECATED = -2147483648,
}
pub type GParamSpec = _GParamSpec;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GParamSpec {
    pub g_type_instance: GTypeInstance,
    pub name: *const gchar,
    pub flags: GParamFlags,
    pub value_type: GType,
    pub owner_type: GType,
    pub _nick: *mut gchar,
    pub _blurb: *mut gchar,
    pub qdata: *mut GData,
    pub ref_count: guint,
    pub param_id: guint,
}
pub type GClosure = _GClosure;
pub type GClosureNotifyData = _GClosureNotifyData;
pub type GCallback = ::core::option::Option<unsafe extern "C" fn()>;
pub type GClosureNotify =
    ::core::option::Option<unsafe extern "C" fn(data: gpointer, closure: *mut GClosure)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GClosureNotifyData {
    pub data: gpointer,
    pub notify: GClosureNotify,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GClosure {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub marshal: ::core::option::Option<
        unsafe extern "C" fn(
            closure: *mut GClosure,
            return_value: *mut GValue,
            n_param_values: guint,
            param_values: *const GValue,
            invocation_hint: gpointer,
            marshal_data: gpointer,
        ),
    >,
    pub data: gpointer,
    pub notifiers: *mut GClosureNotifyData,
}
impl _GClosure {
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn ref_count(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<0usize, 15u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_ref_count(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<0usize, 15u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn ref_count_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                0usize,
                15u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_ref_count_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<0usize, 15u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn meta_marshal_nouse(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<15usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_meta_marshal_nouse(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<15usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn meta_marshal_nouse_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                15usize,
                1u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_meta_marshal_nouse_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<15usize, 1u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn n_guards(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<16usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_n_guards(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<16usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn n_guards_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                16usize,
                1u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_n_guards_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<16usize, 1u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn n_fnotifiers(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<17usize, 2u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_n_fnotifiers(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<17usize, 2u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn n_fnotifiers_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                17usize,
                2u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_n_fnotifiers_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<17usize, 2u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn n_inotifiers(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<19usize, 8u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_n_inotifiers(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<19usize, 8u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn n_inotifiers_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                19usize,
                8u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_n_inotifiers_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<19usize, 8u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn in_inotify(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<27usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_in_inotify(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<27usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn in_inotify_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                27usize,
                1u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_in_inotify_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<27usize, 1u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn floating(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<28usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_floating(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<28usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn floating_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                28usize,
                1u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_floating_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<28usize, 1u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn derivative_flag(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<29usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_derivative_flag(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<29usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn derivative_flag_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                29usize,
                1u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_derivative_flag_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<29usize, 1u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn in_marshal(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<30usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_in_marshal(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<30usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn in_marshal_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                30usize,
                1u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_in_marshal_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<30usize, 1u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn is_invalid(&self) -> guint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get_const::<31usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_is_invalid(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set_const::<31usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn is_invalid_raw(this: *const Self) -> guint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get_const::<
                31usize,
                1u8,
            >(::core::ptr::addr_of!((*this)._bitfield_1))
                as u32)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_is_invalid_raw(this: *mut Self, val: guint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set_const::<31usize, 1u8>(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn new_bitfield_1(
        ref_count: guint,
        meta_marshal_nouse: guint,
        n_guards: guint,
        n_fnotifiers: guint,
        n_inotifiers: guint,
        in_inotify: guint,
        floating: guint,
        derivative_flag: guint,
        in_marshal: guint,
        is_invalid: guint,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set_const::<0usize, 15u8>({
            let ref_count: u32 = unsafe { ::core::mem::transmute(ref_count) };
            ref_count as u64
        });
        __bindgen_bitfield_unit.set_const::<15usize, 1u8>({
            let meta_marshal_nouse: u32 = unsafe { ::core::mem::transmute(meta_marshal_nouse) };
            meta_marshal_nouse as u64
        });
        __bindgen_bitfield_unit.set_const::<16usize, 1u8>({
            let n_guards: u32 = unsafe { ::core::mem::transmute(n_guards) };
            n_guards as u64
        });
        __bindgen_bitfield_unit.set_const::<17usize, 2u8>({
            let n_fnotifiers: u32 = unsafe { ::core::mem::transmute(n_fnotifiers) };
            n_fnotifiers as u64
        });
        __bindgen_bitfield_unit.set_const::<19usize, 8u8>({
            let n_inotifiers: u32 = unsafe { ::core::mem::transmute(n_inotifiers) };
            n_inotifiers as u64
        });
        __bindgen_bitfield_unit.set_const::<27usize, 1u8>({
            let in_inotify: u32 = unsafe { ::core::mem::transmute(in_inotify) };
            in_inotify as u64
        });
        __bindgen_bitfield_unit.set_const::<28usize, 1u8>({
            let floating: u32 = unsafe { ::core::mem::transmute(floating) };
            floating as u64
        });
        __bindgen_bitfield_unit.set_const::<29usize, 1u8>({
            let derivative_flag: u32 = unsafe { ::core::mem::transmute(derivative_flag) };
            derivative_flag as u64
        });
        __bindgen_bitfield_unit.set_const::<30usize, 1u8>({
            let in_marshal: u32 = unsafe { ::core::mem::transmute(in_marshal) };
            in_marshal as u64
        });
        __bindgen_bitfield_unit.set_const::<31usize, 1u8>({
            let is_invalid: u32 = unsafe { ::core::mem::transmute(is_invalid) };
            is_invalid as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum GConnectFlags {
    G_CONNECT_DEFAULT = 0,
    G_CONNECT_AFTER = 1,
    G_CONNECT_SWAPPED = 2,
}
unsafe extern "C" {
    pub fn g_signal_connect_data(
        instance: gpointer,
        detailed_signal: *const gchar,
        c_handler: GCallback,
        data: gpointer,
        destroy_data: GClosureNotify,
        connect_flags: GConnectFlags,
    ) -> gulong;
}
pub type GObject = _GObject;
pub type GObjectClass = _GObjectClass;
pub type GObjectConstructParam = _GObjectConstructParam;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObject {
    pub g_type_instance: GTypeInstance,
    pub ref_count: guint,
    pub qdata: *mut GData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObjectClass {
    pub g_type_class: GTypeClass,
    pub construct_properties: *mut GSList,
    pub constructor: ::core::option::Option<
        unsafe extern "C" fn(
            type_: GType,
            n_construct_properties: guint,
            construct_properties: *mut GObjectConstructParam,
        ) -> *mut GObject,
    >,
    pub set_property: ::core::option::Option<
        unsafe extern "C" fn(
            object: *mut GObject,
            property_id: guint,
            value: *const GValue,
            pspec: *mut GParamSpec,
        ),
    >,
    pub get_property: ::core::option::Option<
        unsafe extern "C" fn(
            object: *mut GObject,
            property_id: guint,
            value: *mut GValue,
            pspec: *mut GParamSpec,
        ),
    >,
    pub dispose: ::core::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub finalize: ::core::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub dispatch_properties_changed: ::core::option::Option<
        unsafe extern "C" fn(object: *mut GObject, n_pspecs: guint, pspecs: *mut *mut GParamSpec),
    >,
    pub notify:
        ::core::option::Option<unsafe extern "C" fn(object: *mut GObject, pspec: *mut GParamSpec)>,
    pub constructed: ::core::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub flags: gsize,
    pub n_construct_properties: gsize,
    pub pspecs: gpointer,
    pub n_pspecs: gsize,
    pub pdummy: [gpointer; 3usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObjectConstructParam {
    pub pspec: *mut GParamSpec,
    pub value: *mut GValue,
}
unsafe extern "C" {
    pub fn g_object_ref(object: gpointer) -> gpointer;
}
unsafe extern "C" {
    pub fn g_object_unref(object: gpointer);
}
#[repr(C)]
#[derive(Debug)]
pub struct _GAsyncResult {
    _unused: [u8; 0],
}
pub type GAsyncResult = _GAsyncResult;
pub type GCancellable = _GCancellable;
#[repr(C)]
#[derive(Debug)]
pub struct _GFileInfo {
    _unused: [u8; 0],
}
pub type GFileInfo = _GFileInfo;
pub type GInputStream = _GInputStream;
#[repr(C)]
#[derive(Debug)]
pub struct _GSeekable {
    _unused: [u8; 0],
}
pub type GSeekable = _GSeekable;
pub type GAsyncReadyCallback = ::core::option::Option<
    unsafe extern "C" fn(source_object: *mut GObject, res: *mut GAsyncResult, data: gpointer),
>;
pub type GInputStreamClass = _GInputStreamClass;
#[repr(C)]
#[derive(Debug)]
pub struct _GInputStreamPrivate {
    _unused: [u8; 0],
}
pub type GInputStreamPrivate = _GInputStreamPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GInputStream {
    pub parent_instance: GObject,
    pub priv_: *mut GInputStreamPrivate,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GInputStreamClass {
    pub parent_class: GObjectClass,
    pub read_fn: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            buffer: *mut core::ffi::c_void,
            count: gsize,
            cancellable: *mut GCancellable,
            error: *mut *mut GError,
        ) -> gssize,
    >,
    pub skip: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            count: gsize,
            cancellable: *mut GCancellable,
            error: *mut *mut GError,
        ) -> gssize,
    >,
    pub close_fn: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            cancellable: *mut GCancellable,
            error: *mut *mut GError,
        ) -> gboolean,
    >,
    pub read_async: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            buffer: *mut core::ffi::c_void,
            count: gsize,
            io_priority: core::ffi::c_int,
            cancellable: *mut GCancellable,
            callback: GAsyncReadyCallback,
            user_data: gpointer,
        ),
    >,
    pub read_finish: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            result: *mut GAsyncResult,
            error: *mut *mut GError,
        ) -> gssize,
    >,
    pub skip_async: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            count: gsize,
            io_priority: core::ffi::c_int,
            cancellable: *mut GCancellable,
            callback: GAsyncReadyCallback,
            user_data: gpointer,
        ),
    >,
    pub skip_finish: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            result: *mut GAsyncResult,
            error: *mut *mut GError,
        ) -> gssize,
    >,
    pub close_async: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            io_priority: core::ffi::c_int,
            cancellable: *mut GCancellable,
            callback: GAsyncReadyCallback,
            user_data: gpointer,
        ),
    >,
    pub close_finish: ::core::option::Option<
        unsafe extern "C" fn(
            stream: *mut GInputStream,
            result: *mut GAsyncResult,
            error: *mut *mut GError,
        ) -> gboolean,
    >,
    pub _g_reserved1: ::core::option::Option<unsafe extern "C" fn()>,
    pub _g_reserved2: ::core::option::Option<unsafe extern "C" fn()>,
    pub _g_reserved3: ::core::option::Option<unsafe extern "C" fn()>,
    pub _g_reserved4: ::core::option::Option<unsafe extern "C" fn()>,
    pub _g_reserved5: ::core::option::Option<unsafe extern "C" fn()>,
}
#[repr(C)]
#[derive(Debug)]
pub struct _GCancellablePrivate {
    _unused: [u8; 0],
}
pub type GCancellablePrivate = _GCancellablePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GCancellable {
    pub parent_instance: GObject,
    pub priv_: *mut GCancellablePrivate,
}
pub type VipsPel = core::ffi::c_uchar;
pub type VipsCallbackFn = ::core::option::Option<
    unsafe extern "C" fn(a: *mut core::ffi::c_void, b: *mut core::ffi::c_void) -> core::ffi::c_int,
>;
pub type VipsSListMap2Fn = ::core::option::Option<
    unsafe extern "C" fn(
        item: *mut core::ffi::c_void,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
pub type VipsSListMap4Fn = ::core::option::Option<
    unsafe extern "C" fn(
        item: *mut core::ffi::c_void,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
        c: *mut core::ffi::c_void,
        d: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
pub type VipsSListFold2Fn = ::core::option::Option<
    unsafe extern "C" fn(
        item: *mut core::ffi::c_void,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
        c: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsPrecision {
    VIPS_PRECISION_INTEGER = 0,
    VIPS_PRECISION_FLOAT = 1,
    VIPS_PRECISION_APPROXIMATE = 2,
    VIPS_PRECISION_LAST = 3,
}
unsafe extern "C" {
    pub fn vips_path_filename7(path: *const core::ffi::c_char) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_path_mode7(path: *const core::ffi::c_char) -> *mut core::ffi::c_char;
}
pub type VipsImage = _VipsImage;
pub type VipsRegion = _VipsRegion;
pub type VipsBuf = _VipsBuf;
pub type VipsSource = _VipsSource;
pub type VipsTarget = _VipsTarget;
pub type VipsInterpolate = _VipsInterpolate;
pub type VipsOperation = _VipsOperation;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsBuf {
    pub base: *mut core::ffi::c_char,
    pub mx: core::ffi::c_int,
    pub i: core::ffi::c_int,
    pub full: gboolean,
    pub lasti: core::ffi::c_int,
    pub dynamic: gboolean,
}
unsafe extern "C" {
    pub fn vips_buf_rewind(buf: *mut VipsBuf);
}
unsafe extern "C" {
    pub fn vips_buf_destroy(buf: *mut VipsBuf);
}
unsafe extern "C" {
    pub fn vips_buf_init(buf: *mut VipsBuf);
}
unsafe extern "C" {
    pub fn vips_buf_set_static(
        buf: *mut VipsBuf,
        base: *mut core::ffi::c_char,
        mx: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_buf_set_dynamic(buf: *mut VipsBuf, mx: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_buf_init_static(
        buf: *mut VipsBuf,
        base: *mut core::ffi::c_char,
        mx: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_buf_init_dynamic(buf: *mut VipsBuf, mx: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_buf_appendns(
        buf: *mut VipsBuf,
        str_: *const core::ffi::c_char,
        sz: core::ffi::c_int,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_appends(buf: *mut VipsBuf, str_: *const core::ffi::c_char) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_appendf(buf: *mut VipsBuf, fmt: *const core::ffi::c_char, ...) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_vappendf(
        buf: *mut VipsBuf,
        fmt: *const core::ffi::c_char,
        ap: va_list,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_appendc(buf: *mut VipsBuf, ch: core::ffi::c_char) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_appendgv(buf: *mut VipsBuf, value: *mut GValue) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_append_size(buf: *mut VipsBuf, n: usize) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_removec(buf: *mut VipsBuf, ch: core::ffi::c_char) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_change(
        buf: *mut VipsBuf,
        o: *const core::ffi::c_char,
        n: *const core::ffi::c_char,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_is_empty(buf: *mut VipsBuf) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_is_full(buf: *mut VipsBuf) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_all(buf: *mut VipsBuf) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_buf_firstline(buf: *mut VipsBuf) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_buf_appendg(buf: *mut VipsBuf, g: f64) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_appendd(buf: *mut VipsBuf, d: core::ffi::c_int) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_buf_len(buf: *mut VipsBuf) -> core::ffi::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsDbuf {
    pub data: *mut core::ffi::c_uchar,
    pub allocated_size: usize,
    pub data_size: usize,
    pub write_point: usize,
}
pub type VipsDbuf = _VipsDbuf;
unsafe extern "C" {
    pub fn vips_dbuf_init(dbuf: *mut VipsDbuf);
}
unsafe extern "C" {
    pub fn vips_dbuf_minimum_size(dbuf: *mut VipsDbuf, size: usize) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_dbuf_allocate(dbuf: *mut VipsDbuf, size: usize) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_dbuf_read(dbuf: *mut VipsDbuf, data: *mut core::ffi::c_uchar, size: usize)
    -> usize;
}
unsafe extern "C" {
    pub fn vips_dbuf_get_write(dbuf: *mut VipsDbuf, size: *mut usize) -> *mut core::ffi::c_uchar;
}
unsafe extern "C" {
    pub fn vips_dbuf_write(
        dbuf: *mut VipsDbuf,
        data: *const core::ffi::c_uchar,
        size: usize,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_dbuf_writef(dbuf: *mut VipsDbuf, fmt: *const core::ffi::c_char, ...) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_dbuf_write_amp(dbuf: *mut VipsDbuf, str_: *const core::ffi::c_char) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_dbuf_reset(dbuf: *mut VipsDbuf);
}
unsafe extern "C" {
    pub fn vips_dbuf_destroy(dbuf: *mut VipsDbuf);
}
unsafe extern "C" {
    pub fn vips_dbuf_seek(dbuf: *mut VipsDbuf, offset: off_t, whence: core::ffi::c_int)
    -> gboolean;
}
unsafe extern "C" {
    pub fn vips_dbuf_truncate(dbuf: *mut VipsDbuf);
}
unsafe extern "C" {
    pub fn vips_dbuf_tell(dbuf: *mut VipsDbuf) -> off_t;
}
unsafe extern "C" {
    pub fn vips_dbuf_string(dbuf: *mut VipsDbuf, size: *mut usize) -> *mut core::ffi::c_uchar;
}
unsafe extern "C" {
    pub fn vips_dbuf_steal(dbuf: *mut VipsDbuf, size: *mut usize) -> *mut core::ffi::c_uchar;
}
unsafe extern "C" {
    pub fn vips_enum_string(enm: GType, value: core::ffi::c_int) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_enum_nick(enm: GType, value: core::ffi::c_int) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_enum_from_nick(
        domain: *const core::ffi::c_char,
        type_: GType,
        str_: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_flags_from_nick(
        domain: *const core::ffi::c_char,
        type_: GType,
        nick: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_slist_equal(l1: *mut GSList, l2: *mut GSList) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_slist_map2(
        list: *mut GSList,
        fn_: VipsSListMap2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_slist_map2_rev(
        list: *mut GSList,
        fn_: VipsSListMap2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_slist_map4(
        list: *mut GSList,
        fn_: VipsSListMap4Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
        c: *mut core::ffi::c_void,
        d: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_slist_fold2(
        list: *mut GSList,
        start: *mut core::ffi::c_void,
        fn_: VipsSListFold2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_slist_filter(
        list: *mut GSList,
        fn_: VipsSListMap2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut GSList;
}
unsafe extern "C" {
    pub fn vips_slist_free_all(list: *mut GSList);
}
unsafe extern "C" {
    pub fn vips_map_equal(
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_hash_table_map(
        hash: *mut GHashTable,
        fn_: VipsSListMap2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_iscasepostfix(a: *const core::ffi::c_char, b: *const core::ffi::c_char)
    -> gboolean;
}
unsafe extern "C" {
    pub fn vips_isprefix(a: *const core::ffi::c_char, b: *const core::ffi::c_char) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_break_token(
        str_: *mut core::ffi::c_char,
        brk: *const core::ffi::c_char,
    ) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_filename_suffix_match(
        path: *const core::ffi::c_char,
        suffixes: *mut *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_file_length(fd: core::ffi::c_int) -> gint64;
}
unsafe extern "C" {
    pub fn vips_existsf(name: *const core::ffi::c_char, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_isdirf(name: *const core::ffi::c_char, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mkdirf(name: *const core::ffi::c_char, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rmdirf(name: *const core::ffi::c_char, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rename(
        old_name: *const core::ffi::c_char,
        new_name: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsToken {
    VIPS_TOKEN_LEFT = 1,
    VIPS_TOKEN_RIGHT = 2,
    VIPS_TOKEN_STRING = 3,
    VIPS_TOKEN_EQUALS = 4,
    VIPS_TOKEN_COMMA = 5,
}
unsafe extern "C" {
    pub fn vips__token_get(
        buffer: *const core::ffi::c_char,
        token: *mut VipsToken,
        string: *mut core::ffi::c_char,
        size: core::ffi::c_int,
    ) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_ispoweroftwo(p: core::ffi::c_int) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_amiMSBfirst() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_realpath(path: *const core::ffi::c_char) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_strtod(str_: *const core::ffi::c_char, out: *mut f64) -> core::ffi::c_int;
}
pub type VipsObject = _VipsObject;
pub type VipsObjectClass = _VipsObjectClass;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsArgumentFlags {
    VIPS_ARGUMENT_NONE = 0,
    VIPS_ARGUMENT_REQUIRED = 1,
    VIPS_ARGUMENT_CONSTRUCT = 2,
    VIPS_ARGUMENT_SET_ONCE = 4,
    VIPS_ARGUMENT_SET_ALWAYS = 8,
    VIPS_ARGUMENT_INPUT = 16,
    VIPS_ARGUMENT_OUTPUT = 32,
    VIPS_ARGUMENT_DEPRECATED = 64,
    VIPS_ARGUMENT_MODIFY = 128,
    VIPS_ARGUMENT_NON_HASHABLE = 256,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArgument {
    pub pspec: *mut GParamSpec,
}
pub type VipsArgument = _VipsArgument;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArgumentClass {
    pub parent: VipsArgument,
    pub object_class: *mut VipsObjectClass,
    pub flags: VipsArgumentFlags,
    pub priority: core::ffi::c_int,
    pub offset: guint,
}
pub type VipsArgumentClass = _VipsArgumentClass;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArgumentInstance {
    pub parent: VipsArgument,
    pub argument_class: *mut VipsArgumentClass,
    pub object: *mut VipsObject,
    pub assigned: gboolean,
    pub close_id: gulong,
    pub invalidate_id: gulong,
}
pub type VipsArgumentInstance = _VipsArgumentInstance;
pub type VipsArgumentTable = GHashTable;
unsafe extern "C" {
    pub fn vips_argument_get_id() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__object_set_member(
        object: *mut VipsObject,
        pspec: *mut GParamSpec,
        member: *mut *mut GObject,
        argument: *mut GObject,
    );
}
pub type VipsArgumentMapFn = ::core::option::Option<
    unsafe extern "C" fn(
        object: *mut VipsObject,
        pspec: *mut GParamSpec,
        argument_class: *mut VipsArgumentClass,
        argument_instance: *mut VipsArgumentInstance,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
unsafe extern "C" {
    pub fn vips_argument_map(
        object: *mut VipsObject,
        fn_: VipsArgumentMapFn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_object_get_args(
        object: *mut VipsObject,
        names: *mut *mut *const core::ffi::c_char,
        flags: *mut *mut core::ffi::c_int,
        n_args: *mut core::ffi::c_int,
    ) -> core::ffi::c_int;
}
pub type VipsArgumentClassMapFn = ::core::option::Option<
    unsafe extern "C" fn(
        object_class: *mut VipsObjectClass,
        pspec: *mut GParamSpec,
        argument_class: *mut VipsArgumentClass,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
unsafe extern "C" {
    pub fn vips_argument_class_map(
        object_class: *mut VipsObjectClass,
        fn_: VipsArgumentClassMapFn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_argument_class_needsstring(argument_class: *mut VipsArgumentClass) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_object_get_argument(
        object: *mut VipsObject,
        name: *const core::ffi::c_char,
        pspec: *mut *mut GParamSpec,
        argument_class: *mut *mut VipsArgumentClass,
        argument_instance: *mut *mut VipsArgumentInstance,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_object_argument_isset(
        object: *mut VipsObject,
        name: *const core::ffi::c_char,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_object_get_argument_flags(
        object: *mut VipsObject,
        name: *const core::ffi::c_char,
    ) -> VipsArgumentFlags;
}
unsafe extern "C" {
    pub fn vips_object_get_argument_priority(
        object: *mut VipsObject,
        name: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsObject {
    pub parent_instance: GObject,
    pub constructed: gboolean,
    pub static_object: gboolean,
    pub argument_table: *mut VipsArgumentTable,
    pub nickname: *mut core::ffi::c_char,
    pub description: *mut core::ffi::c_char,
    pub preclose: gboolean,
    pub close: gboolean,
    pub postclose: gboolean,
    pub local_memory: usize,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsObjectClass {
    pub parent_class: GObjectClass,
    pub build:
        ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject) -> core::ffi::c_int>,
    pub postbuild: ::core::option::Option<
        unsafe extern "C" fn(
            object: *mut VipsObject,
            data: *mut core::ffi::c_void,
        ) -> core::ffi::c_int,
    >,
    pub summary_class:
        ::core::option::Option<unsafe extern "C" fn(cls: *mut _VipsObjectClass, buf: *mut VipsBuf)>,
    pub summary:
        ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject, buf: *mut VipsBuf)>,
    pub dump:
        ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject, buf: *mut VipsBuf)>,
    pub sanity:
        ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject, buf: *mut VipsBuf)>,
    pub rewind: ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject)>,
    pub preclose: ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject)>,
    pub close: ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject)>,
    pub postclose: ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject)>,
    pub new_from_string: ::core::option::Option<
        unsafe extern "C" fn(string: *const core::ffi::c_char) -> *mut VipsObject,
    >,
    pub to_string:
        ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject, buf: *mut VipsBuf)>,
    pub output_needs_arg: gboolean,
    pub output_to_arg: ::core::option::Option<
        unsafe extern "C" fn(
            object: *mut VipsObject,
            string: *const core::ffi::c_char,
        ) -> core::ffi::c_int,
    >,
    pub nickname: *const core::ffi::c_char,
    pub description: *const core::ffi::c_char,
    pub argument_table: *mut VipsArgumentTable,
    pub argument_table_traverse: *mut GSList,
    pub argument_table_traverse_gtype: GType,
    pub deprecated: gboolean,
    pub _vips_reserved1: ::core::option::Option<unsafe extern "C" fn()>,
    pub _vips_reserved2: ::core::option::Option<unsafe extern "C" fn()>,
    pub _vips_reserved3: ::core::option::Option<unsafe extern "C" fn()>,
    pub _vips_reserved4: ::core::option::Option<unsafe extern "C" fn()>,
}
unsafe extern "C" {
    pub fn vips_value_is_null(psoec: *mut GParamSpec, value: *const GValue) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_object_set_property(
        gobject: *mut GObject,
        property_id: guint,
        value: *const GValue,
        pspec: *mut GParamSpec,
    );
}
unsafe extern "C" {
    pub fn vips_object_get_property(
        gobject: *mut GObject,
        property_id: guint,
        value: *mut GValue,
        pspec: *mut GParamSpec,
    );
}
unsafe extern "C" {
    pub fn vips_object_preclose(object: *mut VipsObject);
}
unsafe extern "C" {
    pub fn vips_object_build(object: *mut VipsObject) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_object_summary_class(klass: *mut VipsObjectClass, buf: *mut VipsBuf);
}
unsafe extern "C" {
    pub fn vips_object_summary(object: *mut VipsObject, buf: *mut VipsBuf);
}
unsafe extern "C" {
    pub fn vips_object_dump(object: *mut VipsObject, buf: *mut VipsBuf);
}
unsafe extern "C" {
    pub fn vips_object_print_summary_class(klass: *mut VipsObjectClass);
}
unsafe extern "C" {
    pub fn vips_object_print_summary(object: *mut VipsObject);
}
unsafe extern "C" {
    pub fn vips_object_print_dump(object: *mut VipsObject);
}
unsafe extern "C" {
    pub fn vips_object_print_name(object: *mut VipsObject);
}
unsafe extern "C" {
    pub fn vips_object_sanity(object: *mut VipsObject) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_object_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_object_class_install_argument(
        cls: *mut VipsObjectClass,
        pspec: *mut GParamSpec,
        flags: VipsArgumentFlags,
        priority: core::ffi::c_int,
        offset: guint,
    );
}
unsafe extern "C" {
    pub fn vips_object_set_argument_from_string(
        object: *mut VipsObject,
        name: *const core::ffi::c_char,
        value: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_object_argument_needsstring(
        object: *mut VipsObject,
        name: *const core::ffi::c_char,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_object_get_argument_to_string(
        object: *mut VipsObject,
        name: *const core::ffi::c_char,
        arg: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_object_set_required(
        object: *mut VipsObject,
        value: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
pub type VipsObjectSetArguments = ::core::option::Option<
    unsafe extern "C" fn(
        object: *mut VipsObject,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
unsafe extern "C" {
    pub fn vips_object_new(
        type_: GType,
        set: VipsObjectSetArguments,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut VipsObject;
}
unsafe extern "C" {
    pub fn vips_object_set_valist(object: *mut VipsObject, ap: va_list) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_object_set(object: *mut VipsObject, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_object_set_from_string(
        object: *mut VipsObject,
        string: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_object_new_from_string(
        object_class: *mut VipsObjectClass,
        p: *const core::ffi::c_char,
    ) -> *mut VipsObject;
}
unsafe extern "C" {
    pub fn vips_object_to_string(object: *mut VipsObject, buf: *mut VipsBuf);
}
unsafe extern "C" {
    pub fn vips_object_map(
        fn_: VipsSListMap2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
pub type VipsTypeMapFn = ::core::option::Option<
    unsafe extern "C" fn(type_: GType, a: *mut core::ffi::c_void) -> *mut core::ffi::c_void,
>;
pub type VipsTypeMap2Fn = ::core::option::Option<
    unsafe extern "C" fn(
        type_: GType,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
pub type VipsClassMapFn = ::core::option::Option<
    unsafe extern "C" fn(
        cls: *mut VipsObjectClass,
        a: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
unsafe extern "C" {
    pub fn vips_type_map(
        base: GType,
        fn_: VipsTypeMap2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_type_map_all(
        base: GType,
        fn_: VipsTypeMapFn,
        a: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_type_depth(type_: GType) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_type_find(
        basename: *const core::ffi::c_char,
        nickname: *const core::ffi::c_char,
    ) -> GType;
}
unsafe extern "C" {
    pub fn vips_nickname_find(type_: GType) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_class_map_all(
        type_: GType,
        fn_: VipsClassMapFn,
        a: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_class_find(
        basename: *const core::ffi::c_char,
        nickname: *const core::ffi::c_char,
    ) -> *const VipsObjectClass;
}
unsafe extern "C" {
    pub fn vips_object_local_array(
        parent: *mut VipsObject,
        n: core::ffi::c_int,
    ) -> *mut *mut VipsObject;
}
unsafe extern "C" {
    pub fn vips_object_local_cb(vobject: *mut VipsObject, gobject: *mut GObject);
}
unsafe extern "C" {
    pub fn vips_object_set_static(object: *mut VipsObject, static_object: gboolean);
}
unsafe extern "C" {
    pub fn vips_object_print_all();
}
unsafe extern "C" {
    pub fn vips_object_sanity_all();
}
unsafe extern "C" {
    pub fn vips_object_rewind(object: *mut VipsObject);
}
unsafe extern "C" {
    pub fn vips_object_unref_outputs(object: *mut VipsObject);
}
unsafe extern "C" {
    pub fn vips_object_get_description(object: *mut VipsObject) -> *const core::ffi::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsThing {
    pub i: core::ffi::c_int,
}
pub type VipsThing = _VipsThing;
unsafe extern "C" {
    pub fn vips_thing_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_thing_new(i: core::ffi::c_int) -> *mut VipsThing;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _VipsArea {
    pub data: *mut core::ffi::c_void,
    pub length: usize,
    pub n: core::ffi::c_int,
    pub count: core::ffi::c_int,
    pub lock: GMutex,
    pub free_fn: VipsCallbackFn,
    pub client: *mut core::ffi::c_void,
    pub type_: GType,
    pub sizeof_type: usize,
}
pub type VipsArea = _VipsArea;
unsafe extern "C" {
    pub fn vips_area_copy(area: *mut VipsArea) -> *mut VipsArea;
}
unsafe extern "C" {
    pub fn vips_area_free_cb(mem: *mut core::ffi::c_void, area: *mut VipsArea) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_area_unref(area: *mut VipsArea);
}
unsafe extern "C" {
    pub fn vips_area_new(free_fn: VipsCallbackFn, data: *mut core::ffi::c_void) -> *mut VipsArea;
}
unsafe extern "C" {
    pub fn vips_area_new_array(
        type_: GType,
        sizeof_type: usize,
        n: core::ffi::c_int,
    ) -> *mut VipsArea;
}
unsafe extern "C" {
    pub fn vips_area_new_array_object(n: core::ffi::c_int) -> *mut VipsArea;
}
unsafe extern "C" {
    pub fn vips_area_get_data(
        area: *mut VipsArea,
        length: *mut usize,
        n: *mut core::ffi::c_int,
        type_: *mut GType,
        sizeof_type: *mut usize,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_area_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_save_string_get_type() -> GType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSaveString {
    pub s: *mut core::ffi::c_char,
}
pub type VipsSaveString = _VipsSaveString;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _VipsRefString {
    pub area: VipsArea,
}
pub type VipsRefString = _VipsRefString;
unsafe extern "C" {
    pub fn vips_ref_string_new(str_: *const core::ffi::c_char) -> *mut VipsRefString;
}
unsafe extern "C" {
    pub fn vips_ref_string_get(
        refstr: *mut VipsRefString,
        length: *mut usize,
    ) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_ref_string_get_type() -> GType;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _VipsBlob {
    pub area: VipsArea,
}
pub type VipsBlob = _VipsBlob;
unsafe extern "C" {
    pub fn vips_blob_new(
        free_fn: VipsCallbackFn,
        data: *const core::ffi::c_void,
        length: usize,
    ) -> *mut VipsBlob;
}
unsafe extern "C" {
    pub fn vips_blob_copy(data: *const core::ffi::c_void, length: usize) -> *mut VipsBlob;
}
unsafe extern "C" {
    pub fn vips_blob_get(blob: *mut VipsBlob, length: *mut usize) -> *const core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_blob_set(
        blob: *mut VipsBlob,
        free_fn: VipsCallbackFn,
        data: *const core::ffi::c_void,
        length: usize,
    );
}
unsafe extern "C" {
    pub fn vips_blob_get_type() -> GType;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _VipsArrayDouble {
    pub area: VipsArea,
}
pub type VipsArrayDouble = _VipsArrayDouble;
unsafe extern "C" {
    pub fn vips_array_double_new(array: *const f64, n: core::ffi::c_int) -> *mut VipsArrayDouble;
}
unsafe extern "C" {
    pub fn vips_array_double_newv(n: core::ffi::c_int, ...) -> *mut VipsArrayDouble;
}
unsafe extern "C" {
    pub fn vips_array_double_get(array: *mut VipsArrayDouble, n: *mut core::ffi::c_int)
    -> *mut f64;
}
unsafe extern "C" {
    pub fn vips_array_double_get_type() -> GType;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _VipsArrayInt {
    pub area: VipsArea,
}
pub type VipsArrayInt = _VipsArrayInt;
unsafe extern "C" {
    pub fn vips_array_int_new(
        array: *const core::ffi::c_int,
        n: core::ffi::c_int,
    ) -> *mut VipsArrayInt;
}
unsafe extern "C" {
    pub fn vips_array_int_newv(n: core::ffi::c_int, ...) -> *mut VipsArrayInt;
}
unsafe extern "C" {
    pub fn vips_array_int_get(
        array: *mut VipsArrayInt,
        n: *mut core::ffi::c_int,
    ) -> *mut core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_array_int_get_type() -> GType;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _VipsArrayImage {
    pub area: VipsArea,
}
pub type VipsArrayImage = _VipsArrayImage;
unsafe extern "C" {
    pub fn vips_array_image_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_value_set_area(
        value: *mut GValue,
        free_fn: VipsCallbackFn,
        data: *mut core::ffi::c_void,
    );
}
unsafe extern "C" {
    pub fn vips_value_get_area(value: *const GValue, length: *mut usize) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_value_get_save_string(value: *const GValue) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_value_set_save_string(value: *mut GValue, str_: *const core::ffi::c_char);
}
unsafe extern "C" {
    pub fn vips_value_set_save_stringf(value: *mut GValue, fmt: *const core::ffi::c_char, ...);
}
unsafe extern "C" {
    pub fn vips_value_get_ref_string(
        value: *const GValue,
        length: *mut usize,
    ) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_value_set_ref_string(value: *mut GValue, str_: *const core::ffi::c_char);
}
unsafe extern "C" {
    pub fn vips_value_get_blob(value: *const GValue, length: *mut usize) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_value_set_blob(
        value: *mut GValue,
        free_fn: VipsCallbackFn,
        data: *const core::ffi::c_void,
        length: usize,
    );
}
unsafe extern "C" {
    pub fn vips_value_set_blob_free(
        value: *mut GValue,
        data: *mut core::ffi::c_void,
        length: usize,
    );
}
unsafe extern "C" {
    pub fn vips_value_set_array(
        value: *mut GValue,
        n: core::ffi::c_int,
        type_: GType,
        sizeof_type: usize,
    );
}
unsafe extern "C" {
    pub fn vips_value_get_array(
        value: *const GValue,
        n: *mut core::ffi::c_int,
        type_: *mut GType,
        sizeof_type: *mut usize,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_value_get_array_double(value: *const GValue, n: *mut core::ffi::c_int) -> *mut f64;
}
unsafe extern "C" {
    pub fn vips_value_set_array_double(value: *mut GValue, array: *const f64, n: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_value_get_array_int(
        value: *const GValue,
        n: *mut core::ffi::c_int,
    ) -> *mut core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_value_set_array_int(
        value: *mut GValue,
        array: *const core::ffi::c_int,
        n: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_value_get_array_object(
        value: *const GValue,
        n: *mut core::ffi::c_int,
    ) -> *mut *mut GObject;
}
unsafe extern "C" {
    pub fn vips_value_set_array_object(value: *mut GValue, n: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_profile_set(profile: gboolean);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsConnection {
    pub parent_object: VipsObject,
    pub descriptor: core::ffi::c_int,
    pub tracked_descriptor: core::ffi::c_int,
    pub close_descriptor: core::ffi::c_int,
    pub filename: *mut core::ffi::c_char,
}
pub type VipsConnection = _VipsConnection;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsConnectionClass {
    pub parent_class: VipsObjectClass,
}
pub type VipsConnectionClass = _VipsConnectionClass;
unsafe extern "C" {
    pub fn vips_connection_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_connection_filename(connection: *mut VipsConnection) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_connection_nick(connection: *mut VipsConnection) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_pipe_read_limit_set(limit: gint64);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSource {
    pub parent_object: VipsConnection,
    pub decode: gboolean,
    pub have_tested_seek: gboolean,
    pub is_pipe: gboolean,
    pub read_position: gint64,
    pub length: gint64,
    pub data: *const core::ffi::c_void,
    pub header_bytes: *mut GByteArray,
    pub sniff: *mut GByteArray,
    pub blob: *mut VipsBlob,
    pub mmap_baseaddr: *mut core::ffi::c_void,
    pub mmap_length: usize,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSourceClass {
    pub parent_class: VipsConnectionClass,
    pub read: ::core::option::Option<
        unsafe extern "C" fn(
            source: *mut VipsSource,
            buffer: *mut core::ffi::c_void,
            length: usize,
        ) -> gint64,
    >,
    pub seek: ::core::option::Option<
        unsafe extern "C" fn(
            source: *mut VipsSource,
            offset: gint64,
            whence: core::ffi::c_int,
        ) -> gint64,
    >,
}
pub type VipsSourceClass = _VipsSourceClass;
unsafe extern "C" {
    pub fn vips_source_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_source_new_from_descriptor(descriptor: core::ffi::c_int) -> *mut VipsSource;
}
unsafe extern "C" {
    pub fn vips_source_new_from_file(filename: *const core::ffi::c_char) -> *mut VipsSource;
}
unsafe extern "C" {
    pub fn vips_source_new_from_blob(blob: *mut VipsBlob) -> *mut VipsSource;
}
unsafe extern "C" {
    pub fn vips_source_new_from_target(target: *mut VipsTarget) -> *mut VipsSource;
}
unsafe extern "C" {
    pub fn vips_source_new_from_memory(
        data: *const core::ffi::c_void,
        length: usize,
    ) -> *mut VipsSource;
}
unsafe extern "C" {
    pub fn vips_source_new_from_options(options: *const core::ffi::c_char) -> *mut VipsSource;
}
unsafe extern "C" {
    pub fn vips_source_minimise(source: *mut VipsSource);
}
unsafe extern "C" {
    pub fn vips_source_unminimise(source: *mut VipsSource) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_source_decode(source: *mut VipsSource) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_source_read(
        source: *mut VipsSource,
        buffer: *mut core::ffi::c_void,
        length: usize,
    ) -> gint64;
}
unsafe extern "C" {
    pub fn vips_source_is_mappable(source: *mut VipsSource) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_source_is_file(source: *mut VipsSource) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_source_map(source: *mut VipsSource, length: *mut usize)
    -> *const core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_source_map_blob(source: *mut VipsSource) -> *mut VipsBlob;
}
unsafe extern "C" {
    pub fn vips_source_seek(
        source: *mut VipsSource,
        offset: gint64,
        whence: core::ffi::c_int,
    ) -> gint64;
}
unsafe extern "C" {
    pub fn vips_source_rewind(source: *mut VipsSource) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_source_sniff_at_most(
        source: *mut VipsSource,
        data: *mut *mut core::ffi::c_uchar,
        length: usize,
    ) -> gint64;
}
unsafe extern "C" {
    pub fn vips_source_sniff(source: *mut VipsSource, length: usize) -> *mut core::ffi::c_uchar;
}
unsafe extern "C" {
    pub fn vips_source_length(source: *mut VipsSource) -> gint64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSourceCustom {
    pub parent_object: VipsSource,
}
pub type VipsSourceCustom = _VipsSourceCustom;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSourceCustomClass {
    pub parent_class: VipsSourceClass,
    pub read: ::core::option::Option<
        unsafe extern "C" fn(
            source: *mut VipsSourceCustom,
            buffer: *mut core::ffi::c_void,
            length: gint64,
        ) -> gint64,
    >,
    pub seek: ::core::option::Option<
        unsafe extern "C" fn(
            source: *mut VipsSourceCustom,
            offset: gint64,
            whence: core::ffi::c_int,
        ) -> gint64,
    >,
}
pub type VipsSourceCustomClass = _VipsSourceCustomClass;
unsafe extern "C" {
    pub fn vips_source_custom_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_source_custom_new() -> *mut VipsSourceCustom;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsGInputStream {
    pub parent_instance: GInputStream,
    pub source: *mut VipsSource,
}
pub type VipsGInputStream = _VipsGInputStream;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsGInputStreamClass {
    pub parent_class: GInputStreamClass,
}
pub type VipsGInputStreamClass = _VipsGInputStreamClass;
unsafe extern "C" {
    pub fn vips_g_input_stream_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_g_input_stream_new_from_source(source: *mut VipsSource) -> *mut GInputStream;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSourceGInputStream {
    pub parent_instance: VipsSource,
    pub stream: *mut GInputStream,
    pub seekable: *mut GSeekable,
    pub info: *mut GFileInfo,
}
pub type VipsSourceGInputStream = _VipsSourceGInputStream;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSourceGInputStreamClass {
    pub parent_class: VipsSourceClass,
}
pub type VipsSourceGInputStreamClass = _VipsSourceGInputStreamClass;
unsafe extern "C" {
    pub fn vips_source_g_input_stream_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_source_g_input_stream_new(stream: *mut GInputStream)
    -> *mut VipsSourceGInputStream;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsTarget {
    pub parent_object: VipsConnection,
    pub memory: gboolean,
    pub ended: gboolean,
    pub memory_buffer: *mut GString,
    pub blob: *mut VipsBlob,
    pub output_buffer: [core::ffi::c_uchar; 8500usize],
    pub write_point: core::ffi::c_int,
    pub position: gint64,
    pub delete_on_close: gboolean,
    pub delete_on_close_filename: *mut core::ffi::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsTargetClass {
    pub parent_class: VipsConnectionClass,
    pub write: ::core::option::Option<
        unsafe extern "C" fn(
            target: *mut VipsTarget,
            data: *const core::ffi::c_void,
            length: usize,
        ) -> gint64,
    >,
    pub finish: ::core::option::Option<unsafe extern "C" fn(target: *mut VipsTarget)>,
    pub read: ::core::option::Option<
        unsafe extern "C" fn(
            target: *mut VipsTarget,
            buffer: *mut core::ffi::c_void,
            length: usize,
        ) -> gint64,
    >,
    pub seek: ::core::option::Option<
        unsafe extern "C" fn(
            target: *mut VipsTarget,
            offset: gint64,
            whence: core::ffi::c_int,
        ) -> gint64,
    >,
    pub end:
        ::core::option::Option<unsafe extern "C" fn(target: *mut VipsTarget) -> core::ffi::c_int>,
}
pub type VipsTargetClass = _VipsTargetClass;
unsafe extern "C" {
    pub fn vips_target_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_target_new_to_descriptor(descriptor: core::ffi::c_int) -> *mut VipsTarget;
}
unsafe extern "C" {
    pub fn vips_target_new_to_file(filename: *const core::ffi::c_char) -> *mut VipsTarget;
}
unsafe extern "C" {
    pub fn vips_target_new_to_memory() -> *mut VipsTarget;
}
unsafe extern "C" {
    pub fn vips_target_new_temp(based_on: *mut VipsTarget) -> *mut VipsTarget;
}
unsafe extern "C" {
    pub fn vips_target_write(
        target: *mut VipsTarget,
        data: *const core::ffi::c_void,
        length: usize,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_target_read(
        target: *mut VipsTarget,
        buffer: *mut core::ffi::c_void,
        length: usize,
    ) -> gint64;
}
unsafe extern "C" {
    pub fn vips_target_seek(
        target: *mut VipsTarget,
        offset: gint64,
        whence: core::ffi::c_int,
    ) -> gint64;
}
unsafe extern "C" {
    pub fn vips_target_end(target: *mut VipsTarget) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_target_steal(
        target: *mut VipsTarget,
        length: *mut usize,
    ) -> *mut core::ffi::c_uchar;
}
unsafe extern "C" {
    pub fn vips_target_steal_text(target: *mut VipsTarget) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_target_putc(target: *mut VipsTarget, ch: core::ffi::c_int) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_target_writes(
        target: *mut VipsTarget,
        str_: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_target_writef(
        target: *mut VipsTarget,
        fmt: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_target_write_amp(
        target: *mut VipsTarget,
        str_: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsTargetCustom {
    pub parent_object: VipsTarget,
}
pub type VipsTargetCustom = _VipsTargetCustom;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsTargetCustomClass {
    pub parent_class: VipsTargetClass,
    pub write: ::core::option::Option<
        unsafe extern "C" fn(
            target: *mut VipsTargetCustom,
            data: *const core::ffi::c_void,
            length: gint64,
        ) -> gint64,
    >,
    pub finish: ::core::option::Option<unsafe extern "C" fn(target: *mut VipsTargetCustom)>,
    pub read: ::core::option::Option<
        unsafe extern "C" fn(
            target: *mut VipsTargetCustom,
            buffer: *mut core::ffi::c_void,
            length: gint64,
        ) -> gint64,
    >,
    pub seek: ::core::option::Option<
        unsafe extern "C" fn(
            target: *mut VipsTargetCustom,
            offset: gint64,
            whence: core::ffi::c_int,
        ) -> gint64,
    >,
    pub end: ::core::option::Option<
        unsafe extern "C" fn(target: *mut VipsTargetCustom) -> core::ffi::c_int,
    >,
}
pub type VipsTargetCustomClass = _VipsTargetCustomClass;
unsafe extern "C" {
    pub fn vips_target_custom_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_target_custom_new() -> *mut VipsTargetCustom;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSbuf {
    pub parent_object: VipsObject,
    pub source: *mut VipsSource,
    pub input_buffer: [core::ffi::c_uchar; 4097usize],
    pub chars_in_buffer: core::ffi::c_int,
    pub read_point: core::ffi::c_int,
    pub line: [core::ffi::c_uchar; 4097usize],
}
pub type VipsSbuf = _VipsSbuf;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsSbufClass {
    pub parent_class: VipsObjectClass,
}
pub type VipsSbufClass = _VipsSbufClass;
unsafe extern "C" {
    pub fn vips_sbuf_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_sbuf_new_from_source(source: *mut VipsSource) -> *mut VipsSbuf;
}
unsafe extern "C" {
    pub fn vips_sbuf_unbuffer(sbuf: *mut VipsSbuf);
}
unsafe extern "C" {
    pub fn vips_sbuf_getc(sbuf: *mut VipsSbuf) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sbuf_ungetc(sbuf: *mut VipsSbuf);
}
unsafe extern "C" {
    pub fn vips_sbuf_require(sbuf: *mut VipsSbuf, require: core::ffi::c_int) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sbuf_get_line(sbuf: *mut VipsSbuf) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_sbuf_get_line_copy(sbuf: *mut VipsSbuf) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_sbuf_get_non_whitespace(sbuf: *mut VipsSbuf) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_sbuf_skip_whitespace(sbuf: *mut VipsSbuf) -> core::ffi::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsRect {
    pub left: core::ffi::c_int,
    pub top: core::ffi::c_int,
    pub width: core::ffi::c_int,
    pub height: core::ffi::c_int,
}
pub type VipsRect = _VipsRect;
unsafe extern "C" {
    pub fn vips_rect_isempty(r: *const VipsRect) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_rect_includespoint(
        r: *const VipsRect,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_rect_includesrect(r1: *const VipsRect, r2: *const VipsRect) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_rect_equalsrect(r1: *const VipsRect, r2: *const VipsRect) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_rect_overlapsrect(r1: *const VipsRect, r2: *const VipsRect) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_rect_marginadjust(r: *mut VipsRect, n: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_rect_intersectrect(r1: *const VipsRect, r2: *const VipsRect, out: *mut VipsRect);
}
unsafe extern "C" {
    pub fn vips_rect_unionrect(r1: *const VipsRect, r2: *const VipsRect, out: *mut VipsRect);
}
unsafe extern "C" {
    pub fn vips_rect_dup(r: *const VipsRect) -> *mut VipsRect;
}
unsafe extern "C" {
    pub fn vips_rect_normalise(r: *mut VipsRect);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VipsWindow {
    pub ref_count: core::ffi::c_int,
    pub im: *mut _VipsImage,
    pub top: core::ffi::c_int,
    pub height: core::ffi::c_int,
    pub data: *mut VipsPel,
    pub baseaddr: *mut core::ffi::c_void,
    pub length: usize,
}
unsafe extern "C" {
    pub fn vips_window_unref(window: *mut VipsWindow) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_window_print(window: *mut VipsWindow);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VipsBufferThread {
    pub hash: *mut GHashTable,
    pub thread: *mut GThread,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsBufferCache {
    pub buffers: *mut GSList,
    pub thread: *mut GThread,
    pub im: *mut _VipsImage,
    pub buffer_thread: *mut VipsBufferThread,
    pub reserve: *mut GSList,
    pub n_reserve: core::ffi::c_int,
}
pub type VipsBufferCache = _VipsBufferCache;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsBuffer {
    pub ref_count: core::ffi::c_int,
    pub im: *mut _VipsImage,
    pub area: VipsRect,
    pub done: gboolean,
    pub cache: *mut VipsBufferCache,
    pub buf: *mut VipsPel,
    pub bsize: usize,
}
pub type VipsBuffer = _VipsBuffer;
unsafe extern "C" {
    pub fn vips_buffer_dump_all();
}
unsafe extern "C" {
    pub fn vips_buffer_done(buffer: *mut VipsBuffer);
}
unsafe extern "C" {
    pub fn vips_buffer_undone(buffer: *mut VipsBuffer);
}
unsafe extern "C" {
    pub fn vips_buffer_unref(buffer: *mut VipsBuffer);
}
unsafe extern "C" {
    pub fn vips_buffer_new(im: *mut _VipsImage, area: *mut VipsRect) -> *mut VipsBuffer;
}
unsafe extern "C" {
    pub fn vips_buffer_ref(im: *mut _VipsImage, area: *mut VipsRect) -> *mut VipsBuffer;
}
unsafe extern "C" {
    pub fn vips_buffer_unref_ref(
        buffer: *mut VipsBuffer,
        im: *mut _VipsImage,
        area: *mut VipsRect,
    ) -> *mut VipsBuffer;
}
unsafe extern "C" {
    pub fn vips_buffer_print(buffer: *mut VipsBuffer);
}
unsafe extern "C" {
    pub fn vips__render_shutdown();
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _RegionType {
    VIPS_REGION_NONE = 0,
    VIPS_REGION_BUFFER = 1,
    VIPS_REGION_OTHER_REGION = 2,
    VIPS_REGION_OTHER_IMAGE = 3,
    VIPS_REGION_WINDOW = 4,
}
pub use self::_RegionType as RegionType;
unsafe extern "C" {
    pub fn vips__region_take_ownership(reg: *mut _VipsRegion);
}
unsafe extern "C" {
    pub fn vips__region_check_ownership(reg: *mut _VipsRegion);
}
unsafe extern "C" {
    pub fn vips__region_no_ownership(reg: *mut _VipsRegion);
}
pub type VipsRegionFillFn = ::core::option::Option<
    unsafe extern "C" fn(arg1: *mut _VipsRegion, arg2: *mut core::ffi::c_void) -> core::ffi::c_int,
>;
unsafe extern "C" {
    pub fn vips_region_fill(
        reg: *mut _VipsRegion,
        r: *const VipsRect,
        fn_: VipsRegionFillFn,
        a: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__image_wio_output(image: *mut _VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__image_pio_output(image: *mut _VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__argument_get_instance(
        argument_class: *mut VipsArgumentClass,
        object: *mut VipsObject,
    ) -> *mut VipsArgumentInstance;
}
unsafe extern "C" {
    pub fn vips__argument_table_lookup(
        table: *mut VipsArgumentTable,
        pspec: *mut GParamSpec,
    ) -> *mut VipsArgument;
}
unsafe extern "C" {
    pub fn vips__demand_hint_array(
        image: *mut _VipsImage,
        hint: core::ffi::c_int,
        in_: *mut *mut _VipsImage,
    );
}
unsafe extern "C" {
    pub fn vips__image_copy_fields_array(
        out: *mut _VipsImage,
        in_: *mut *mut _VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__region_count_pixels(region: *mut _VipsRegion, nickname: *const core::ffi::c_char);
}
unsafe extern "C" {
    pub fn vips_region_dump_all();
}
unsafe extern "C" {
    pub fn vips_region_prepare_many(
        reg: *mut *mut _VipsRegion,
        r: *const VipsRect,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__view_image(image: *mut _VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__thread_gate_start(gate_name: *const core::ffi::c_char);
}
unsafe extern "C" {
    pub fn vips__thread_gate_stop(gate_name: *const core::ffi::c_char);
}
unsafe extern "C" {
    pub fn vips__thread_malloc_free(size: gint64);
}
unsafe extern "C" {
    pub fn vips__file_open_read(
        filename: *const core::ffi::c_char,
        fallback_dir: *const core::ffi::c_char,
        text_mode: gboolean,
    ) -> *mut FILE;
}
unsafe extern "C" {
    pub fn vips__file_open_write(
        filename: *const core::ffi::c_char,
        text_mode: gboolean,
    ) -> *mut FILE;
}
unsafe extern "C" {
    pub fn vips__write(
        fd: core::ffi::c_int,
        buf: *const core::ffi::c_void,
        count: usize,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__open(
        filename: *const core::ffi::c_char,
        flags: core::ffi::c_int,
        mode: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__file_read(
        fp: *mut FILE,
        name: *const core::ffi::c_char,
        length_out: *mut usize,
    ) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips__get_bytes(
        filename: *const core::ffi::c_char,
        buf: *mut core::ffi::c_uchar,
        len: gint64,
    ) -> gint64;
}
unsafe extern "C" {
    pub fn vips__seek(fd: core::ffi::c_int, pos: gint64, whence: core::ffi::c_int) -> gint64;
}
unsafe extern "C" {
    pub fn vips__filename_split8(
        name: *const core::ffi::c_char,
        filename: *mut core::ffi::c_char,
        option_string: *mut core::ffi::c_char,
    );
}
unsafe extern "C" {
    pub fn vips__temp_name(format: *const core::ffi::c_char) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips__win32_terminate(ret: core::ffi::c_int);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsRegionShrink {
    VIPS_REGION_SHRINK_MEAN = 0,
    VIPS_REGION_SHRINK_MEDIAN = 1,
    VIPS_REGION_SHRINK_MODE = 2,
    VIPS_REGION_SHRINK_MAX = 3,
    VIPS_REGION_SHRINK_MIN = 4,
    VIPS_REGION_SHRINK_NEAREST = 5,
    VIPS_REGION_SHRINK_LAST = 6,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsRegion {
    pub parent_object: VipsObject,
    pub im: *mut VipsImage,
    pub valid: VipsRect,
    pub type_: RegionType,
    pub data: *mut VipsPel,
    pub bpl: core::ffi::c_int,
    pub seq: *mut core::ffi::c_void,
    pub thread: *mut GThread,
    pub window: *mut VipsWindow,
    pub buffer: *mut VipsBuffer,
    pub invalid: gboolean,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsRegionClass {
    pub parent_class: VipsObjectClass,
}
pub type VipsRegionClass = _VipsRegionClass;
unsafe extern "C" {
    pub fn vips_region_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_region_new(image: *mut VipsImage) -> *mut VipsRegion;
}
unsafe extern "C" {
    pub fn vips_region_buffer(reg: *mut VipsRegion, r: *const VipsRect) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_image(reg: *mut VipsRegion, r: *const VipsRect) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_region(
        reg: *mut VipsRegion,
        dest: *mut VipsRegion,
        r: *const VipsRect,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_equalsregion(
        reg1: *mut VipsRegion,
        reg2: *mut VipsRegion,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_position(
        reg: *mut VipsRegion,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_paint(reg: *mut VipsRegion, r: *const VipsRect, value: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_region_paint_pel(reg: *mut VipsRegion, r: *const VipsRect, ink: *const VipsPel);
}
unsafe extern "C" {
    pub fn vips_region_black(reg: *mut VipsRegion);
}
unsafe extern "C" {
    pub fn vips_region_copy(
        reg: *mut VipsRegion,
        dest: *mut VipsRegion,
        r: *const VipsRect,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_region_shrink_method(
        from: *mut VipsRegion,
        to: *mut VipsRegion,
        target: *const VipsRect,
        method: VipsRegionShrink,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_shrink(
        from: *mut VipsRegion,
        to: *mut VipsRegion,
        target: *const VipsRect,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_prepare(reg: *mut VipsRegion, r: *const VipsRect) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_prepare_to(
        reg: *mut VipsRegion,
        dest: *mut VipsRegion,
        r: *const VipsRect,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_fetch(
        region: *mut VipsRegion,
        left: core::ffi::c_int,
        top: core::ffi::c_int,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        len: *mut usize,
    ) -> *mut VipsPel;
}
unsafe extern "C" {
    pub fn vips_region_width(region: *mut VipsRegion) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_height(region: *mut VipsRegion) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_region_invalidate(reg: *mut VipsRegion);
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsDemandStyle {
    VIPS_DEMAND_STYLE_ERROR = -1,
    VIPS_DEMAND_STYLE_SMALLTILE = 0,
    VIPS_DEMAND_STYLE_FATSTRIP = 1,
    VIPS_DEMAND_STYLE_THINSTRIP = 2,
    VIPS_DEMAND_STYLE_ANY = 3,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsImageType {
    VIPS_IMAGE_ERROR = -1,
    VIPS_IMAGE_NONE = 0,
    VIPS_IMAGE_SETBUF = 1,
    VIPS_IMAGE_SETBUF_FOREIGN = 2,
    VIPS_IMAGE_OPENIN = 3,
    VIPS_IMAGE_MMAPIN = 4,
    VIPS_IMAGE_MMAPINRW = 5,
    VIPS_IMAGE_OPENOUT = 6,
    VIPS_IMAGE_PARTIAL = 7,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsInterpretation {
    VIPS_INTERPRETATION_ERROR = -1,
    VIPS_INTERPRETATION_MULTIBAND = 0,
    VIPS_INTERPRETATION_B_W = 1,
    VIPS_INTERPRETATION_HISTOGRAM = 10,
    VIPS_INTERPRETATION_XYZ = 12,
    VIPS_INTERPRETATION_LAB = 13,
    VIPS_INTERPRETATION_CMYK = 15,
    VIPS_INTERPRETATION_LABQ = 16,
    VIPS_INTERPRETATION_RGB = 17,
    VIPS_INTERPRETATION_CMC = 18,
    VIPS_INTERPRETATION_LCH = 19,
    VIPS_INTERPRETATION_LABS = 21,
    VIPS_INTERPRETATION_sRGB = 22,
    VIPS_INTERPRETATION_YXY = 23,
    VIPS_INTERPRETATION_FOURIER = 24,
    VIPS_INTERPRETATION_RGB16 = 25,
    VIPS_INTERPRETATION_GREY16 = 26,
    VIPS_INTERPRETATION_MATRIX = 27,
    VIPS_INTERPRETATION_scRGB = 28,
    VIPS_INTERPRETATION_HSV = 29,
    VIPS_INTERPRETATION_OKLAB = 30,
    VIPS_INTERPRETATION_OKLCH = 31,
    VIPS_INTERPRETATION_LAST = 32,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsBandFormat {
    VIPS_FORMAT_NOTSET = -1,
    VIPS_FORMAT_UCHAR = 0,
    VIPS_FORMAT_CHAR = 1,
    VIPS_FORMAT_USHORT = 2,
    VIPS_FORMAT_SHORT = 3,
    VIPS_FORMAT_UINT = 4,
    VIPS_FORMAT_INT = 5,
    VIPS_FORMAT_FLOAT = 6,
    VIPS_FORMAT_COMPLEX = 7,
    VIPS_FORMAT_DOUBLE = 8,
    VIPS_FORMAT_DPCOMPLEX = 9,
    VIPS_FORMAT_LAST = 10,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsCoding {
    VIPS_CODING_ERROR = -1,
    VIPS_CODING_NONE = 0,
    VIPS_CODING_LABQ = 2,
    VIPS_CODING_RAD = 6,
    VIPS_CODING_LAST = 7,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsAccess {
    VIPS_ACCESS_RANDOM = 0,
    VIPS_ACCESS_SEQUENTIAL = 1,
    VIPS_ACCESS_SEQUENTIAL_UNBUFFERED = 2,
    VIPS_ACCESS_LAST = 3,
}
pub type VipsStartFn = ::core::option::Option<
    unsafe extern "C" fn(
        out: *mut VipsImage,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
pub type VipsGenerateFn = ::core::option::Option<
    unsafe extern "C" fn(
        out: *mut VipsRegion,
        seq: *mut core::ffi::c_void,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
        stop: *mut gboolean,
    ) -> core::ffi::c_int,
>;
pub type VipsStopFn = ::core::option::Option<
    unsafe extern "C" fn(
        seq: *mut core::ffi::c_void,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> core::ffi::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsProgress {
    pub im: *mut VipsImage,
    pub run: core::ffi::c_int,
    pub eta: core::ffi::c_int,
    pub tpels: gint64,
    pub npels: gint64,
    pub percent: core::ffi::c_int,
    pub start: *mut GTimer,
}
pub type VipsProgress = _VipsProgress;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _VipsImage {
    pub parent_instance: VipsObject,
    pub Xsize: core::ffi::c_int,
    pub Ysize: core::ffi::c_int,
    pub Bands: core::ffi::c_int,
    pub BandFmt: VipsBandFormat,
    pub Coding: VipsCoding,
    pub Type: VipsInterpretation,
    pub Xres: f64,
    pub Yres: f64,
    pub Xoffset: core::ffi::c_int,
    pub Yoffset: core::ffi::c_int,
    pub Length: core::ffi::c_int,
    pub Compression: core::ffi::c_short,
    pub Level: core::ffi::c_short,
    pub Bbits: core::ffi::c_int,
    pub time: *mut VipsProgress,
    pub Hist: *mut core::ffi::c_char,
    pub filename: *mut core::ffi::c_char,
    pub data: *mut VipsPel,
    pub kill: core::ffi::c_int,
    pub Xres_float: f32,
    pub Yres_float: f32,
    pub mode: *mut core::ffi::c_char,
    pub dtype: VipsImageType,
    pub fd: core::ffi::c_int,
    pub baseaddr: *mut core::ffi::c_void,
    pub length: usize,
    pub magic: guint32,
    pub start_fn: VipsStartFn,
    pub generate_fn: VipsGenerateFn,
    pub stop_fn: VipsStopFn,
    pub client1: *mut core::ffi::c_void,
    pub client2: *mut core::ffi::c_void,
    pub sslock: GMutex,
    pub regions: *mut GSList,
    pub dhint: VipsDemandStyle,
    pub meta: *mut GHashTable,
    pub meta_traverse: *mut GSList,
    pub sizeof_header: gint64,
    pub windows: *mut GSList,
    pub upstream: *mut GSList,
    pub downstream: *mut GSList,
    pub serial: core::ffi::c_int,
    pub history_list: *mut GSList,
    pub progress_signal: *mut VipsImage,
    pub file_length: gint64,
    pub hint_set: gboolean,
    pub delete_on_close: gboolean,
    pub delete_on_close_filename: *mut core::ffi::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsImageClass {
    pub parent_class: VipsObjectClass,
    pub preeval: ::core::option::Option<
        unsafe extern "C" fn(
            image: *mut VipsImage,
            progress: *mut VipsProgress,
            data: *mut core::ffi::c_void,
        ),
    >,
    pub eval: ::core::option::Option<
        unsafe extern "C" fn(
            image: *mut VipsImage,
            progress: *mut VipsProgress,
            data: *mut core::ffi::c_void,
        ),
    >,
    pub posteval: ::core::option::Option<
        unsafe extern "C" fn(
            image: *mut VipsImage,
            progress: *mut VipsProgress,
            data: *mut core::ffi::c_void,
        ),
    >,
    pub written: ::core::option::Option<
        unsafe extern "C" fn(
            image: *mut VipsImage,
            result: *mut core::ffi::c_int,
            data: *mut core::ffi::c_void,
        ),
    >,
    pub invalidate: ::core::option::Option<
        unsafe extern "C" fn(image: *mut VipsImage, data: *mut core::ffi::c_void),
    >,
    pub minimise: ::core::option::Option<
        unsafe extern "C" fn(image: *mut VipsImage, data: *mut core::ffi::c_void),
    >,
}
pub type VipsImageClass = _VipsImageClass;
unsafe extern "C" {
    pub fn vips_image_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_progress_set(progress: gboolean);
}
unsafe extern "C" {
    pub fn vips_image_invalidate_all(image: *mut VipsImage);
}
unsafe extern "C" {
    pub fn vips_image_minimise_all(image: *mut VipsImage);
}
unsafe extern "C" {
    pub fn vips_image_is_sequential(image: *mut VipsImage) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_image_preeval(image: *mut VipsImage);
}
unsafe extern "C" {
    pub fn vips_image_eval(image: *mut VipsImage, processed: guint64);
}
unsafe extern "C" {
    pub fn vips_image_posteval(image: *mut VipsImage);
}
unsafe extern "C" {
    pub fn vips_image_set_progress(image: *mut VipsImage, progress: gboolean);
}
unsafe extern "C" {
    pub fn vips_image_iskilled(image: *mut VipsImage) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_image_set_kill(image: *mut VipsImage, kill: gboolean);
}
unsafe extern "C" {
    pub fn vips_filename_get_filename(
        vips_filename: *const core::ffi::c_char,
    ) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_filename_get_options(
        vips_filename: *const core::ffi::c_char,
    ) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_image_new() -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_memory() -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_memory() -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_file(name: *const core::ffi::c_char, ...) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_file_RW(filename: *const core::ffi::c_char) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_file_raw(
        filename: *const core::ffi::c_char,
        xsize: core::ffi::c_int,
        ysize: core::ffi::c_int,
        bands: core::ffi::c_int,
        offset: guint64,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_memory(
        data: *const core::ffi::c_void,
        size: usize,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        bands: core::ffi::c_int,
        format: VipsBandFormat,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_memory_copy(
        data: *const core::ffi::c_void,
        size: usize,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        bands: core::ffi::c_int,
        format: VipsBandFormat,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_buffer(
        buf: *const core::ffi::c_void,
        len: usize,
        option_string: *const core::ffi::c_char,
        ...
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_source(
        source: *mut VipsSource,
        option_string: *const core::ffi::c_char,
        ...
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_matrix(
        width: core::ffi::c_int,
        height: core::ffi::c_int,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_matrixv(
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_matrix_from_array(
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        array: *const f64,
        size: core::ffi::c_int,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_matrix_from_array(
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        array: *const f64,
        size: core::ffi::c_int,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_image(
        image: *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_new_from_image1(image: *mut VipsImage, c: f64) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_set_delete_on_close(image: *mut VipsImage, delete_on_close: gboolean);
}
unsafe extern "C" {
    pub fn vips_get_disc_threshold() -> guint64;
}
unsafe extern "C" {
    pub fn vips_image_new_temp_file(format: *const core::ffi::c_char) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_write(image: *mut VipsImage, out: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_write_to_file(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_write_to_buffer(
        in_: *mut VipsImage,
        suffix: *const core::ffi::c_char,
        buf: *mut *mut core::ffi::c_void,
        size: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_write_to_target(
        in_: *mut VipsImage,
        suffix: *const core::ffi::c_char,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_write_to_memory(
        in_: *mut VipsImage,
        size: *mut usize,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_image_decode_predict(
        in_: *mut VipsImage,
        bands: *mut core::ffi::c_int,
        format: *mut VipsBandFormat,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_decode(in_: *mut VipsImage, out: *mut *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_encode(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        coding: VipsCoding,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_isMSBfirst(image: *mut VipsImage) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_image_isfile(image: *mut VipsImage) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_image_ispartial(image: *mut VipsImage) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_image_hasalpha(image: *mut VipsImage) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_image_copy_memory(image: *mut VipsImage) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_wio_input(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_pio_input(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_pio_output(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_inplace(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_write_prepare(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_write_line(
        image: *mut VipsImage,
        ypos: core::ffi::c_int,
        linebuffer: *mut VipsPel,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_band_format_isint(format: VipsBandFormat) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_band_format_isuint(format: VipsBandFormat) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_band_format_is8bit(format: VipsBandFormat) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_band_format_isfloat(format: VipsBandFormat) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_band_format_iscomplex(format: VipsBandFormat) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_system(cmd_format: *const core::ffi::c_char, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_array_image_new(
        array: *mut *mut VipsImage,
        n: core::ffi::c_int,
    ) -> *mut VipsArrayImage;
}
unsafe extern "C" {
    pub fn vips_array_image_newv(n: core::ffi::c_int, ...) -> *mut VipsArrayImage;
}
unsafe extern "C" {
    pub fn vips_array_image_new_from_string(
        string: *const core::ffi::c_char,
        flags: VipsAccess,
    ) -> *mut VipsArrayImage;
}
unsafe extern "C" {
    pub fn vips_array_image_empty() -> *mut VipsArrayImage;
}
unsafe extern "C" {
    pub fn vips_array_image_append(
        array: *mut VipsArrayImage,
        image: *mut VipsImage,
    ) -> *mut VipsArrayImage;
}
unsafe extern "C" {
    pub fn vips_array_image_get(
        array: *mut VipsArrayImage,
        n: *mut core::ffi::c_int,
    ) -> *mut *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_value_get_array_image(
        value: *const GValue,
        n: *mut core::ffi::c_int,
    ) -> *mut *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_value_set_array_image(value: *mut GValue, n: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_reorder_prepare_many(
        image: *mut VipsImage,
        regions: *mut *mut VipsRegion,
        r: *mut VipsRect,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_reorder_margin_hint(image: *mut VipsImage, margin: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_image_free_buffer(image: *mut VipsImage, buffer: *mut core::ffi::c_void);
}
pub type VipsImage_autoptr = *mut VipsImage;
pub type VipsImage_listautoptr = *mut GList;
pub type VipsImage_slistautoptr = *mut GSList;
pub type VipsImage_queueautoptr = *mut GQueue;
pub type VipsObject_autoptr = *mut VipsObject;
pub type VipsObject_listautoptr = *mut GList;
pub type VipsObject_slistautoptr = *mut GSList;
pub type VipsObject_queueautoptr = *mut GQueue;
pub type VipsRegion_autoptr = *mut VipsRegion;
pub type VipsRegion_listautoptr = *mut GList;
pub type VipsRegion_slistautoptr = *mut GSList;
pub type VipsRegion_queueautoptr = *mut GQueue;
pub type VipsConnection_autoptr = *mut VipsConnection;
pub type VipsConnection_listautoptr = *mut GList;
pub type VipsConnection_slistautoptr = *mut GSList;
pub type VipsConnection_queueautoptr = *mut GQueue;
pub type VipsSource_autoptr = *mut VipsSource;
pub type VipsSource_listautoptr = *mut GList;
pub type VipsSource_slistautoptr = *mut GSList;
pub type VipsSource_queueautoptr = *mut GQueue;
pub type VipsSourceCustom_autoptr = *mut VipsSourceCustom;
pub type VipsSourceCustom_listautoptr = *mut GList;
pub type VipsSourceCustom_slistautoptr = *mut GSList;
pub type VipsSourceCustom_queueautoptr = *mut GQueue;
pub type VipsGInputStream_autoptr = *mut VipsGInputStream;
pub type VipsGInputStream_listautoptr = *mut GList;
pub type VipsGInputStream_slistautoptr = *mut GSList;
pub type VipsGInputStream_queueautoptr = *mut GQueue;
pub type VipsSourceGInputStream_autoptr = *mut VipsSourceGInputStream;
pub type VipsSourceGInputStream_listautoptr = *mut GList;
pub type VipsSourceGInputStream_slistautoptr = *mut GSList;
pub type VipsSourceGInputStream_queueautoptr = *mut GQueue;
pub type VipsTarget_autoptr = *mut VipsTarget;
pub type VipsTarget_listautoptr = *mut GList;
pub type VipsTarget_slistautoptr = *mut GSList;
pub type VipsTarget_queueautoptr = *mut GQueue;
pub type VipsTargetCustom_autoptr = *mut VipsTargetCustom;
pub type VipsTargetCustom_listautoptr = *mut GList;
pub type VipsTargetCustom_slistautoptr = *mut GSList;
pub type VipsTargetCustom_queueautoptr = *mut GQueue;
pub type VipsSbuf_autoptr = *mut VipsSbuf;
pub type VipsSbuf_listautoptr = *mut GList;
pub type VipsSbuf_slistautoptr = *mut GSList;
pub type VipsSbuf_queueautoptr = *mut GQueue;
pub type VipsInterpolate_autoptr = *mut VipsInterpolate;
pub type VipsInterpolate_listautoptr = *mut GList;
pub type VipsInterpolate_slistautoptr = *mut GSList;
pub type VipsInterpolate_queueautoptr = *mut GQueue;
pub type VipsOperation_autoptr = *mut VipsOperation;
pub type VipsOperation_listautoptr = *mut GList;
pub type VipsOperation_slistautoptr = *mut GSList;
pub type VipsOperation_queueautoptr = *mut GQueue;
pub type VipsArrayDouble_autoptr = *mut VipsArrayDouble;
pub type VipsArrayDouble_listautoptr = *mut GList;
pub type VipsArrayDouble_slistautoptr = *mut GSList;
pub type VipsArrayDouble_queueautoptr = *mut GQueue;
pub type VipsArrayImage_autoptr = *mut VipsArrayImage;
pub type VipsArrayImage_listautoptr = *mut GList;
pub type VipsArrayImage_slistautoptr = *mut GSList;
pub type VipsArrayImage_queueautoptr = *mut GQueue;
unsafe extern "C" {
    pub fn vips_malloc(object: *mut VipsObject, size: usize) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_strdup(
        object: *mut VipsObject,
        str_: *const core::ffi::c_char,
    ) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_tracked_free(s: *mut core::ffi::c_void);
}
unsafe extern "C" {
    pub fn vips_tracked_aligned_free(s: *mut core::ffi::c_void);
}
unsafe extern "C" {
    pub fn vips_tracked_malloc(size: usize) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_tracked_aligned_alloc(size: usize, align: usize) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_tracked_get_mem() -> usize;
}
unsafe extern "C" {
    pub fn vips_tracked_get_mem_highwater() -> usize;
}
unsafe extern "C" {
    pub fn vips_tracked_get_allocs() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tracked_open(
        pathname: *const core::ffi::c_char,
        flags: core::ffi::c_int,
        mode: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tracked_close(fd: core::ffi::c_int) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tracked_get_files() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_error_buffer() -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_error_buffer_copy() -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_error_clear();
}
unsafe extern "C" {
    pub fn vips_error_freeze();
}
unsafe extern "C" {
    pub fn vips_error_thaw();
}
unsafe extern "C" {
    pub fn vips_error(domain: *const core::ffi::c_char, fmt: *const core::ffi::c_char, ...);
}
unsafe extern "C" {
    pub fn vips_verror(
        domain: *const core::ffi::c_char,
        fmt: *const core::ffi::c_char,
        ap: va_list,
    );
}
unsafe extern "C" {
    pub fn vips_error_system(
        err: core::ffi::c_int,
        domain: *const core::ffi::c_char,
        fmt: *const core::ffi::c_char,
        ...
    );
}
unsafe extern "C" {
    pub fn vips_verror_system(
        err: core::ffi::c_int,
        domain: *const core::ffi::c_char,
        fmt: *const core::ffi::c_char,
        ap: va_list,
    );
}
unsafe extern "C" {
    pub fn vips_error_g(error: *mut *mut GError);
}
unsafe extern "C" {
    pub fn vips_g_error(error: *mut *mut GError);
}
unsafe extern "C" {
    pub fn vips_error_exit(fmt: *const core::ffi::c_char, ...) -> !;
}
unsafe extern "C" {
    pub fn vips_check_uncoded(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_coding(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
        coding: VipsCoding,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_coding_known(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_coding_noneorlabq(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_coding_same(
        domain: *const core::ffi::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_mono(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_bands(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
        bands: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_bands_1or3(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_bands_atleast(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
        bands: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_bands_1orn(
        domain: *const core::ffi::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_bands_1orn_unary(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
        n: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_bands_same(
        domain: *const core::ffi::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_bandno(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
        bandno: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_int(domain: *const core::ffi::c_char, im: *mut VipsImage)
    -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_uint(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_uintorf(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_noncomplex(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_complex(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_twocomponents(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_format(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
        fmt: VipsBandFormat,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_u8or16(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_8or16(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_u8or16orf(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_format_same(
        domain: *const core::ffi::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_size_same(
        domain: *const core::ffi::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_oddsquare(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_vector_length(
        domain: *const core::ffi::c_char,
        n: core::ffi::c_int,
        len: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_vector(
        domain: *const core::ffi::c_char,
        n: core::ffi::c_int,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_hist(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_matrix(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
        out: *mut *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_separable(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_precision_intfloat(
        domain: *const core::ffi::c_char,
        precision: VipsPrecision,
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsFormatFlags {
    VIPS_FORMAT_NONE = 0,
    VIPS_FORMAT_PARTIAL = 1,
    VIPS_FORMAT_BIGENDIAN = 2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsFormat {
    pub parent_object: VipsObject,
}
pub type VipsFormat = _VipsFormat;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsFormatClass {
    pub parent_class: VipsObjectClass,
    pub is_a: ::core::option::Option<
        unsafe extern "C" fn(filename: *const core::ffi::c_char) -> gboolean,
    >,
    pub header: ::core::option::Option<
        unsafe extern "C" fn(
            filename: *const core::ffi::c_char,
            image: *mut VipsImage,
        ) -> core::ffi::c_int,
    >,
    pub load: ::core::option::Option<
        unsafe extern "C" fn(
            filename: *const core::ffi::c_char,
            image: *mut VipsImage,
        ) -> core::ffi::c_int,
    >,
    pub save: ::core::option::Option<
        unsafe extern "C" fn(
            image: *mut VipsImage,
            filename: *const core::ffi::c_char,
        ) -> core::ffi::c_int,
    >,
    pub get_flags: ::core::option::Option<
        unsafe extern "C" fn(filename: *const core::ffi::c_char) -> VipsFormatFlags,
    >,
    pub priority: core::ffi::c_int,
    pub suffs: *mut *const core::ffi::c_char,
}
pub type VipsFormatClass = _VipsFormatClass;
unsafe extern "C" {
    pub fn vips_format_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_format_map(
        fn_: VipsSListMap2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_format_for_file(filename: *const core::ffi::c_char) -> *mut VipsFormatClass;
}
unsafe extern "C" {
    pub fn vips_format_for_name(filename: *const core::ffi::c_char) -> *mut VipsFormatClass;
}
unsafe extern "C" {
    pub fn vips_format_get_flags(
        format: *mut VipsFormatClass,
        filename: *const core::ffi::c_char,
    ) -> VipsFormatFlags;
}
unsafe extern "C" {
    pub fn vips_format_read(
        filename: *const core::ffi::c_char,
        out: *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_format_write(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
pub type VipsRegionWrite = ::core::option::Option<
    unsafe extern "C" fn(
        region: *mut VipsRegion,
        area: *mut VipsRect,
        a: *mut core::ffi::c_void,
    ) -> core::ffi::c_int,
>;
unsafe extern "C" {
    pub fn vips_sink_disc(
        im: *mut VipsImage,
        write_fn: VipsRegionWrite,
        a: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sink(
        im: *mut VipsImage,
        start_fn: VipsStartFn,
        generate_fn: VipsGenerateFn,
        stop_fn: VipsStopFn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sink_tile(
        im: *mut VipsImage,
        tile_width: core::ffi::c_int,
        tile_height: core::ffi::c_int,
        start_fn: VipsStartFn,
        generate_fn: VipsGenerateFn,
        stop_fn: VipsStopFn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
pub type VipsSinkNotify = ::core::option::Option<
    unsafe extern "C" fn(im: *mut VipsImage, rect: *mut VipsRect, a: *mut core::ffi::c_void),
>;
unsafe extern "C" {
    pub fn vips_sink_screen(
        in_: *mut VipsImage,
        out: *mut VipsImage,
        mask: *mut VipsImage,
        tile_width: core::ffi::c_int,
        tile_height: core::ffi::c_int,
        max_tiles: core::ffi::c_int,
        priority: core::ffi::c_int,
        notify_fn: VipsSinkNotify,
        a: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sink_memory(im: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_start_one(
        out: *mut VipsImage,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_stop_one(
        seq: *mut core::ffi::c_void,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_start_many(
        out: *mut VipsImage,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_stop_many(
        seq: *mut core::ffi::c_void,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_allocate_input_array(out: *mut VipsImage, ...) -> *mut *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_generate(
        image: *mut VipsImage,
        start_fn: VipsStartFn,
        generate_fn: VipsGenerateFn,
        stop_fn: VipsStopFn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_pipeline_array(
        image: *mut VipsImage,
        hint: VipsDemandStyle,
        in_: *mut *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_pipelinev(
        image: *mut VipsImage,
        hint: VipsDemandStyle,
        ...
    ) -> core::ffi::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsInterpolate {
    pub parent_object: VipsObject,
}
pub type VipsInterpolateMethod = ::core::option::Option<
    unsafe extern "C" fn(
        interpolate: *mut VipsInterpolate,
        out: *mut core::ffi::c_void,
        in_: *mut VipsRegion,
        x: f64,
        y: f64,
    ),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsInterpolateClass {
    pub parent_class: VipsObjectClass,
    pub interpolate: VipsInterpolateMethod,
    pub get_window_size: ::core::option::Option<
        unsafe extern "C" fn(interpolate: *mut VipsInterpolate) -> core::ffi::c_int,
    >,
    pub window_size: core::ffi::c_int,
    pub get_window_offset: ::core::option::Option<
        unsafe extern "C" fn(interpolate: *mut VipsInterpolate) -> core::ffi::c_int,
    >,
    pub window_offset: core::ffi::c_int,
}
pub type VipsInterpolateClass = _VipsInterpolateClass;
unsafe extern "C" {
    pub fn vips_interpolate_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_interpolate(
        interpolate: *mut VipsInterpolate,
        out: *mut core::ffi::c_void,
        in_: *mut VipsRegion,
        x: f64,
        y: f64,
    );
}
unsafe extern "C" {
    pub fn vips_interpolate_get_method(interpolate: *mut VipsInterpolate) -> VipsInterpolateMethod;
}
unsafe extern "C" {
    pub fn vips_interpolate_get_window_size(interpolate: *mut VipsInterpolate) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_interpolate_get_window_offset(
        interpolate: *mut VipsInterpolate,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_interpolate_nearest_static() -> *mut VipsInterpolate;
}
unsafe extern "C" {
    pub fn vips_interpolate_bilinear_static() -> *mut VipsInterpolate;
}
unsafe extern "C" {
    pub fn vips_interpolate_new(nickname: *const core::ffi::c_char) -> *mut VipsInterpolate;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct VipsSemaphore {
    pub name: *mut core::ffi::c_char,
    pub v: core::ffi::c_int,
    pub mutex: GMutex,
    pub cond: GCond,
}
unsafe extern "C" {
    pub fn vips_semaphore_up(s: *mut VipsSemaphore) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_semaphore_upn(s: *mut VipsSemaphore, n: core::ffi::c_int) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_semaphore_down(s: *mut VipsSemaphore) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_semaphore_downn(s: *mut VipsSemaphore, n: core::ffi::c_int) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_semaphore_down_timeout(s: *mut VipsSemaphore, timeout: gint64) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_semaphore_destroy(s: *mut VipsSemaphore);
}
unsafe extern "C" {
    pub fn vips_semaphore_init(
        s: *mut VipsSemaphore,
        v: core::ffi::c_int,
        name: *mut core::ffi::c_char,
    );
}
unsafe extern "C" {
    pub fn vips_g_thread_new(
        domain: *const core::ffi::c_char,
        func: GThreadFunc,
        data: gpointer,
    ) -> *mut GThread;
}
unsafe extern "C" {
    pub fn vips_thread_isvips() -> gboolean;
}
unsafe extern "C" {
    pub fn vips_thread_execute(
        domain: *const core::ffi::c_char,
        func: GFunc,
        data: gpointer,
    ) -> core::ffi::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsThreadState {
    pub parent_object: VipsObject,
    pub im: *mut VipsImage,
    pub reg: *mut VipsRegion,
    pub pos: VipsRect,
    pub x: core::ffi::c_int,
    pub y: core::ffi::c_int,
    pub stop: gboolean,
    pub a: *mut core::ffi::c_void,
    pub stall: gboolean,
}
pub type VipsThreadState = _VipsThreadState;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsThreadStateClass {
    pub parent_class: VipsObjectClass,
}
pub type VipsThreadStateClass = _VipsThreadStateClass;
unsafe extern "C" {
    pub fn vips_thread_state_set(
        object: *mut VipsObject,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_thread_state_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_thread_state_new(
        im: *mut VipsImage,
        a: *mut core::ffi::c_void,
    ) -> *mut VipsThreadState;
}
pub type VipsThreadStartFn = ::core::option::Option<
    unsafe extern "C" fn(im: *mut VipsImage, a: *mut core::ffi::c_void) -> *mut VipsThreadState,
>;
pub type VipsThreadpoolAllocateFn = ::core::option::Option<
    unsafe extern "C" fn(
        state: *mut VipsThreadState,
        a: *mut core::ffi::c_void,
        stop: *mut gboolean,
    ) -> core::ffi::c_int,
>;
pub type VipsThreadpoolWorkFn = ::core::option::Option<
    unsafe extern "C" fn(
        state: *mut VipsThreadState,
        a: *mut core::ffi::c_void,
    ) -> core::ffi::c_int,
>;
pub type VipsThreadpoolProgressFn =
    ::core::option::Option<unsafe extern "C" fn(a: *mut core::ffi::c_void) -> core::ffi::c_int>;
unsafe extern "C" {
    pub fn vips_threadpool_run(
        im: *mut VipsImage,
        start: VipsThreadStartFn,
        allocate: VipsThreadpoolAllocateFn,
        work: VipsThreadpoolWorkFn,
        progress: VipsThreadpoolProgressFn,
        a: *mut core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_get_tile_size(
        im: *mut VipsImage,
        tile_width: *mut core::ffi::c_int,
        tile_height: *mut core::ffi::c_int,
        n_lines: *mut core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_format_sizeof(format: VipsBandFormat) -> guint64;
}
unsafe extern "C" {
    pub fn vips_format_sizeof_unsafe(format: VipsBandFormat) -> guint64;
}
unsafe extern "C" {
    pub fn vips_interpretation_max_alpha(interpretation: VipsInterpretation) -> f64;
}
unsafe extern "C" {
    pub fn vips_interpretation_bands(interpretation: VipsInterpretation) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_width(image: *const VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_height(image: *const VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_bands(image: *const VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_format(image: *const VipsImage) -> VipsBandFormat;
}
unsafe extern "C" {
    pub fn vips_image_get_format_max(format: VipsBandFormat) -> f64;
}
unsafe extern "C" {
    pub fn vips_image_guess_format(image: *const VipsImage) -> VipsBandFormat;
}
unsafe extern "C" {
    pub fn vips_image_get_coding(image: *const VipsImage) -> VipsCoding;
}
unsafe extern "C" {
    pub fn vips_image_get_interpretation(image: *const VipsImage) -> VipsInterpretation;
}
unsafe extern "C" {
    pub fn vips_image_guess_interpretation(image: *const VipsImage) -> VipsInterpretation;
}
unsafe extern "C" {
    pub fn vips_image_get_xres(image: *const VipsImage) -> f64;
}
unsafe extern "C" {
    pub fn vips_image_get_yres(image: *const VipsImage) -> f64;
}
unsafe extern "C" {
    pub fn vips_image_get_xoffset(image: *const VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_yoffset(image: *const VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_filename(image: *const VipsImage) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_image_get_mode(image: *const VipsImage) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_image_get_scale(image: *const VipsImage) -> f64;
}
unsafe extern "C" {
    pub fn vips_image_get_offset(image: *const VipsImage) -> f64;
}
unsafe extern "C" {
    pub fn vips_image_get_page_height(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_n_pages(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_n_subifds(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_orientation(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_orientation_swap(image: *mut VipsImage) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_image_get_concurrency(
        image: *mut VipsImage,
        default_concurrency: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_tile_width(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_tile_height(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_gainmap(image: *mut VipsImage) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_get_data(image: *mut VipsImage) -> *const core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_image_init_fields(
        image: *mut VipsImage,
        xsize: core::ffi::c_int,
        ysize: core::ffi::c_int,
        bands: core::ffi::c_int,
        format: VipsBandFormat,
        coding: VipsCoding,
        interpretation: VipsInterpretation,
        xres: f64,
        yres: f64,
    );
}
unsafe extern "C" {
    pub fn vips_image_set(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        value: *mut GValue,
    );
}
unsafe extern "C" {
    pub fn vips_image_get(
        image: *const VipsImage,
        name: *const core::ffi::c_char,
        value_copy: *mut GValue,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_as_string(
        image: *const VipsImage,
        name: *const core::ffi::c_char,
        out: *mut *mut core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_typeof(image: *const VipsImage, name: *const core::ffi::c_char) -> GType;
}
unsafe extern "C" {
    pub fn vips_image_remove(image: *mut VipsImage, name: *const core::ffi::c_char) -> gboolean;
}
pub type VipsImageMapFn = ::core::option::Option<
    unsafe extern "C" fn(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        value: *mut GValue,
        a: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void,
>;
unsafe extern "C" {
    pub fn vips_image_map(
        image: *mut VipsImage,
        fn_: VipsImageMapFn,
        a: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_image_get_fields(image: *mut VipsImage) -> *mut *mut gchar;
}
unsafe extern "C" {
    pub fn vips_image_set_area(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        free_fn: VipsCallbackFn,
        data: *mut core::ffi::c_void,
    );
}
unsafe extern "C" {
    pub fn vips_image_get_area(
        image: *const VipsImage,
        name: *const core::ffi::c_char,
        data: *mut *const core::ffi::c_void,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_set_blob(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        free_fn: VipsCallbackFn,
        data: *const core::ffi::c_void,
        length: usize,
    );
}
unsafe extern "C" {
    pub fn vips_image_set_blob_copy(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        data: *const core::ffi::c_void,
        length: usize,
    );
}
unsafe extern "C" {
    pub fn vips_image_get_blob(
        image: *const VipsImage,
        name: *const core::ffi::c_char,
        data: *mut *const core::ffi::c_void,
        length: *mut usize,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_int(
        image: *const VipsImage,
        name: *const core::ffi::c_char,
        out: *mut core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_set_int(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        i: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_image_get_double(
        image: *const VipsImage,
        name: *const core::ffi::c_char,
        out: *mut f64,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_set_double(image: *mut VipsImage, name: *const core::ffi::c_char, d: f64);
}
unsafe extern "C" {
    pub fn vips_image_get_string(
        image: *const VipsImage,
        name: *const core::ffi::c_char,
        out: *mut *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_set_string(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        str_: *const core::ffi::c_char,
    );
}
unsafe extern "C" {
    pub fn vips_image_print_field(image: *const VipsImage, name: *const core::ffi::c_char);
}
unsafe extern "C" {
    pub fn vips_image_get_image(
        image: *const VipsImage,
        name: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_set_image(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        im: *mut VipsImage,
    );
}
unsafe extern "C" {
    pub fn vips_image_set_array_int(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        array: *const core::ffi::c_int,
        n: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_image_get_array_int(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        out: *mut *mut core::ffi::c_int,
        n: *mut core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_array_double(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        out: *mut *mut f64,
        n: *mut core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_set_array_double(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        array: *const f64,
        n: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_image_history_printf(
        image: *mut VipsImage,
        format: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_history_args(
        image: *mut VipsImage,
        name: *const core::ffi::c_char,
        argc: core::ffi::c_int,
        argv: *mut *mut core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_get_history(image: *mut VipsImage) -> *const core::ffi::c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationFlags {
    VIPS_OPERATION_NONE = 0,
    VIPS_OPERATION_SEQUENTIAL = 1,
    VIPS_OPERATION_SEQUENTIAL_UNBUFFERED = 2,
    VIPS_OPERATION_NOCACHE = 4,
    VIPS_OPERATION_DEPRECATED = 8,
    VIPS_OPERATION_UNTRUSTED = 16,
    VIPS_OPERATION_BLOCKED = 32,
    VIPS_OPERATION_REVALIDATE = 64,
}
pub type VipsOperationBuildFn =
    ::core::option::Option<unsafe extern "C" fn(object: *mut VipsObject) -> gboolean>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsOperation {
    pub parent_instance: VipsObject,
    pub hash: guint,
    pub found_hash: gboolean,
    pub pixels: core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsOperationClass {
    pub parent_class: VipsObjectClass,
    pub usage: ::core::option::Option<
        unsafe extern "C" fn(cls: *mut _VipsOperationClass, buf: *mut VipsBuf),
    >,
    pub get_flags: ::core::option::Option<
        unsafe extern "C" fn(operation: *mut VipsOperation) -> VipsOperationFlags,
    >,
    pub flags: VipsOperationFlags,
    pub invalidate: ::core::option::Option<unsafe extern "C" fn(operation: *mut VipsOperation)>,
}
pub type VipsOperationClass = _VipsOperationClass;
unsafe extern "C" {
    pub fn vips_operation_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_get_flags(operation: *mut VipsOperation) -> VipsOperationFlags;
}
unsafe extern "C" {
    pub fn vips_operation_class_print_usage(operation_class: *mut VipsOperationClass);
}
unsafe extern "C" {
    pub fn vips_operation_invalidate(operation: *mut VipsOperation);
}
unsafe extern "C" {
    pub fn vips_operation_call_valist(
        operation: *mut VipsOperation,
        ap: va_list,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_operation_new(name: *const core::ffi::c_char) -> *mut VipsOperation;
}
unsafe extern "C" {
    pub fn vips_call_required_optional(
        operation: *mut *mut VipsOperation,
        required: va_list,
        optional: va_list,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_call(operation_name: *const core::ffi::c_char, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_call_split(
        operation_name: *const core::ffi::c_char,
        optional: va_list,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_call_split_option_string(
        operation_name: *const core::ffi::c_char,
        option_string: *const core::ffi::c_char,
        optional: va_list,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_call_options(group: *mut GOptionGroup, operation: *mut VipsOperation);
}
unsafe extern "C" {
    pub fn vips_call_argv(
        operation: *mut VipsOperation,
        argc: core::ffi::c_int,
        argv: *mut *mut core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cache_drop_all();
}
unsafe extern "C" {
    pub fn vips_cache_operation_buildp(operation: *mut *mut VipsOperation) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cache_operation_build(operation: *mut VipsOperation) -> *mut VipsOperation;
}
unsafe extern "C" {
    pub fn vips_cache_print();
}
unsafe extern "C" {
    pub fn vips_cache_set_max(max: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_cache_set_max_mem(max_mem: usize);
}
unsafe extern "C" {
    pub fn vips_cache_get_max() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cache_get_size() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cache_get_max_mem() -> usize;
}
unsafe extern "C" {
    pub fn vips_cache_get_max_files() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cache_set_max_files(max_files: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_cache_set_dump(dump: gboolean);
}
unsafe extern "C" {
    pub fn vips_cache_set_trace(trace: gboolean);
}
unsafe extern "C" {
    pub fn vips_concurrency_set(concurrency: core::ffi::c_int);
}
unsafe extern "C" {
    pub fn vips_concurrency_get() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_operation_block_set(name: *const core::ffi::c_char, state: gboolean);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeign {
    pub parent_object: VipsOperation,
}
pub type VipsForeign = _VipsForeign;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignClass {
    pub parent_class: VipsOperationClass,
    pub priority: core::ffi::c_int,
    pub suffs: *mut *const core::ffi::c_char,
}
pub type VipsForeignClass = _VipsForeignClass;
unsafe extern "C" {
    pub fn vips_foreign_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_map(
        base: *const core::ffi::c_char,
        fn_: VipsSListMap2Fn,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
    ) -> *mut core::ffi::c_void;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignFlags {
    VIPS_FOREIGN_NONE = 0,
    VIPS_FOREIGN_PARTIAL = 1,
    VIPS_FOREIGN_BIGENDIAN = 2,
    VIPS_FOREIGN_SEQUENTIAL = 4,
    VIPS_FOREIGN_ALL = 7,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsFailOn {
    VIPS_FAIL_ON_NONE = 0,
    VIPS_FAIL_ON_TRUNCATED = 1,
    VIPS_FAIL_ON_ERROR = 2,
    VIPS_FAIL_ON_WARNING = 3,
    VIPS_FAIL_ON_LAST = 4,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignLoad {
    pub parent_object: VipsForeign,
    pub memory: gboolean,
    pub access: VipsAccess,
    pub flags: VipsForeignFlags,
    pub fail_on: VipsFailOn,
    pub fail: gboolean,
    pub sequential: gboolean,
    pub out: *mut VipsImage,
    pub real: *mut VipsImage,
    pub nocache: gboolean,
    pub disc: gboolean,
    pub error: gboolean,
    pub revalidate: gboolean,
}
pub type VipsForeignLoad = _VipsForeignLoad;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignLoadClass {
    pub parent_class: VipsForeignClass,
    pub is_a: ::core::option::Option<
        unsafe extern "C" fn(filename: *const core::ffi::c_char) -> gboolean,
    >,
    pub is_a_buffer: ::core::option::Option<
        unsafe extern "C" fn(data: *const core::ffi::c_void, size: usize) -> gboolean,
    >,
    pub is_a_source:
        ::core::option::Option<unsafe extern "C" fn(source: *mut VipsSource) -> gboolean>,
    pub get_flags_filename: ::core::option::Option<
        unsafe extern "C" fn(filename: *const core::ffi::c_char) -> VipsForeignFlags,
    >,
    pub get_flags: ::core::option::Option<
        unsafe extern "C" fn(load: *mut VipsForeignLoad) -> VipsForeignFlags,
    >,
    pub header: ::core::option::Option<
        unsafe extern "C" fn(load: *mut VipsForeignLoad) -> core::ffi::c_int,
    >,
    pub load: ::core::option::Option<
        unsafe extern "C" fn(load: *mut VipsForeignLoad) -> core::ffi::c_int,
    >,
}
pub type VipsForeignLoadClass = _VipsForeignLoadClass;
unsafe extern "C" {
    pub fn vips_foreign_load_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_find_load(filename: *const core::ffi::c_char) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_foreign_find_load_buffer(
        data: *const core::ffi::c_void,
        size: usize,
    ) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_foreign_find_load_source(source: *mut VipsSource) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_foreign_flags(
        loader: *const core::ffi::c_char,
        filename: *const core::ffi::c_char,
    ) -> VipsForeignFlags;
}
unsafe extern "C" {
    pub fn vips_foreign_is_a(
        loader: *const core::ffi::c_char,
        filename: *const core::ffi::c_char,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_foreign_is_a_buffer(
        loader: *const core::ffi::c_char,
        data: *const core::ffi::c_void,
        size: usize,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_foreign_is_a_source(
        loader: *const core::ffi::c_char,
        source: *mut VipsSource,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_foreign_load_invalidate(image: *mut VipsImage);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignSaveable {
    VIPS_FOREIGN_SAVEABLE_ANY = 0,
    VIPS_FOREIGN_SAVEABLE_MONO = 1,
    VIPS_FOREIGN_SAVEABLE_RGB = 2,
    VIPS_FOREIGN_SAVEABLE_CMYK = 4,
    VIPS_FOREIGN_SAVEABLE_ALPHA = 8,
    VIPS_FOREIGN_SAVEABLE_ALL = 15,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignCoding {
    VIPS_FOREIGN_CODING_NONE = 1,
    VIPS_FOREIGN_CODING_LABQ = 2,
    VIPS_FOREIGN_CODING_RAD = 4,
    VIPS_FOREIGN_CODING_ALL = 7,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignKeep {
    VIPS_FOREIGN_KEEP_NONE = 0,
    VIPS_FOREIGN_KEEP_EXIF = 1,
    VIPS_FOREIGN_KEEP_XMP = 2,
    VIPS_FOREIGN_KEEP_IPTC = 4,
    VIPS_FOREIGN_KEEP_ICC = 8,
    VIPS_FOREIGN_KEEP_OTHER = 16,
    VIPS_FOREIGN_KEEP_GAINMAP = 32,
    VIPS_FOREIGN_KEEP_ALL = 63,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignSave {
    pub parent_object: VipsForeign,
    pub strip: gboolean,
    pub keep: VipsForeignKeep,
    pub profile: *mut core::ffi::c_char,
    pub background: *mut VipsArrayDouble,
    pub page_height: core::ffi::c_int,
    pub in_: *mut VipsImage,
    pub ready: *mut VipsImage,
}
pub type VipsForeignSave = _VipsForeignSave;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignSaveClass {
    pub parent_class: VipsForeignClass,
    pub saveable: VipsForeignSaveable,
    pub format_table: *mut VipsBandFormat,
    pub coding: VipsForeignCoding,
}
pub type VipsForeignSaveClass = _VipsForeignSaveClass;
unsafe extern "C" {
    pub fn vips_foreign_save_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_find_save(filename: *const core::ffi::c_char) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_foreign_get_suffixes() -> *mut *mut gchar;
}
unsafe extern "C" {
    pub fn vips_foreign_find_save_buffer(
        suffix: *const core::ffi::c_char,
    ) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_foreign_find_save_target(
        suffix: *const core::ffi::c_char,
    ) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_vipsload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_vipsload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_vipssave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_vipssave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_openslideload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_openslideload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignSubsample {
    VIPS_FOREIGN_SUBSAMPLE_AUTO = 0,
    VIPS_FOREIGN_SUBSAMPLE_ON = 1,
    VIPS_FOREIGN_SUBSAMPLE_OFF = 2,
    VIPS_FOREIGN_SUBSAMPLE_LAST = 3,
}
unsafe extern "C" {
    pub fn vips_jpegload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jpegload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jpegload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jpegsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jpegsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jpegsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jpegsave_mime(in_: *mut VipsImage, ...) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignWebpPreset {
    VIPS_FOREIGN_WEBP_PRESET_DEFAULT = 0,
    VIPS_FOREIGN_WEBP_PRESET_PICTURE = 1,
    VIPS_FOREIGN_WEBP_PRESET_PHOTO = 2,
    VIPS_FOREIGN_WEBP_PRESET_DRAWING = 3,
    VIPS_FOREIGN_WEBP_PRESET_ICON = 4,
    VIPS_FOREIGN_WEBP_PRESET_TEXT = 5,
    VIPS_FOREIGN_WEBP_PRESET_LAST = 6,
}
unsafe extern "C" {
    pub fn vips_webpload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_webpload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_webpload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_webpsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_webpsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_webpsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_webpsave_mime(in_: *mut VipsImage, ...) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignTiffCompression {
    VIPS_FOREIGN_TIFF_COMPRESSION_NONE = 0,
    VIPS_FOREIGN_TIFF_COMPRESSION_JPEG = 1,
    VIPS_FOREIGN_TIFF_COMPRESSION_DEFLATE = 2,
    VIPS_FOREIGN_TIFF_COMPRESSION_PACKBITS = 3,
    VIPS_FOREIGN_TIFF_COMPRESSION_CCITTFAX4 = 4,
    VIPS_FOREIGN_TIFF_COMPRESSION_LZW = 5,
    VIPS_FOREIGN_TIFF_COMPRESSION_WEBP = 6,
    VIPS_FOREIGN_TIFF_COMPRESSION_ZSTD = 7,
    VIPS_FOREIGN_TIFF_COMPRESSION_JP2K = 8,
    VIPS_FOREIGN_TIFF_COMPRESSION_LAST = 9,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignTiffPredictor {
    VIPS_FOREIGN_TIFF_PREDICTOR_NONE = 1,
    VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL = 2,
    VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT = 3,
    VIPS_FOREIGN_TIFF_PREDICTOR_LAST = 4,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignTiffResunit {
    VIPS_FOREIGN_TIFF_RESUNIT_CM = 0,
    VIPS_FOREIGN_TIFF_RESUNIT_INCH = 1,
    VIPS_FOREIGN_TIFF_RESUNIT_LAST = 2,
}
unsafe extern "C" {
    pub fn vips_tiffload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tiffload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tiffload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tiffsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tiffsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tiffsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_openexrload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_fitsload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_fitsload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_fitssave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_analyzeload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rawload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        bands: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rawsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rawsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rawsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_csvload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_csvload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_csvsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_csvsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_matrixload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_matrixload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_matrixsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_matrixsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_matrixprint(in_: *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_magickload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_magickload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_magickload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_magicksave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_magicksave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignPngFilter {
    VIPS_FOREIGN_PNG_FILTER_NONE = 8,
    VIPS_FOREIGN_PNG_FILTER_SUB = 16,
    VIPS_FOREIGN_PNG_FILTER_UP = 32,
    VIPS_FOREIGN_PNG_FILTER_AVG = 64,
    VIPS_FOREIGN_PNG_FILTER_PAETH = 128,
    VIPS_FOREIGN_PNG_FILTER_ALL = 248,
}
unsafe extern "C" {
    pub fn vips_pngload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pngload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pngload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pngsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pngsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pngsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignPpmFormat {
    VIPS_FOREIGN_PPM_FORMAT_PBM = 0,
    VIPS_FOREIGN_PPM_FORMAT_PGM = 1,
    VIPS_FOREIGN_PPM_FORMAT_PPM = 2,
    VIPS_FOREIGN_PPM_FORMAT_PFM = 3,
    VIPS_FOREIGN_PPM_FORMAT_PNM = 4,
    VIPS_FOREIGN_PPM_FORMAT_LAST = 5,
}
unsafe extern "C" {
    pub fn vips_ppmload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_ppmload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_ppmload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_ppmsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_ppmsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_matload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_radload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_radload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_radload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_radsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_radsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_radsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignPdfPageBox {
    VIPS_FOREIGN_PDF_PAGE_BOX_MEDIA = 0,
    VIPS_FOREIGN_PDF_PAGE_BOX_CROP = 1,
    VIPS_FOREIGN_PDF_PAGE_BOX_TRIM = 2,
    VIPS_FOREIGN_PDF_PAGE_BOX_BLEED = 3,
    VIPS_FOREIGN_PDF_PAGE_BOX_ART = 4,
    VIPS_FOREIGN_PDF_PAGE_BOX_LAST = 5,
}
unsafe extern "C" {
    pub fn vips_pdfload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pdfload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pdfload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_svgload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_svgload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_svgload_string(
        str_: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_svgload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gifload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gifload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gifload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gifsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gifsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gifsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_dcrawload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_dcrawload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_dcrawload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_uhdrload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_uhdrload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_uhdrload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_uhdrsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_uhdrsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_uhdrsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_heifload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_heifload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_heifload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_heifsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_heifsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_heifsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_niftiload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_niftiload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_niftisave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jp2kload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jp2kload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jp2kload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jp2ksave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jp2ksave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jp2ksave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jxlload_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jxlload_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jxlload(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jxlsave(
        in_: *mut VipsImage,
        filename: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jxlsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_jxlsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignDzLayout {
    VIPS_FOREIGN_DZ_LAYOUT_DZ = 0,
    VIPS_FOREIGN_DZ_LAYOUT_ZOOMIFY = 1,
    VIPS_FOREIGN_DZ_LAYOUT_GOOGLE = 2,
    VIPS_FOREIGN_DZ_LAYOUT_IIIF = 3,
    VIPS_FOREIGN_DZ_LAYOUT_IIIF3 = 4,
    VIPS_FOREIGN_DZ_LAYOUT_LAST = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignDzDepth {
    VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL = 0,
    VIPS_FOREIGN_DZ_DEPTH_ONETILE = 1,
    VIPS_FOREIGN_DZ_DEPTH_ONE = 2,
    VIPS_FOREIGN_DZ_DEPTH_LAST = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignDzContainer {
    VIPS_FOREIGN_DZ_CONTAINER_FS = 0,
    VIPS_FOREIGN_DZ_CONTAINER_ZIP = 1,
    VIPS_FOREIGN_DZ_CONTAINER_SZI = 2,
    VIPS_FOREIGN_DZ_CONTAINER_LAST = 3,
}
unsafe extern "C" {
    pub fn vips_dzsave(
        in_: *mut VipsImage,
        name: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_dzsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut core::ffi::c_void,
        len: *mut usize,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_dzsave_target(
        in_: *mut VipsImage,
        target: *mut VipsTarget,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignHeifCompression {
    VIPS_FOREIGN_HEIF_COMPRESSION_HEVC = 1,
    VIPS_FOREIGN_HEIF_COMPRESSION_AVC = 2,
    VIPS_FOREIGN_HEIF_COMPRESSION_JPEG = 3,
    VIPS_FOREIGN_HEIF_COMPRESSION_AV1 = 4,
    VIPS_FOREIGN_HEIF_COMPRESSION_LAST = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignHeifEncoder {
    VIPS_FOREIGN_HEIF_ENCODER_AUTO = 0,
    VIPS_FOREIGN_HEIF_ENCODER_AOM = 1,
    VIPS_FOREIGN_HEIF_ENCODER_RAV1E = 2,
    VIPS_FOREIGN_HEIF_ENCODER_SVT = 3,
    VIPS_FOREIGN_HEIF_ENCODER_X265 = 4,
    VIPS_FOREIGN_HEIF_ENCODER_LAST = 5,
}
unsafe extern "C" {
    pub fn vips_foreign_jpeg_subsample_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_math_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_math2_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_round_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_relational_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_boolean_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_complex_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_complex2_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_complexget_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_precision_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_intent_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_pcs_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_extend_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_compass_direction_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_direction_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_align_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_angle_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_angle45_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_interesting_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_blend_mode_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_combine_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_text_wrap_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_sdf_shape_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_combine_mode_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_flags_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_fail_on_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_saveable_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_coding_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_keep_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_subsample_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_webp_preset_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_tiff_compression_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_tiff_predictor_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_tiff_resunit_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_png_filter_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_ppm_format_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_pdf_page_box_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_dz_layout_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_dz_depth_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_dz_container_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_heif_compression_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_foreign_heif_encoder_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_demand_style_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_image_type_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_interpretation_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_band_format_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_coding_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_access_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_morphology_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_argument_flags_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_operation_flags_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_region_shrink_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_kernel_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_size_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_token_get_type() -> GType;
}
unsafe extern "C" {
    pub fn vips_saveable_get_type() -> GType;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationMath {
    VIPS_OPERATION_MATH_SIN = 0,
    VIPS_OPERATION_MATH_COS = 1,
    VIPS_OPERATION_MATH_TAN = 2,
    VIPS_OPERATION_MATH_ASIN = 3,
    VIPS_OPERATION_MATH_ACOS = 4,
    VIPS_OPERATION_MATH_ATAN = 5,
    VIPS_OPERATION_MATH_LOG = 6,
    VIPS_OPERATION_MATH_LOG10 = 7,
    VIPS_OPERATION_MATH_EXP = 8,
    VIPS_OPERATION_MATH_EXP10 = 9,
    VIPS_OPERATION_MATH_SINH = 10,
    VIPS_OPERATION_MATH_COSH = 11,
    VIPS_OPERATION_MATH_TANH = 12,
    VIPS_OPERATION_MATH_ASINH = 13,
    VIPS_OPERATION_MATH_ACOSH = 14,
    VIPS_OPERATION_MATH_ATANH = 15,
    VIPS_OPERATION_MATH_LAST = 16,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationMath2 {
    VIPS_OPERATION_MATH2_POW = 0,
    VIPS_OPERATION_MATH2_WOP = 1,
    VIPS_OPERATION_MATH2_ATAN2 = 2,
    VIPS_OPERATION_MATH2_LAST = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationRound {
    VIPS_OPERATION_ROUND_RINT = 0,
    VIPS_OPERATION_ROUND_CEIL = 1,
    VIPS_OPERATION_ROUND_FLOOR = 2,
    VIPS_OPERATION_ROUND_LAST = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationRelational {
    VIPS_OPERATION_RELATIONAL_EQUAL = 0,
    VIPS_OPERATION_RELATIONAL_NOTEQ = 1,
    VIPS_OPERATION_RELATIONAL_LESS = 2,
    VIPS_OPERATION_RELATIONAL_LESSEQ = 3,
    VIPS_OPERATION_RELATIONAL_MORE = 4,
    VIPS_OPERATION_RELATIONAL_MOREEQ = 5,
    VIPS_OPERATION_RELATIONAL_LAST = 6,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationBoolean {
    VIPS_OPERATION_BOOLEAN_AND = 0,
    VIPS_OPERATION_BOOLEAN_OR = 1,
    VIPS_OPERATION_BOOLEAN_EOR = 2,
    VIPS_OPERATION_BOOLEAN_LSHIFT = 3,
    VIPS_OPERATION_BOOLEAN_RSHIFT = 4,
    VIPS_OPERATION_BOOLEAN_LAST = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationComplex {
    VIPS_OPERATION_COMPLEX_POLAR = 0,
    VIPS_OPERATION_COMPLEX_RECT = 1,
    VIPS_OPERATION_COMPLEX_CONJ = 2,
    VIPS_OPERATION_COMPLEX_LAST = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationComplex2 {
    VIPS_OPERATION_COMPLEX2_CROSS_PHASE = 0,
    VIPS_OPERATION_COMPLEX2_LAST = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationComplexget {
    VIPS_OPERATION_COMPLEXGET_REAL = 0,
    VIPS_OPERATION_COMPLEXGET_IMAG = 1,
    VIPS_OPERATION_COMPLEXGET_LAST = 2,
}
unsafe extern "C" {
    pub fn vips_add(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sum(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_subtract(
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_multiply(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_divide(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_linear(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        a: *const f64,
        b: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_linear1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        a: f64,
        b: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_remainder(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_remainder_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_remainder_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_invert(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_abs(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sign(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_clamp(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_maxpair(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_minpair(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_round(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        round: VipsOperationRound,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_floor(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_ceil(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rint(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_math(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        math: VipsOperationMath,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sin(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cos(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tan(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_asin(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_acos(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_atan(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_exp(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_exp10(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_log(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_log10(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sinh(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cosh(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tanh(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_asinh(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_acosh(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_atanh(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_complex(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        cmplx: VipsOperationComplex,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_polar(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rect(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_conj(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_complex2(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        cmplx: VipsOperationComplex2,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cross_phase(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_complexget(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        get: VipsOperationComplexget,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_real(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_imag(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_complexform(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_relational(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        relational: VipsOperationRelational,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_equal(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_notequal(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_less(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_lesseq(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_more(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_moreeq(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_relational_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        relational: VipsOperationRelational,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_equal_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_notequal_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_less_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_lesseq_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_more_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_moreeq_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_relational_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        relational: VipsOperationRelational,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_equal_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_notequal_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_less_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_lesseq_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_more_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_moreeq_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_boolean(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        boolean: VipsOperationBoolean,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_andimage(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_orimage(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_eorimage(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_lshift(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rshift(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_boolean_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        boolean: VipsOperationBoolean,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_andimage_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_orimage_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_eorimage_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_lshift_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rshift_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_boolean_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        boolean: VipsOperationBoolean,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_andimage_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_orimage_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_eorimage_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_lshift_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rshift_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_math2(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        math2: VipsOperationMath2,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pow(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_wop(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_atan2(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_math2_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        math2: VipsOperationMath2,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pow_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_wop_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_atan2_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *const f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_math2_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        math2: VipsOperationMath2,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pow_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_wop_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_atan2_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_avg(in_: *mut VipsImage, out: *mut f64, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_deviate(in_: *mut VipsImage, out: *mut f64, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_min(in_: *mut VipsImage, out: *mut f64, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_max(in_: *mut VipsImage, out: *mut f64, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_stats(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_measure(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        h: core::ffi::c_int,
        v: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_find_trim(
        in_: *mut VipsImage,
        left: *mut core::ffi::c_int,
        top: *mut core::ffi::c_int,
        width: *mut core::ffi::c_int,
        height: *mut core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_getpoint(
        in_: *mut VipsImage,
        vector: *mut *mut f64,
        n: *mut core::ffi::c_int,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_find(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_find_ndim(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_find_indexed(
        in_: *mut VipsImage,
        index: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hough_line(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hough_circle(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_project(
        in_: *mut VipsImage,
        columns: *mut *mut VipsImage,
        rows: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_profile(
        in_: *mut VipsImage,
        columns: *mut *mut VipsImage,
        rows: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsExtend {
    VIPS_EXTEND_BLACK = 0,
    VIPS_EXTEND_COPY = 1,
    VIPS_EXTEND_REPEAT = 2,
    VIPS_EXTEND_MIRROR = 3,
    VIPS_EXTEND_WHITE = 4,
    VIPS_EXTEND_BACKGROUND = 5,
    VIPS_EXTEND_LAST = 6,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsCompassDirection {
    VIPS_COMPASS_DIRECTION_CENTRE = 0,
    VIPS_COMPASS_DIRECTION_NORTH = 1,
    VIPS_COMPASS_DIRECTION_EAST = 2,
    VIPS_COMPASS_DIRECTION_SOUTH = 3,
    VIPS_COMPASS_DIRECTION_WEST = 4,
    VIPS_COMPASS_DIRECTION_NORTH_EAST = 5,
    VIPS_COMPASS_DIRECTION_SOUTH_EAST = 6,
    VIPS_COMPASS_DIRECTION_SOUTH_WEST = 7,
    VIPS_COMPASS_DIRECTION_NORTH_WEST = 8,
    VIPS_COMPASS_DIRECTION_LAST = 9,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsDirection {
    VIPS_DIRECTION_HORIZONTAL = 0,
    VIPS_DIRECTION_VERTICAL = 1,
    VIPS_DIRECTION_LAST = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsAlign {
    VIPS_ALIGN_LOW = 0,
    VIPS_ALIGN_CENTRE = 1,
    VIPS_ALIGN_HIGH = 2,
    VIPS_ALIGN_LAST = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsAngle {
    VIPS_ANGLE_D0 = 0,
    VIPS_ANGLE_D90 = 1,
    VIPS_ANGLE_D180 = 2,
    VIPS_ANGLE_D270 = 3,
    VIPS_ANGLE_LAST = 4,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsAngle45 {
    VIPS_ANGLE45_D0 = 0,
    VIPS_ANGLE45_D45 = 1,
    VIPS_ANGLE45_D90 = 2,
    VIPS_ANGLE45_D135 = 3,
    VIPS_ANGLE45_D180 = 4,
    VIPS_ANGLE45_D225 = 5,
    VIPS_ANGLE45_D270 = 6,
    VIPS_ANGLE45_D315 = 7,
    VIPS_ANGLE45_LAST = 8,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsInteresting {
    VIPS_INTERESTING_NONE = 0,
    VIPS_INTERESTING_CENTRE = 1,
    VIPS_INTERESTING_ENTROPY = 2,
    VIPS_INTERESTING_ATTENTION = 3,
    VIPS_INTERESTING_LOW = 4,
    VIPS_INTERESTING_HIGH = 5,
    VIPS_INTERESTING_ALL = 6,
    VIPS_INTERESTING_LAST = 7,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsBlendMode {
    VIPS_BLEND_MODE_CLEAR = 0,
    VIPS_BLEND_MODE_SOURCE = 1,
    VIPS_BLEND_MODE_OVER = 2,
    VIPS_BLEND_MODE_IN = 3,
    VIPS_BLEND_MODE_OUT = 4,
    VIPS_BLEND_MODE_ATOP = 5,
    VIPS_BLEND_MODE_DEST = 6,
    VIPS_BLEND_MODE_DEST_OVER = 7,
    VIPS_BLEND_MODE_DEST_IN = 8,
    VIPS_BLEND_MODE_DEST_OUT = 9,
    VIPS_BLEND_MODE_DEST_ATOP = 10,
    VIPS_BLEND_MODE_XOR = 11,
    VIPS_BLEND_MODE_ADD = 12,
    VIPS_BLEND_MODE_SATURATE = 13,
    VIPS_BLEND_MODE_MULTIPLY = 14,
    VIPS_BLEND_MODE_SCREEN = 15,
    VIPS_BLEND_MODE_OVERLAY = 16,
    VIPS_BLEND_MODE_DARKEN = 17,
    VIPS_BLEND_MODE_LIGHTEN = 18,
    VIPS_BLEND_MODE_COLOUR_DODGE = 19,
    VIPS_BLEND_MODE_COLOUR_BURN = 20,
    VIPS_BLEND_MODE_HARD_LIGHT = 21,
    VIPS_BLEND_MODE_SOFT_LIGHT = 22,
    VIPS_BLEND_MODE_DIFFERENCE = 23,
    VIPS_BLEND_MODE_EXCLUSION = 24,
    VIPS_BLEND_MODE_LAST = 25,
}
unsafe extern "C" {
    pub fn vips_copy(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tilecache(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_linecache(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sequential(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_copy_file(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_embed(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gravity(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsCompassDirection,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_flip(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_insert(
        main: *mut VipsImage,
        sub: *mut VipsImage,
        out: *mut *mut VipsImage,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_join(
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_arrayjoin(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_extract_area(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        left: core::ffi::c_int,
        top: core::ffi::c_int,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_crop(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        left: core::ffi::c_int,
        top: core::ffi::c_int,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_smartcrop(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_extract_band(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        band: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_replicate(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        across: core::ffi::c_int,
        down: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_grid(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        tile_height: core::ffi::c_int,
        across: core::ffi::c_int,
        down: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_transpose3d(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
    -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_wrap(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rot(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        angle: VipsAngle,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rot90(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rot180(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rot270(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rot45(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_autorot_remove_angle(image: *mut VipsImage);
}
unsafe extern "C" {
    pub fn vips_autorot(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_zoom(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        xfac: core::ffi::c_int,
        yfac: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_subsample(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        xfac: core::ffi::c_int,
        yfac: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        format: VipsBandFormat,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_uchar(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_char(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_ushort(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
    -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_short(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_uint(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_int(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_float(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_double(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
    -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_complex(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_cast_dpcomplex(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_scale(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_msb(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_byteswap(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandjoin(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandjoin2(
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandjoin_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandjoin_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandrank(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandfold(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandunfold(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandbool(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        boolean: VipsOperationBoolean,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandand(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandor(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandeor(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_bandmean(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_recomb(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        m: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_ifthenelse(
        cond: *mut VipsImage,
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_switch(
        tests: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_flatten(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_addalpha(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_premultiply(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
    -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_unpremultiply(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_composite(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: core::ffi::c_int,
        mode: *mut core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_composite2(
        base: *mut VipsImage,
        overlay: *mut VipsImage,
        out: *mut *mut VipsImage,
        mode: VipsBlendMode,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_falsecolour(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
    -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gamma(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsCombine {
    VIPS_COMBINE_MAX = 0,
    VIPS_COMBINE_SUM = 1,
    VIPS_COMBINE_MIN = 2,
    VIPS_COMBINE_LAST = 3,
}
unsafe extern "C" {
    pub fn vips_conv(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_convf(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_convi(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_conva(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_convsep(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_convasep(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_compass(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gaussblur(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        sigma: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sharpen(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_spcor(
        in_: *mut VipsImage,
        ref_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_fastcor(
        in_: *mut VipsImage,
        ref_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sobel(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_scharr(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_prewitt(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_canny(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsOperationMorphology {
    VIPS_OPERATION_MORPHOLOGY_ERODE = 0,
    VIPS_OPERATION_MORPHOLOGY_DILATE = 1,
    VIPS_OPERATION_MORPHOLOGY_LAST = 2,
}
unsafe extern "C" {
    pub fn vips_morph(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        morph: VipsOperationMorphology,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rank(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        index: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_median(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        size: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_countlines(
        in_: *mut VipsImage,
        nolines: *mut f64,
        direction: VipsDirection,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_labelregions(
        in_: *mut VipsImage,
        mask: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_fill_nearest(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_merge(
        ref_: *mut VipsImage,
        sec: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        dx: core::ffi::c_int,
        dy: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mosaic(
        ref_: *mut VipsImage,
        sec: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        xref: core::ffi::c_int,
        yref: core::ffi::c_int,
        xsec: core::ffi::c_int,
        ysec: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mosaic1(
        ref_: *mut VipsImage,
        sec: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        xr1: core::ffi::c_int,
        yr1: core::ffi::c_int,
        xs1: core::ffi::c_int,
        ys1: core::ffi::c_int,
        xr2: core::ffi::c_int,
        yr2: core::ffi::c_int,
        xs2: core::ffi::c_int,
        ys2: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_match(
        ref_: *mut VipsImage,
        sec: *mut VipsImage,
        out: *mut *mut VipsImage,
        xr1: core::ffi::c_int,
        yr1: core::ffi::c_int,
        xs1: core::ffi::c_int,
        ys1: core::ffi::c_int,
        xr2: core::ffi::c_int,
        yr2: core::ffi::c_int,
        xs2: core::ffi::c_int,
        ys2: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_globalbalance(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_remosaic(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        old_str: *const core::ffi::c_char,
        new_str: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_matrixinvert(m: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_matrixmultiply(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_maplut(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        lut: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_percent(
        in_: *mut VipsImage,
        percent: f64,
        threshold: *mut core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_stdif(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_cum(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_norm(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_equal(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_plot(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_match(
        in_: *mut VipsImage,
        ref_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_local(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_ismonotonic(in_: *mut VipsImage, out: *mut gboolean, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_hist_entropy(in_: *mut VipsImage, out: *mut f64, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_case(
        index: *mut VipsImage,
        cases: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_fwfft(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_invfft(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_freqmult(
        in_: *mut VipsImage,
        mask: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_spectrum(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_phasecor(
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsKernel {
    VIPS_KERNEL_NEAREST = 0,
    VIPS_KERNEL_LINEAR = 1,
    VIPS_KERNEL_CUBIC = 2,
    VIPS_KERNEL_MITCHELL = 3,
    VIPS_KERNEL_LANCZOS2 = 4,
    VIPS_KERNEL_LANCZOS3 = 5,
    VIPS_KERNEL_MKS2013 = 6,
    VIPS_KERNEL_MKS2021 = 7,
    VIPS_KERNEL_LAST = 8,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsSize {
    VIPS_SIZE_BOTH = 0,
    VIPS_SIZE_UP = 1,
    VIPS_SIZE_DOWN = 2,
    VIPS_SIZE_FORCE = 3,
    VIPS_SIZE_LAST = 4,
}
unsafe extern "C" {
    pub fn vips_shrink(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        hshrink: f64,
        vshrink: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_shrinkh(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        hshrink: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_shrinkv(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        vshrink: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_reduce(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        hshrink: f64,
        vshrink: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_reduceh(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        hshrink: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_reducev(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        vshrink: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_thumbnail(
        filename: *const core::ffi::c_char,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_thumbnail_buffer(
        buf: *mut core::ffi::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_thumbnail_image(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_thumbnail_source(
        source: *mut VipsSource,
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_similarity(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rotate(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        angle: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_affine(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        a: f64,
        b: f64,
        c: f64,
        d: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_resize(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        scale: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mapim(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        index: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_quadratic(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        coeff: *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsIntent {
    VIPS_INTENT_PERCEPTUAL = 0,
    VIPS_INTENT_RELATIVE = 1,
    VIPS_INTENT_SATURATION = 2,
    VIPS_INTENT_ABSOLUTE = 3,
    VIPS_INTENT_AUTO = 32,
    VIPS_INTENT_LAST = 33,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsPCS {
    VIPS_PCS_LAB = 0,
    VIPS_PCS_XYZ = 1,
    VIPS_PCS_LAST = 2,
}
unsafe extern "C" {
    pub fn vips_colourspace_issupported(image: *const VipsImage) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_colourspace(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        space: VipsInterpretation,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_LabQ2sRGB(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_rad2float(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_float2rad(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_LabS2LabQ(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_LabQ2LabS(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_LabQ2Lab(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_Lab2LabQ(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_LCh2Lab(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_Lab2LCh(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_Lab2XYZ(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_XYZ2Lab(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_XYZ2scRGB(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_scRGB2sRGB(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_scRGB2BW(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sRGB2scRGB(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_scRGB2XYZ(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_HSV2sRGB(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sRGB2HSV(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_LCh2CMC(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_CMC2LCh(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_XYZ2Yxy(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_Yxy2XYZ(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_LabS2Lab(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_Lab2LabS(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_CMYK2XYZ(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_XYZ2CMYK(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_Oklab2XYZ(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_XYZ2Oklab(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_Oklch2Oklab(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
    -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_Oklab2Oklch(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
    -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_uhdr2scRGB(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_profile_load(
        name: *const core::ffi::c_char,
        profile: *mut *mut VipsBlob,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_icc_present() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_icc_transform(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        output_profile: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_icc_import(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_icc_export(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_icc_ac2rc(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        profile_filename: *const core::ffi::c_char,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_icc_is_compatible_profile(
        image: *mut VipsImage,
        data: *const core::ffi::c_void,
        data_length: usize,
    ) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_dE76(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_dE00(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_dECMC(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_Lab2XYZ(L: f32, a: f32, b: f32, X: *mut f32, Y: *mut f32, Z: *mut f32);
}
unsafe extern "C" {
    pub fn vips_col_XYZ2Lab(X: f32, Y: f32, Z: f32, L: *mut f32, a: *mut f32, b: *mut f32);
}
unsafe extern "C" {
    pub fn vips_col_ab2h(a: f64, b: f64) -> f64;
}
unsafe extern "C" {
    pub fn vips_col_ab2Ch(a: f32, b: f32, C: *mut f32, h: *mut f32);
}
unsafe extern "C" {
    pub fn vips_col_Ch2ab(C: f32, h: f32, a: *mut f32, b: *mut f32);
}
unsafe extern "C" {
    pub fn vips_col_L2Lcmc(L: f32) -> f32;
}
unsafe extern "C" {
    pub fn vips_col_C2Ccmc(C: f32) -> f32;
}
unsafe extern "C" {
    pub fn vips_col_Ch2hcmc(C: f32, h: f32) -> f32;
}
unsafe extern "C" {
    pub fn vips_col_make_tables_CMC();
}
unsafe extern "C" {
    pub fn vips_col_Lcmc2L(Lcmc: f32) -> f32;
}
unsafe extern "C" {
    pub fn vips_col_Ccmc2C(Ccmc: f32) -> f32;
}
unsafe extern "C" {
    pub fn vips_col_Chcmc2h(C: f32, hcmc: f32) -> f32;
}
unsafe extern "C" {
    pub fn vips_col_sRGB2scRGB_8(
        r: core::ffi::c_int,
        g: core::ffi::c_int,
        b: core::ffi::c_int,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_sRGB2scRGB_16(
        r: core::ffi::c_int,
        g: core::ffi::c_int,
        b: core::ffi::c_int,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_sRGB2scRGB_8_noclip(
        r: core::ffi::c_int,
        g: core::ffi::c_int,
        b: core::ffi::c_int,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_sRGB2scRGB_16_noclip(
        r: core::ffi::c_int,
        g: core::ffi::c_int,
        b: core::ffi::c_int,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_scRGB2XYZ(
        R: f32,
        G: f32,
        B: f32,
        X: *mut f32,
        Y: *mut f32,
        Z: *mut f32,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_XYZ2scRGB(
        X: f32,
        Y: f32,
        Z: f32,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_scRGB2sRGB_8(
        R: f32,
        G: f32,
        B: f32,
        r: *mut core::ffi::c_int,
        g: *mut core::ffi::c_int,
        b: *mut core::ffi::c_int,
        og: *mut core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_scRGB2sRGB_16(
        R: f32,
        G: f32,
        B: f32,
        r: *mut core::ffi::c_int,
        g: *mut core::ffi::c_int,
        b: *mut core::ffi::c_int,
        og: *mut core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_scRGB2BW_16(
        R: f32,
        G: f32,
        B: f32,
        g: *mut core::ffi::c_int,
        og: *mut core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_col_scRGB2BW_8(
        R: f32,
        G: f32,
        B: f32,
        g: *mut core::ffi::c_int,
        og: *mut core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_pythagoras(L1: f32, a1: f32, b1: f32, L2: f32, a2: f32, b2: f32) -> f32;
}
unsafe extern "C" {
    pub fn vips_col_dE00(L1: f32, a1: f32, b1: f32, L2: f32, a2: f32, b2: f32) -> f32;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsCombineMode {
    VIPS_COMBINE_MODE_SET = 0,
    VIPS_COMBINE_MODE_ADD = 1,
    VIPS_COMBINE_MODE_LAST = 2,
}
unsafe extern "C" {
    pub fn vips_draw_rect(
        image: *mut VipsImage,
        ink: *mut f64,
        n: core::ffi::c_int,
        left: core::ffi::c_int,
        top: core::ffi::c_int,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_rect1(
        image: *mut VipsImage,
        ink: f64,
        left: core::ffi::c_int,
        top: core::ffi::c_int,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_point(
        image: *mut VipsImage,
        ink: *mut f64,
        n: core::ffi::c_int,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_point1(
        image: *mut VipsImage,
        ink: f64,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_image(
        image: *mut VipsImage,
        sub: *mut VipsImage,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_mask(
        image: *mut VipsImage,
        ink: *mut f64,
        n: core::ffi::c_int,
        mask: *mut VipsImage,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_mask1(
        image: *mut VipsImage,
        ink: f64,
        mask: *mut VipsImage,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_line(
        image: *mut VipsImage,
        ink: *mut f64,
        n: core::ffi::c_int,
        x1: core::ffi::c_int,
        y1: core::ffi::c_int,
        x2: core::ffi::c_int,
        y2: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_line1(
        image: *mut VipsImage,
        ink: f64,
        x1: core::ffi::c_int,
        y1: core::ffi::c_int,
        x2: core::ffi::c_int,
        y2: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_circle(
        image: *mut VipsImage,
        ink: *mut f64,
        n: core::ffi::c_int,
        cx: core::ffi::c_int,
        cy: core::ffi::c_int,
        radius: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_circle1(
        image: *mut VipsImage,
        ink: f64,
        cx: core::ffi::c_int,
        cy: core::ffi::c_int,
        radius: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_flood(
        image: *mut VipsImage,
        ink: *mut f64,
        n: core::ffi::c_int,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_flood1(
        image: *mut VipsImage,
        ink: f64,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_draw_smudge(
        image: *mut VipsImage,
        left: core::ffi::c_int,
        top: core::ffi::c_int,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsTextWrap {
    VIPS_TEXT_WRAP_WORD = 0,
    VIPS_TEXT_WRAP_CHAR = 1,
    VIPS_TEXT_WRAP_WORD_CHAR = 2,
    VIPS_TEXT_WRAP_NONE = 3,
    VIPS_TEXT_WRAP_LAST = 4,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsSdfShape {
    VIPS_SDF_SHAPE_CIRCLE = 0,
    VIPS_SDF_SHAPE_BOX = 1,
    VIPS_SDF_SHAPE_ROUNDED_BOX = 2,
    VIPS_SDF_SHAPE_LINE = 3,
    VIPS_SDF_SHAPE_LAST = 4,
}
unsafe extern "C" {
    pub fn vips_black(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_xyz(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_grey(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gaussmat(
        out: *mut *mut VipsImage,
        sigma: f64,
        min_ampl: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_logmat(
        out: *mut *mut VipsImage,
        sigma: f64,
        min_ampl: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_text(
        out: *mut *mut VipsImage,
        text: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_gaussnoise(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_eye(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sines(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_zone(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_sdf(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        shape: VipsSdfShape,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_identity(out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_buildlut(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_invertlut(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_tonelut(out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_ideal(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        frequency_cutoff: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_ideal_ring(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        frequency_cutoff: f64,
        ringwidth: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_ideal_band(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        frequency_cutoff_x: f64,
        frequency_cutoff_y: f64,
        radius: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_butterworth(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        order: f64,
        frequency_cutoff: f64,
        amplitude_cutoff: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_butterworth_ring(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        order: f64,
        frequency_cutoff: f64,
        amplitude_cutoff: f64,
        ringwidth: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_butterworth_band(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        order: f64,
        frequency_cutoff_x: f64,
        frequency_cutoff_y: f64,
        radius: f64,
        amplitude_cutoff: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_gaussian(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        frequency_cutoff: f64,
        amplitude_cutoff: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_gaussian_ring(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        frequency_cutoff: f64,
        amplitude_cutoff: f64,
        ringwidth: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_gaussian_band(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        frequency_cutoff_x: f64,
        frequency_cutoff_y: f64,
        radius: f64,
        amplitude_cutoff: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mask_fractal(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        fractal_dimension: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_fractsurf(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        fractal_dimension: f64,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_worley(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_perlin(
        out: *mut *mut VipsImage,
        width: core::ffi::c_int,
        height: core::ffi::c_int,
        ...
    ) -> core::ffi::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct im__INTMASK {
    pub xsize: core::ffi::c_int,
    pub ysize: core::ffi::c_int,
    pub scale: core::ffi::c_int,
    pub offset: core::ffi::c_int,
    pub coeff: *mut core::ffi::c_int,
    pub filename: *mut core::ffi::c_char,
}
pub type INTMASK = im__INTMASK;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct im__DOUBLEMASK {
    pub xsize: core::ffi::c_int,
    pub ysize: core::ffi::c_int,
    pub scale: f64,
    pub offset: f64,
    pub coeff: *mut f64,
    pub filename: *mut core::ffi::c_char,
}
pub type DOUBLEMASK = im__DOUBLEMASK;
unsafe extern "C" {
    pub fn vips_image_new_mode(
        filename: *const core::ffi::c_char,
        mode: *const core::ffi::c_char,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips_image_open_input(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_image_open_output(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mapfile(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_mapfilerw(image: *mut VipsImage) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_remapfilerw(image: *mut VipsImage) -> core::ffi::c_int;
}
pub type VipsPlotFn = ::core::option::Option<
    unsafe extern "C" fn(
        image: *mut VipsImage,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        a: *mut core::ffi::c_void,
        b: *mut core::ffi::c_void,
        c: *mut core::ffi::c_void,
    ) -> core::ffi::c_int,
>;
unsafe extern "C" {
    pub fn vips__deprecated_open_read(
        filename: *const core::ffi::c_char,
        sequential: gboolean,
    ) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips__deprecated_open_write(filename: *const core::ffi::c_char) -> *mut VipsImage;
}
unsafe extern "C" {
    pub fn vips__find_lroverlap(
        ref_in: *mut VipsImage,
        sec_in: *mut VipsImage,
        out: *mut VipsImage,
        bandno_in: core::ffi::c_int,
        xref: core::ffi::c_int,
        yref: core::ffi::c_int,
        xsec: core::ffi::c_int,
        ysec: core::ffi::c_int,
        halfcorrelation: core::ffi::c_int,
        halfarea: core::ffi::c_int,
        dx0: *mut core::ffi::c_int,
        dy0: *mut core::ffi::c_int,
        scale1: *mut f64,
        angle1: *mut f64,
        dx1: *mut f64,
        dy1: *mut f64,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__find_tboverlap(
        ref_in: *mut VipsImage,
        sec_in: *mut VipsImage,
        out: *mut VipsImage,
        bandno_in: core::ffi::c_int,
        xref: core::ffi::c_int,
        yref: core::ffi::c_int,
        xsec: core::ffi::c_int,
        ysec: core::ffi::c_int,
        halfcorrelation: core::ffi::c_int,
        halfarea: core::ffi::c_int,
        dx0: *mut core::ffi::c_int,
        dy0: *mut core::ffi::c_int,
        scale1: *mut f64,
        angle1: *mut f64,
        dx1: *mut f64,
        dy1: *mut f64,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_imask(
        domain: *const core::ffi::c_char,
        mask: *mut INTMASK,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_dmask(
        domain: *const core::ffi::c_char,
        mask: *mut DOUBLEMASK,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_check_dmask_1d(
        domain: *const core::ffi::c_char,
        mask: *mut DOUBLEMASK,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_get_option_group() -> *mut GOptionGroup;
}
unsafe extern "C" {
    pub fn vips_window_ref(
        im: *mut VipsImage,
        top: core::ffi::c_int,
        height: core::ffi::c_int,
    ) -> *mut VipsWindow;
}
unsafe extern "C" {
    pub fn vips_popenf(
        fmt: *const core::ffi::c_char,
        mode: *const core::ffi::c_char,
        ...
    ) -> *mut FILE;
}
unsafe extern "C" {
    pub fn vips__ink_to_vector(
        domain: *const core::ffi::c_char,
        im: *mut VipsImage,
        ink: *mut VipsPel,
        n: *mut core::ffi::c_int,
    ) -> *mut f64;
}
unsafe extern "C" {
    pub fn vips__init(argv0: *const core::ffi::c_char) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips__get_sizeof_vipsobject() -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VipsVector {
    pub name: *const core::ffi::c_char,
    pub unique_name: *mut core::ffi::c_char,
    pub n_temp: core::ffi::c_int,
    pub n_scanline: core::ffi::c_int,
    pub n_source: core::ffi::c_int,
    pub n_destination: core::ffi::c_int,
    pub n_constant: core::ffi::c_int,
    pub n_parameter: core::ffi::c_int,
    pub n_instruction: core::ffi::c_int,
    pub sl: [core::ffi::c_int; 10usize],
    pub line: [core::ffi::c_int; 10usize],
    pub s: [core::ffi::c_int; 10usize],
    pub d1: core::ffi::c_int,
    pub compiled: gboolean,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VipsExecutor {
    pub vector: *mut VipsVector,
}
unsafe extern "C" {
    pub fn vips_vector_init();
}
unsafe extern "C" {
    pub fn vips_vector_free(vector: *mut VipsVector);
}
unsafe extern "C" {
    pub fn vips_vector_new(
        name: *const core::ffi::c_char,
        dsize: core::ffi::c_int,
    ) -> *mut VipsVector;
}
unsafe extern "C" {
    pub fn vips_vector_constant(
        vector: *mut VipsVector,
        name: *mut core::ffi::c_char,
        value: core::ffi::c_int,
        size: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_vector_source_scanline(
        vector: *mut VipsVector,
        name: *mut core::ffi::c_char,
        line: core::ffi::c_int,
        size: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_vector_source_name(
        vector: *mut VipsVector,
        name: *const core::ffi::c_char,
        size: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_vector_temporary(
        vector: *mut VipsVector,
        name: *const core::ffi::c_char,
        size: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_vector_parameter(
        vector: *mut VipsVector,
        name: *const core::ffi::c_char,
        size: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_vector_destination(
        vector: *mut VipsVector,
        name: *const core::ffi::c_char,
        size: core::ffi::c_int,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_vector_asm2(
        vector: *mut VipsVector,
        op: *const core::ffi::c_char,
        a: *const core::ffi::c_char,
        b: *const core::ffi::c_char,
    );
}
unsafe extern "C" {
    pub fn vips_vector_asm3(
        vector: *mut VipsVector,
        op: *const core::ffi::c_char,
        a: *const core::ffi::c_char,
        b: *const core::ffi::c_char,
        c: *const core::ffi::c_char,
    );
}
unsafe extern "C" {
    pub fn vips_vector_full(vector: *mut VipsVector) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_vector_compile(vector: *mut VipsVector) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_vector_print(vector: *mut VipsVector);
}
unsafe extern "C" {
    pub fn vips_executor_set_program(
        executor: *mut VipsExecutor,
        vector: *mut VipsVector,
        n: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_executor_set_scanline(
        executor: *mut VipsExecutor,
        ir: *mut VipsRegion,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_executor_set_destination(
        executor: *mut VipsExecutor,
        value: *mut core::ffi::c_void,
    );
}
unsafe extern "C" {
    pub fn vips_executor_set_parameter(
        executor: *mut VipsExecutor,
        var: core::ffi::c_int,
        value: core::ffi::c_int,
    );
}
unsafe extern "C" {
    pub fn vips_executor_set_array(
        executor: *mut VipsExecutor,
        var: core::ffi::c_int,
        value: *mut core::ffi::c_void,
    );
}
unsafe extern "C" {
    pub fn vips_executor_run(executor: *mut VipsExecutor);
}
unsafe extern "C" {
    pub fn vips_vector_to_fixed_point(
        in_: *mut f64,
        out: *mut core::ffi::c_int,
        n: core::ffi::c_int,
        scale: core::ffi::c_int,
    );
}
pub type im_object = *mut core::ffi::c_void;
unsafe extern "C" {
    pub fn vips__input_interpolate_init(
        obj: *mut im_object,
        str_: *mut core::ffi::c_char,
    ) -> core::ffi::c_int;
}
impl VipsBBits {
    pub const IM_BBITS_FLOAT: VipsBBits = VipsBBits::IM_BBITS_INT;
}
impl VipsBBits {
    pub const IM_BBITS_DOUBLE: VipsBBits = VipsBBits::IM_BBITS_COMPLEX;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsBBits {
    IM_BBITS_BYTE = 8,
    IM_BBITS_SHORT = 16,
    IM_BBITS_INT = 32,
    IM_BBITS_COMPLEX = 64,
    IM_BBITS_DPCOMPLEX = 128,
}
unsafe extern "C" {
    pub fn vips_g_mutex_new() -> *mut GMutex;
}
unsafe extern "C" {
    pub fn vips_g_mutex_free(arg1: *mut GMutex);
}
unsafe extern "C" {
    pub fn vips_g_cond_new() -> *mut GCond;
}
unsafe extern "C" {
    pub fn vips_g_cond_free(arg1: *mut GCond);
}
unsafe extern "C" {
    pub fn vips_g_thread_join(thread: *mut GThread) -> *mut core::ffi::c_void;
}
unsafe extern "C" {
    pub fn vips_cache(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> core::ffi::c_int;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VipsForeignJpegSubsample {
    VIPS_FOREIGN_JPEG_SUBSAMPLE_AUTO = 0,
    VIPS_FOREIGN_JPEG_SUBSAMPLE_ON = 1,
    VIPS_FOREIGN_JPEG_SUBSAMPLE_OFF = 2,
    VIPS_FOREIGN_JPEG_SUBSAMPLE_LAST = 3,
}
unsafe extern "C" {
    pub fn vips_rawsave_fd(in_: *mut VipsImage, fd: core::ffi::c_int, ...) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_warn(domain: *const core::ffi::c_char, fmt: *const core::ffi::c_char, ...);
}
unsafe extern "C" {
    pub fn vips_vwarn(domain: *const core::ffi::c_char, fmt: *const core::ffi::c_char, ap: va_list);
}
unsafe extern "C" {
    pub fn vips_info_set(info: gboolean);
}
unsafe extern "C" {
    pub fn vips_info(domain: *const core::ffi::c_char, fmt: *const core::ffi::c_char, ...);
}
unsafe extern "C" {
    pub fn vips_vinfo(domain: *const core::ffi::c_char, fmt: *const core::ffi::c_char, ap: va_list);
}
unsafe extern "C" {
    pub fn vips_autorot_get_angle(image: *mut VipsImage) -> VipsAngle;
}
unsafe extern "C" {
    pub fn vips_thread_isworker() -> gboolean;
}
unsafe extern "C" {
    pub fn vips_free(buf: *mut core::ffi::c_void) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_target_finish(target: *mut VipsTarget);
}
unsafe extern "C" {
    pub fn vips_cache_operation_lookup(operation: *mut VipsOperation) -> *mut VipsOperation;
}
unsafe extern "C" {
    pub fn vips_cache_operation_add(operation: *mut VipsOperation);
}
unsafe extern "C" {
    pub fn vips_strncpy(
        dest: *mut core::ffi::c_char,
        src: *const core::ffi::c_char,
        n: core::ffi::c_int,
    ) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_strrstr(
        haystack: *const core::ffi::c_char,
        needle: *const core::ffi::c_char,
    ) -> *mut core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_ispostfix(a: *const core::ffi::c_char, b: *const core::ffi::c_char) -> gboolean;
}
unsafe extern "C" {
    pub fn vips_vsnprintf(
        str_: *mut core::ffi::c_char,
        size: usize,
        format: *const core::ffi::c_char,
        ap: va_list,
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_snprintf(
        str_: *mut core::ffi::c_char,
        size: usize,
        format: *const core::ffi::c_char,
        ...
    ) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_max_coord_get() -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_init(argv0: *const core::ffi::c_char) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_get_argv0() -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_get_prgname() -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_shutdown();
}
unsafe extern "C" {
    pub fn vips_thread_shutdown();
}
unsafe extern "C" {
    pub fn vips_add_option_entries(option_group: *mut GOptionGroup);
}
unsafe extern "C" {
    pub fn vips_leak_set(leak: gboolean);
}
unsafe extern "C" {
    pub fn vips_block_untrusted_set(state: gboolean);
}
unsafe extern "C" {
    pub fn vips_version_string() -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_version(flag: core::ffi::c_int) -> core::ffi::c_int;
}
unsafe extern "C" {
    pub fn vips_guess_prefix(
        argv0: *const core::ffi::c_char,
        env_name: *const core::ffi::c_char,
    ) -> *const core::ffi::c_char;
}
unsafe extern "C" {
    pub fn vips_guess_libdir(
        argv0: *const core::ffi::c_char,
        env_name: *const core::ffi::c_char,
    ) -> *const core::ffi::c_char;
}
pub type __builtin_va_list = *mut core::ffi::c_char;