#[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.6\0";
pub const VIPS_VERSION_STRING: &[u8; 7] = b"8.18.6\0";
pub const VIPS_MAJOR_VERSION: u32 = 8;
pub const VIPS_MINOR_VERSION: u32 = 18;
pub const VIPS_MICRO_VERSION: u32 = 6;
pub const VIPS_LIBRARY_CURRENT: u32 = 58;
pub const VIPS_LIBRARY_REVISION: u32 = 6;
pub const VIPS_LIBRARY_AGE: u32 = 18;
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 = core::ffi::c_long;
pub type gsize = core::ffi::c_ulong;
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,
}
#[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;