From dd4becddd7a077c205e8491e5a6c8dbedec87176 Mon Sep 17 00:00:00 2001 From: Nathan Fiedler Date: Tue, 20 Sep 2016 20:03:28 -0700 Subject: [PATCH] Hack to get build working on FreeBSD again Due to a bug in rust-bindgen, use the bindings as generated on the Mac for the same version of MagickWand as found on FreeBSD. That is, when build.rs is invoked on a FreeBSD system, it will use the Mac-generated bindings.rs rather than pulling down rust-bindgen and invoking it to generate the bindings on the fly. See issue #385 in the rust-bindgen project for details. cargo test passes --- bindings.rs | 8097 +++++++++++++++++++++++++++++++++++++++++++++++++++ build.rs | 194 +- 2 files changed, 8200 insertions(+), 91 deletions(-) create mode 100644 bindings.rs diff --git a/bindings.rs b/bindings.rs new file mode 100644 index 0000000..e8054a5 --- /dev/null +++ b/bindings.rs @@ -0,0 +1,8097 @@ +/* automatically generated by rust-bindgen */ + +#![allow(dead_code, + non_camel_case_types, + non_upper_case_globals, + non_snake_case)] +pub type __int8_t = ::libc::c_char; +pub type __uint8_t = ::libc::c_uchar; +pub type __int16_t = ::libc::c_short; +pub type __uint16_t = ::libc::c_ushort; +pub type __int32_t = ::libc::c_int; +pub type __uint32_t = ::libc::c_uint; +pub type __int64_t = ::libc::c_longlong; +pub type __uint64_t = ::libc::c_ulonglong; +pub type __darwin_intptr_t = ::libc::c_long; +pub type __darwin_natural_t = ::libc::c_uint; +pub type __darwin_ct_rune_t = ::libc::c_int; +#[repr(C)] +#[derive(Copy)] +pub struct __mbstate_t { + pub _bindgen_data_: [u64; 16usize], +} +impl __mbstate_t { + pub unsafe fn __mbstate8(&mut self) -> *mut [::libc::c_char; 128usize] { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } + pub unsafe fn _mbstateL(&mut self) -> *mut ::libc::c_longlong { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } +} +impl ::std::clone::Clone for __mbstate_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __mbstate_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type __darwin_mbstate_t = __mbstate_t; +pub type __darwin_ptrdiff_t = ::libc::c_long; +pub type __darwin_size_t = ::libc::c_ulong; +pub type __darwin_va_list = __builtin_va_list; +pub type __darwin_wchar_t = ::libc::c_int; +pub type __darwin_rune_t = __darwin_wchar_t; +pub type __darwin_wint_t = ::libc::c_int; +pub type __darwin_clock_t = ::libc::c_ulong; +pub type __darwin_socklen_t = __uint32_t; +pub type __darwin_ssize_t = ::libc::c_long; +pub type __darwin_time_t = ::libc::c_long; +pub type __darwin_blkcnt_t = __int64_t; +pub type __darwin_blksize_t = __int32_t; +pub type __darwin_dev_t = __int32_t; +pub type __darwin_fsblkcnt_t = ::libc::c_uint; +pub type __darwin_fsfilcnt_t = ::libc::c_uint; +pub type __darwin_gid_t = __uint32_t; +pub type __darwin_id_t = __uint32_t; +pub type __darwin_ino64_t = __uint64_t; +pub type __darwin_ino_t = __darwin_ino64_t; +pub type __darwin_mach_port_name_t = __darwin_natural_t; +pub type __darwin_mach_port_t = __darwin_mach_port_name_t; +pub type __darwin_mode_t = __uint16_t; +pub type __darwin_off_t = __int64_t; +pub type __darwin_pid_t = __int32_t; +pub type __darwin_sigset_t = __uint32_t; +pub type __darwin_suseconds_t = __int32_t; +pub type __darwin_uid_t = __uint32_t; +pub type __darwin_useconds_t = __uint32_t; +pub type __darwin_uuid_t = [::libc::c_uchar; 16usize]; +pub type __darwin_uuid_string_t = [::libc::c_char; 37usize]; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_pthread_handler_rec { + pub __routine: ::std::option::Option, + pub __arg: *mut ::libc::c_void, + pub __next: *mut __darwin_pthread_handler_rec, +} +impl ::std::default::Default for __darwin_pthread_handler_rec { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct _opaque_pthread_attr_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 56usize], +} +impl ::std::clone::Clone for _opaque_pthread_attr_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _opaque_pthread_attr_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct _opaque_pthread_cond_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 40usize], +} +impl ::std::clone::Clone for _opaque_pthread_cond_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _opaque_pthread_cond_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _opaque_pthread_condattr_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 8usize], +} +impl ::std::default::Default for _opaque_pthread_condattr_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct _opaque_pthread_mutex_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 56usize], +} +impl ::std::clone::Clone for _opaque_pthread_mutex_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _opaque_pthread_mutex_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _opaque_pthread_mutexattr_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 8usize], +} +impl ::std::default::Default for _opaque_pthread_mutexattr_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _opaque_pthread_once_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 8usize], +} +impl ::std::default::Default for _opaque_pthread_once_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct _opaque_pthread_rwlock_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 192usize], +} +impl ::std::clone::Clone for _opaque_pthread_rwlock_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _opaque_pthread_rwlock_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _opaque_pthread_rwlockattr_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 16usize], +} +impl ::std::default::Default for _opaque_pthread_rwlockattr_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct _opaque_pthread_t { + pub __sig: ::libc::c_long, + pub __cleanup_stack: *mut __darwin_pthread_handler_rec, + pub __opaque: [::libc::c_char; 8176usize], +} +impl ::std::clone::Clone for _opaque_pthread_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _opaque_pthread_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t; +pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t; +pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t; +pub type __darwin_pthread_key_t = ::libc::c_ulong; +pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t; +pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t; +pub type __darwin_pthread_once_t = _opaque_pthread_once_t; +pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t; +pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t; +pub type __darwin_pthread_t = *mut _opaque_pthread_t; +pub type __darwin_nl_item = ::libc::c_int; +pub type __darwin_wctrans_t = ::libc::c_int; +pub type __darwin_wctype_t = __uint32_t; +pub type va_list = __builtin_va_list; +pub type size_t = usize; +pub type fpos_t = __darwin_off_t; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __sbuf { + pub _base: *mut ::libc::c_uchar, + pub _size: ::libc::c_int, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::default::Default for __sbuf { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub enum __sFILEX { } +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __sFILE { + pub _p: *mut ::libc::c_uchar, + pub _r: ::libc::c_int, + pub _w: ::libc::c_int, + pub _flags: ::libc::c_short, + pub _file: ::libc::c_short, + pub _bf: __sbuf, + pub _lbfsize: ::libc::c_int, + pub _cookie: *mut ::libc::c_void, + pub _close: ::std::option::Option ::libc::c_int>, + pub _read: ::std::option::Option ::libc::c_int>, + pub _seek: ::std::option::Option fpos_t>, + pub _write: ::std::option::Option ::libc::c_int>, + pub _ub: __sbuf, + pub _extra: *mut __sFILEX, + pub _ur: ::libc::c_int, + pub _ubuf: [::libc::c_uchar; 3usize], + pub _nbuf: [::libc::c_uchar; 1usize], + pub _lb: __sbuf, + pub _blksize: ::libc::c_int, + pub _offset: fpos_t, +} +impl ::std::default::Default for __sFILE { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type FILE = __sFILE; +pub type off_t = __darwin_off_t; +pub type ssize_t = isize; +pub type __gnuc_va_list = __builtin_va_list; +pub type idtype_t = u32; +pub const P_ALL: idtype_t = 0; +pub const P_PID: idtype_t = 1; +pub const P_PGID: idtype_t = 2; +pub type pid_t = __darwin_pid_t; +pub type id_t = __darwin_id_t; +pub type sig_atomic_t = ::libc::c_int; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_i386_thread_state { + pub __eax: ::libc::c_uint, + pub __ebx: ::libc::c_uint, + pub __ecx: ::libc::c_uint, + pub __edx: ::libc::c_uint, + pub __edi: ::libc::c_uint, + pub __esi: ::libc::c_uint, + pub __ebp: ::libc::c_uint, + pub __esp: ::libc::c_uint, + pub __ss: ::libc::c_uint, + pub __eflags: ::libc::c_uint, + pub __eip: ::libc::c_uint, + pub __cs: ::libc::c_uint, + pub __ds: ::libc::c_uint, + pub __es: ::libc::c_uint, + pub __fs: ::libc::c_uint, + pub __gs: ::libc::c_uint, +} +impl ::std::default::Default for __darwin_i386_thread_state { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_fp_control { + pub _bindgen_bitfield_1_: ::libc::c_ushort, +} +impl ::std::default::Default for __darwin_fp_control { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type __darwin_fp_control_t = __darwin_fp_control; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_fp_status { + pub _bindgen_bitfield_1_: ::libc::c_ushort, +} +impl ::std::default::Default for __darwin_fp_status { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type __darwin_fp_status_t = __darwin_fp_status; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_mmst_reg { + pub __mmst_reg: [::libc::c_char; 10usize], + pub __mmst_rsrv: [::libc::c_char; 6usize], +} +impl ::std::default::Default for __darwin_mmst_reg { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_xmm_reg { + pub __xmm_reg: [::libc::c_char; 16usize], +} +impl ::std::default::Default for __darwin_xmm_reg { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct __darwin_i386_float_state { + pub __fpu_reserved: [::libc::c_int; 2usize], + pub __fpu_fcw: __darwin_fp_control, + pub __fpu_fsw: __darwin_fp_status, + pub __fpu_ftw: __uint8_t, + pub __fpu_rsrv1: __uint8_t, + pub __fpu_fop: __uint16_t, + pub __fpu_ip: __uint32_t, + pub __fpu_cs: __uint16_t, + pub __fpu_rsrv2: __uint16_t, + pub __fpu_dp: __uint32_t, + pub __fpu_ds: __uint16_t, + pub __fpu_rsrv3: __uint16_t, + pub __fpu_mxcsr: __uint32_t, + pub __fpu_mxcsrmask: __uint32_t, + pub __fpu_stmm0: __darwin_mmst_reg, + pub __fpu_stmm1: __darwin_mmst_reg, + pub __fpu_stmm2: __darwin_mmst_reg, + pub __fpu_stmm3: __darwin_mmst_reg, + pub __fpu_stmm4: __darwin_mmst_reg, + pub __fpu_stmm5: __darwin_mmst_reg, + pub __fpu_stmm6: __darwin_mmst_reg, + pub __fpu_stmm7: __darwin_mmst_reg, + pub __fpu_xmm0: __darwin_xmm_reg, + pub __fpu_xmm1: __darwin_xmm_reg, + pub __fpu_xmm2: __darwin_xmm_reg, + pub __fpu_xmm3: __darwin_xmm_reg, + pub __fpu_xmm4: __darwin_xmm_reg, + pub __fpu_xmm5: __darwin_xmm_reg, + pub __fpu_xmm6: __darwin_xmm_reg, + pub __fpu_xmm7: __darwin_xmm_reg, + pub __fpu_rsrv4: [::libc::c_char; 224usize], + pub __fpu_reserved1: ::libc::c_int, +} +impl ::std::clone::Clone for __darwin_i386_float_state { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __darwin_i386_float_state { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct __darwin_i386_avx_state { + pub __fpu_reserved: [::libc::c_int; 2usize], + pub __fpu_fcw: __darwin_fp_control, + pub __fpu_fsw: __darwin_fp_status, + pub __fpu_ftw: __uint8_t, + pub __fpu_rsrv1: __uint8_t, + pub __fpu_fop: __uint16_t, + pub __fpu_ip: __uint32_t, + pub __fpu_cs: __uint16_t, + pub __fpu_rsrv2: __uint16_t, + pub __fpu_dp: __uint32_t, + pub __fpu_ds: __uint16_t, + pub __fpu_rsrv3: __uint16_t, + pub __fpu_mxcsr: __uint32_t, + pub __fpu_mxcsrmask: __uint32_t, + pub __fpu_stmm0: __darwin_mmst_reg, + pub __fpu_stmm1: __darwin_mmst_reg, + pub __fpu_stmm2: __darwin_mmst_reg, + pub __fpu_stmm3: __darwin_mmst_reg, + pub __fpu_stmm4: __darwin_mmst_reg, + pub __fpu_stmm5: __darwin_mmst_reg, + pub __fpu_stmm6: __darwin_mmst_reg, + pub __fpu_stmm7: __darwin_mmst_reg, + pub __fpu_xmm0: __darwin_xmm_reg, + pub __fpu_xmm1: __darwin_xmm_reg, + pub __fpu_xmm2: __darwin_xmm_reg, + pub __fpu_xmm3: __darwin_xmm_reg, + pub __fpu_xmm4: __darwin_xmm_reg, + pub __fpu_xmm5: __darwin_xmm_reg, + pub __fpu_xmm6: __darwin_xmm_reg, + pub __fpu_xmm7: __darwin_xmm_reg, + pub __fpu_rsrv4: [::libc::c_char; 224usize], + pub __fpu_reserved1: ::libc::c_int, + pub __avx_reserved1: [::libc::c_char; 64usize], + pub __fpu_ymmh0: __darwin_xmm_reg, + pub __fpu_ymmh1: __darwin_xmm_reg, + pub __fpu_ymmh2: __darwin_xmm_reg, + pub __fpu_ymmh3: __darwin_xmm_reg, + pub __fpu_ymmh4: __darwin_xmm_reg, + pub __fpu_ymmh5: __darwin_xmm_reg, + pub __fpu_ymmh6: __darwin_xmm_reg, + pub __fpu_ymmh7: __darwin_xmm_reg, +} +impl ::std::clone::Clone for __darwin_i386_avx_state { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __darwin_i386_avx_state { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_i386_exception_state { + pub __trapno: __uint16_t, + pub __cpu: __uint16_t, + pub __err: __uint32_t, + pub __faultvaddr: __uint32_t, +} +impl ::std::default::Default for __darwin_i386_exception_state { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_x86_debug_state32 { + pub __dr0: ::libc::c_uint, + pub __dr1: ::libc::c_uint, + pub __dr2: ::libc::c_uint, + pub __dr3: ::libc::c_uint, + pub __dr4: ::libc::c_uint, + pub __dr5: ::libc::c_uint, + pub __dr6: ::libc::c_uint, + pub __dr7: ::libc::c_uint, +} +impl ::std::default::Default for __darwin_x86_debug_state32 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_x86_thread_state64 { + pub __rax: __uint64_t, + pub __rbx: __uint64_t, + pub __rcx: __uint64_t, + pub __rdx: __uint64_t, + pub __rdi: __uint64_t, + pub __rsi: __uint64_t, + pub __rbp: __uint64_t, + pub __rsp: __uint64_t, + pub __r8: __uint64_t, + pub __r9: __uint64_t, + pub __r10: __uint64_t, + pub __r11: __uint64_t, + pub __r12: __uint64_t, + pub __r13: __uint64_t, + pub __r14: __uint64_t, + pub __r15: __uint64_t, + pub __rip: __uint64_t, + pub __rflags: __uint64_t, + pub __cs: __uint64_t, + pub __fs: __uint64_t, + pub __gs: __uint64_t, +} +impl ::std::default::Default for __darwin_x86_thread_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct __darwin_x86_float_state64 { + pub __fpu_reserved: [::libc::c_int; 2usize], + pub __fpu_fcw: __darwin_fp_control, + pub __fpu_fsw: __darwin_fp_status, + pub __fpu_ftw: __uint8_t, + pub __fpu_rsrv1: __uint8_t, + pub __fpu_fop: __uint16_t, + pub __fpu_ip: __uint32_t, + pub __fpu_cs: __uint16_t, + pub __fpu_rsrv2: __uint16_t, + pub __fpu_dp: __uint32_t, + pub __fpu_ds: __uint16_t, + pub __fpu_rsrv3: __uint16_t, + pub __fpu_mxcsr: __uint32_t, + pub __fpu_mxcsrmask: __uint32_t, + pub __fpu_stmm0: __darwin_mmst_reg, + pub __fpu_stmm1: __darwin_mmst_reg, + pub __fpu_stmm2: __darwin_mmst_reg, + pub __fpu_stmm3: __darwin_mmst_reg, + pub __fpu_stmm4: __darwin_mmst_reg, + pub __fpu_stmm5: __darwin_mmst_reg, + pub __fpu_stmm6: __darwin_mmst_reg, + pub __fpu_stmm7: __darwin_mmst_reg, + pub __fpu_xmm0: __darwin_xmm_reg, + pub __fpu_xmm1: __darwin_xmm_reg, + pub __fpu_xmm2: __darwin_xmm_reg, + pub __fpu_xmm3: __darwin_xmm_reg, + pub __fpu_xmm4: __darwin_xmm_reg, + pub __fpu_xmm5: __darwin_xmm_reg, + pub __fpu_xmm6: __darwin_xmm_reg, + pub __fpu_xmm7: __darwin_xmm_reg, + pub __fpu_xmm8: __darwin_xmm_reg, + pub __fpu_xmm9: __darwin_xmm_reg, + pub __fpu_xmm10: __darwin_xmm_reg, + pub __fpu_xmm11: __darwin_xmm_reg, + pub __fpu_xmm12: __darwin_xmm_reg, + pub __fpu_xmm13: __darwin_xmm_reg, + pub __fpu_xmm14: __darwin_xmm_reg, + pub __fpu_xmm15: __darwin_xmm_reg, + pub __fpu_rsrv4: [::libc::c_char; 96usize], + pub __fpu_reserved1: ::libc::c_int, +} +impl ::std::clone::Clone for __darwin_x86_float_state64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __darwin_x86_float_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct __darwin_x86_avx_state64 { + pub __fpu_reserved: [::libc::c_int; 2usize], + pub __fpu_fcw: __darwin_fp_control, + pub __fpu_fsw: __darwin_fp_status, + pub __fpu_ftw: __uint8_t, + pub __fpu_rsrv1: __uint8_t, + pub __fpu_fop: __uint16_t, + pub __fpu_ip: __uint32_t, + pub __fpu_cs: __uint16_t, + pub __fpu_rsrv2: __uint16_t, + pub __fpu_dp: __uint32_t, + pub __fpu_ds: __uint16_t, + pub __fpu_rsrv3: __uint16_t, + pub __fpu_mxcsr: __uint32_t, + pub __fpu_mxcsrmask: __uint32_t, + pub __fpu_stmm0: __darwin_mmst_reg, + pub __fpu_stmm1: __darwin_mmst_reg, + pub __fpu_stmm2: __darwin_mmst_reg, + pub __fpu_stmm3: __darwin_mmst_reg, + pub __fpu_stmm4: __darwin_mmst_reg, + pub __fpu_stmm5: __darwin_mmst_reg, + pub __fpu_stmm6: __darwin_mmst_reg, + pub __fpu_stmm7: __darwin_mmst_reg, + pub __fpu_xmm0: __darwin_xmm_reg, + pub __fpu_xmm1: __darwin_xmm_reg, + pub __fpu_xmm2: __darwin_xmm_reg, + pub __fpu_xmm3: __darwin_xmm_reg, + pub __fpu_xmm4: __darwin_xmm_reg, + pub __fpu_xmm5: __darwin_xmm_reg, + pub __fpu_xmm6: __darwin_xmm_reg, + pub __fpu_xmm7: __darwin_xmm_reg, + pub __fpu_xmm8: __darwin_xmm_reg, + pub __fpu_xmm9: __darwin_xmm_reg, + pub __fpu_xmm10: __darwin_xmm_reg, + pub __fpu_xmm11: __darwin_xmm_reg, + pub __fpu_xmm12: __darwin_xmm_reg, + pub __fpu_xmm13: __darwin_xmm_reg, + pub __fpu_xmm14: __darwin_xmm_reg, + pub __fpu_xmm15: __darwin_xmm_reg, + pub __fpu_rsrv4: [::libc::c_char; 96usize], + pub __fpu_reserved1: ::libc::c_int, + pub __avx_reserved1: [::libc::c_char; 64usize], + pub __fpu_ymmh0: __darwin_xmm_reg, + pub __fpu_ymmh1: __darwin_xmm_reg, + pub __fpu_ymmh2: __darwin_xmm_reg, + pub __fpu_ymmh3: __darwin_xmm_reg, + pub __fpu_ymmh4: __darwin_xmm_reg, + pub __fpu_ymmh5: __darwin_xmm_reg, + pub __fpu_ymmh6: __darwin_xmm_reg, + pub __fpu_ymmh7: __darwin_xmm_reg, + pub __fpu_ymmh8: __darwin_xmm_reg, + pub __fpu_ymmh9: __darwin_xmm_reg, + pub __fpu_ymmh10: __darwin_xmm_reg, + pub __fpu_ymmh11: __darwin_xmm_reg, + pub __fpu_ymmh12: __darwin_xmm_reg, + pub __fpu_ymmh13: __darwin_xmm_reg, + pub __fpu_ymmh14: __darwin_xmm_reg, + pub __fpu_ymmh15: __darwin_xmm_reg, +} +impl ::std::clone::Clone for __darwin_x86_avx_state64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __darwin_x86_avx_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_x86_exception_state64 { + pub __trapno: __uint16_t, + pub __cpu: __uint16_t, + pub __err: __uint32_t, + pub __faultvaddr: __uint64_t, +} +impl ::std::default::Default for __darwin_x86_exception_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_x86_debug_state64 { + pub __dr0: __uint64_t, + pub __dr1: __uint64_t, + pub __dr2: __uint64_t, + pub __dr3: __uint64_t, + pub __dr4: __uint64_t, + pub __dr5: __uint64_t, + pub __dr6: __uint64_t, + pub __dr7: __uint64_t, +} +impl ::std::default::Default for __darwin_x86_debug_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct __darwin_mcontext32 { + pub __es: __darwin_i386_exception_state, + pub __ss: __darwin_i386_thread_state, + pub __fs: __darwin_i386_float_state, +} +impl ::std::clone::Clone for __darwin_mcontext32 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __darwin_mcontext32 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct __darwin_mcontext_avx32 { + pub __es: __darwin_i386_exception_state, + pub __ss: __darwin_i386_thread_state, + pub __fs: __darwin_i386_avx_state, +} +impl ::std::clone::Clone for __darwin_mcontext_avx32 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __darwin_mcontext_avx32 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct __darwin_mcontext64 { + pub __es: __darwin_x86_exception_state64, + pub __ss: __darwin_x86_thread_state64, + pub __fs: __darwin_x86_float_state64, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::clone::Clone for __darwin_mcontext64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __darwin_mcontext64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct __darwin_mcontext_avx64 { + pub __es: __darwin_x86_exception_state64, + pub __ss: __darwin_x86_thread_state64, + pub __fs: __darwin_x86_avx_state64, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::clone::Clone for __darwin_mcontext_avx64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for __darwin_mcontext_avx64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type mcontext_t = *mut __darwin_mcontext64; +pub type pthread_attr_t = __darwin_pthread_attr_t; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_sigaltstack { + pub ss_sp: *mut ::libc::c_void, + pub ss_size: __darwin_size_t, + pub ss_flags: ::libc::c_int, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::default::Default for __darwin_sigaltstack { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type stack_t = __darwin_sigaltstack; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __darwin_ucontext { + pub uc_onstack: ::libc::c_int, + pub uc_sigmask: __darwin_sigset_t, + pub uc_stack: __darwin_sigaltstack, + pub uc_link: *mut __darwin_ucontext, + pub uc_mcsize: __darwin_size_t, + pub uc_mcontext: *mut __darwin_mcontext64, +} +impl ::std::default::Default for __darwin_ucontext { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ucontext_t = __darwin_ucontext; +pub type sigset_t = __darwin_sigset_t; +pub type uid_t = __darwin_uid_t; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct sigval { + pub _bindgen_data_: [u64; 1usize], +} +impl sigval { + pub unsafe fn sival_int(&mut self) -> *mut ::libc::c_int { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } + pub unsafe fn sival_ptr(&mut self) -> *mut *mut ::libc::c_void { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } +} +impl ::std::default::Default for sigval { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct sigevent { + pub sigev_notify: ::libc::c_int, + pub sigev_signo: ::libc::c_int, + pub sigev_value: sigval, + pub sigev_notify_function: ::std::option::Option, + pub sigev_notify_attributes: *mut pthread_attr_t, +} +impl ::std::default::Default for sigevent { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __siginfo { + pub si_signo: ::libc::c_int, + pub si_errno: ::libc::c_int, + pub si_code: ::libc::c_int, + pub si_pid: pid_t, + pub si_uid: uid_t, + pub si_status: ::libc::c_int, + pub si_addr: *mut ::libc::c_void, + pub si_value: sigval, + pub si_band: ::libc::c_long, + pub __pad: [::libc::c_ulong; 7usize], +} +impl ::std::default::Default for __siginfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type siginfo_t = __siginfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __sigaction_u { + pub _bindgen_data_: [u64; 1usize], +} +impl __sigaction_u { + pub unsafe fn __sa_handler(&mut self) + -> *mut ::std::option::Option { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } + pub unsafe fn __sa_sigaction(&mut self) + -> + *mut ::std::option::Option { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } +} +impl ::std::default::Default for __sigaction_u { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __sigaction { + pub __sigaction_u: __sigaction_u, + pub sa_tramp: ::std::option::Option, + pub sa_mask: sigset_t, + pub sa_flags: ::libc::c_int, +} +impl ::std::default::Default for __sigaction { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct sigaction { + pub __sigaction_u: __sigaction_u, + pub sa_mask: sigset_t, + pub sa_flags: ::libc::c_int, +} +impl ::std::default::Default for sigaction { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type sig_t = ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct sigvec { + pub sv_handler: ::std::option::Option, + pub sv_mask: ::libc::c_int, + pub sv_flags: ::libc::c_int, +} +impl ::std::default::Default for sigvec { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct sigstack { + pub ss_sp: *mut ::libc::c_char, + pub ss_onstack: ::libc::c_int, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::default::Default for sigstack { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type int8_t = i8; +pub type int16_t = i16; +pub type int32_t = i32; +pub type int64_t = i64; +pub type uint8_t = u8; +pub type uint16_t = u16; +pub type uint32_t = u32; +pub type uint64_t = u64; +pub type int_least8_t = int8_t; +pub type int_least16_t = int16_t; +pub type int_least32_t = int32_t; +pub type int_least64_t = int64_t; +pub type uint_least8_t = uint8_t; +pub type uint_least16_t = uint16_t; +pub type uint_least32_t = uint32_t; +pub type uint_least64_t = uint64_t; +pub type int_fast8_t = int8_t; +pub type int_fast16_t = int16_t; +pub type int_fast32_t = int32_t; +pub type int_fast64_t = int64_t; +pub type uint_fast8_t = uint8_t; +pub type uint_fast16_t = uint16_t; +pub type uint_fast32_t = uint32_t; +pub type uint_fast64_t = uint64_t; +pub type intptr_t = isize; +pub type uintptr_t = usize; +pub type intmax_t = ::libc::c_long; +pub type uintmax_t = ::libc::c_ulong; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct timeval { + pub tv_sec: __darwin_time_t, + pub tv_usec: __darwin_suseconds_t, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::default::Default for timeval { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type rlim_t = __uint64_t; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct rusage { + pub ru_utime: timeval, + pub ru_stime: timeval, + pub ru_maxrss: ::libc::c_long, + pub ru_ixrss: ::libc::c_long, + pub ru_idrss: ::libc::c_long, + pub ru_isrss: ::libc::c_long, + pub ru_minflt: ::libc::c_long, + pub ru_majflt: ::libc::c_long, + pub ru_nswap: ::libc::c_long, + pub ru_inblock: ::libc::c_long, + pub ru_oublock: ::libc::c_long, + pub ru_msgsnd: ::libc::c_long, + pub ru_msgrcv: ::libc::c_long, + pub ru_nsignals: ::libc::c_long, + pub ru_nvcsw: ::libc::c_long, + pub ru_nivcsw: ::libc::c_long, +} +impl ::std::default::Default for rusage { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type rusage_info_t = *mut ::libc::c_void; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct rusage_info_v0 { + pub ri_uuid: [uint8_t; 16usize], + pub ri_user_time: uint64_t, + pub ri_system_time: uint64_t, + pub ri_pkg_idle_wkups: uint64_t, + pub ri_interrupt_wkups: uint64_t, + pub ri_pageins: uint64_t, + pub ri_wired_size: uint64_t, + pub ri_resident_size: uint64_t, + pub ri_phys_footprint: uint64_t, + pub ri_proc_start_abstime: uint64_t, + pub ri_proc_exit_abstime: uint64_t, +} +impl ::std::default::Default for rusage_info_v0 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct rusage_info_v1 { + pub ri_uuid: [uint8_t; 16usize], + pub ri_user_time: uint64_t, + pub ri_system_time: uint64_t, + pub ri_pkg_idle_wkups: uint64_t, + pub ri_interrupt_wkups: uint64_t, + pub ri_pageins: uint64_t, + pub ri_wired_size: uint64_t, + pub ri_resident_size: uint64_t, + pub ri_phys_footprint: uint64_t, + pub ri_proc_start_abstime: uint64_t, + pub ri_proc_exit_abstime: uint64_t, + pub ri_child_user_time: uint64_t, + pub ri_child_system_time: uint64_t, + pub ri_child_pkg_idle_wkups: uint64_t, + pub ri_child_interrupt_wkups: uint64_t, + pub ri_child_pageins: uint64_t, + pub ri_child_elapsed_abstime: uint64_t, +} +impl ::std::default::Default for rusage_info_v1 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct rusage_info_v2 { + pub ri_uuid: [uint8_t; 16usize], + pub ri_user_time: uint64_t, + pub ri_system_time: uint64_t, + pub ri_pkg_idle_wkups: uint64_t, + pub ri_interrupt_wkups: uint64_t, + pub ri_pageins: uint64_t, + pub ri_wired_size: uint64_t, + pub ri_resident_size: uint64_t, + pub ri_phys_footprint: uint64_t, + pub ri_proc_start_abstime: uint64_t, + pub ri_proc_exit_abstime: uint64_t, + pub ri_child_user_time: uint64_t, + pub ri_child_system_time: uint64_t, + pub ri_child_pkg_idle_wkups: uint64_t, + pub ri_child_interrupt_wkups: uint64_t, + pub ri_child_pageins: uint64_t, + pub ri_child_elapsed_abstime: uint64_t, + pub ri_diskio_bytesread: uint64_t, + pub ri_diskio_byteswritten: uint64_t, +} +impl ::std::default::Default for rusage_info_v2 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct rusage_info_v3 { + pub ri_uuid: [uint8_t; 16usize], + pub ri_user_time: uint64_t, + pub ri_system_time: uint64_t, + pub ri_pkg_idle_wkups: uint64_t, + pub ri_interrupt_wkups: uint64_t, + pub ri_pageins: uint64_t, + pub ri_wired_size: uint64_t, + pub ri_resident_size: uint64_t, + pub ri_phys_footprint: uint64_t, + pub ri_proc_start_abstime: uint64_t, + pub ri_proc_exit_abstime: uint64_t, + pub ri_child_user_time: uint64_t, + pub ri_child_system_time: uint64_t, + pub ri_child_pkg_idle_wkups: uint64_t, + pub ri_child_interrupt_wkups: uint64_t, + pub ri_child_pageins: uint64_t, + pub ri_child_elapsed_abstime: uint64_t, + pub ri_diskio_bytesread: uint64_t, + pub ri_diskio_byteswritten: uint64_t, + pub ri_cpu_time_qos_default: uint64_t, + pub ri_cpu_time_qos_maintenance: uint64_t, + pub ri_cpu_time_qos_background: uint64_t, + pub ri_cpu_time_qos_utility: uint64_t, + pub ri_cpu_time_qos_legacy: uint64_t, + pub ri_cpu_time_qos_user_initiated: uint64_t, + pub ri_cpu_time_qos_user_interactive: uint64_t, + pub ri_billed_system_time: uint64_t, + pub ri_serviced_system_time: uint64_t, +} +impl ::std::default::Default for rusage_info_v3 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type rusage_info_current = rusage_info_v3; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct rlimit { + pub rlim_cur: rlim_t, + pub rlim_max: rlim_t, +} +impl ::std::default::Default for rlimit { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct proc_rlimit_control_wakeupmon { + pub wm_flags: uint32_t, + pub wm_rate: int32_t, +} +impl ::std::default::Default for proc_rlimit_control_wakeupmon { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct wait { + pub _bindgen_data_: [u32; 1usize], +} +impl wait { + pub unsafe fn w_status(&mut self) -> *mut ::libc::c_int { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } + pub unsafe fn w_T(&mut self) -> *mut Struct_Unnamed1 { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } + pub unsafe fn w_S(&mut self) -> *mut Struct_Unnamed2 { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } +} +impl ::std::default::Default for wait { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct Struct_Unnamed1 { + pub _bindgen_bitfield_1_: ::libc::c_uint, +} +impl ::std::default::Default for Struct_Unnamed1 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct Struct_Unnamed2 { + pub _bindgen_bitfield_1_: ::libc::c_uint, +} +impl ::std::default::Default for Struct_Unnamed2 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ct_rune_t = __darwin_ct_rune_t; +pub type rune_t = __darwin_rune_t; +pub type wchar_t = __darwin_wchar_t; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct div_t { + pub quot: ::libc::c_int, + pub rem: ::libc::c_int, +} +impl ::std::default::Default for div_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct ldiv_t { + pub quot: ::libc::c_long, + pub rem: ::libc::c_long, +} +impl ::std::default::Default for ldiv_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct lldiv_t { + pub quot: ::libc::c_longlong, + pub rem: ::libc::c_longlong, +} +impl ::std::default::Default for lldiv_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type u_int8_t = ::libc::c_uchar; +pub type u_int16_t = ::libc::c_ushort; +pub type u_int32_t = ::libc::c_uint; +pub type u_int64_t = ::libc::c_ulonglong; +pub type register_t = int64_t; +pub type user_addr_t = u_int64_t; +pub type user_size_t = u_int64_t; +pub type user_ssize_t = int64_t; +pub type user_long_t = int64_t; +pub type user_ulong_t = u_int64_t; +pub type user_time_t = int64_t; +pub type user_off_t = int64_t; +pub type syscall_arg_t = u_int64_t; +pub type dev_t = __darwin_dev_t; +pub type mode_t = __darwin_mode_t; +pub type float_t = f32; +pub type double_t = f64; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __float2 { + pub __sinval: f32, + pub __cosval: f32, +} +impl ::std::default::Default for __float2 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __double2 { + pub __sinval: f64, + pub __cosval: f64, +} +impl ::std::default::Default for __double2 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct exception { + pub type_: ::libc::c_int, + pub name: *mut ::libc::c_char, + pub arg1: f64, + pub arg2: f64, + pub retval: f64, +} +impl ::std::default::Default for exception { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type u_char = ::libc::c_uchar; +pub type u_short = ::libc::c_ushort; +pub type u_int = ::libc::c_uint; +pub type u_long = ::libc::c_ulong; +pub type ushort = ::libc::c_ushort; +pub type uint_ = ::libc::c_uint; +pub type u_quad_t = u_int64_t; +pub type quad_t = int64_t; +pub type qaddr_t = *mut quad_t; +pub type caddr_t = *mut ::libc::c_char; +pub type daddr_t = int32_t; +pub type fixpt_t = u_int32_t; +pub type blkcnt_t = __darwin_blkcnt_t; +pub type blksize_t = __darwin_blksize_t; +pub type gid_t = __darwin_gid_t; +pub type in_addr_t = __uint32_t; +pub type in_port_t = __uint16_t; +pub type ino_t = __darwin_ino_t; +pub type ino64_t = __darwin_ino64_t; +pub type key_t = __int32_t; +pub type nlink_t = __uint16_t; +pub type segsz_t = int32_t; +pub type swblk_t = int32_t; +pub type clock_t = __darwin_clock_t; +pub type time_t = __darwin_time_t; +pub type useconds_t = __darwin_useconds_t; +pub type suseconds_t = __darwin_suseconds_t; +pub type rsize_t = __darwin_size_t; +pub type errno_t = ::libc::c_int; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct fd_set { + pub fds_bits: [__int32_t; 32usize], +} +impl ::std::default::Default for fd_set { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type fd_mask = __int32_t; +pub type pthread_cond_t = __darwin_pthread_cond_t; +pub type pthread_condattr_t = __darwin_pthread_condattr_t; +pub type pthread_mutex_t = __darwin_pthread_mutex_t; +pub type pthread_mutexattr_t = __darwin_pthread_mutexattr_t; +pub type pthread_once_t = __darwin_pthread_once_t; +pub type pthread_rwlock_t = __darwin_pthread_rwlock_t; +pub type pthread_rwlockattr_t = __darwin_pthread_rwlockattr_t; +pub type pthread_t = __darwin_pthread_t; +pub type pthread_key_t = __darwin_pthread_key_t; +pub type fsblkcnt_t = __darwin_fsblkcnt_t; +pub type fsfilcnt_t = __darwin_fsfilcnt_t; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct timespec { + pub tv_sec: __darwin_time_t, + pub tv_nsec: ::libc::c_long, +} +impl ::std::default::Default for timespec { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct tm { + pub tm_sec: ::libc::c_int, + pub tm_min: ::libc::c_int, + pub tm_hour: ::libc::c_int, + pub tm_mday: ::libc::c_int, + pub tm_mon: ::libc::c_int, + pub tm_year: ::libc::c_int, + pub tm_wday: ::libc::c_int, + pub tm_yday: ::libc::c_int, + pub tm_isdst: ::libc::c_int, + pub tm_gmtoff: ::libc::c_long, + pub tm_zone: *mut ::libc::c_char, +} +impl ::std::default::Default for tm { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub enum _MagickWand { } +pub type MagickWand = _MagickWand; +pub type MagickRealType = f32; +pub type SignedQuantum = ssize_t; +pub type Quantum = ::libc::c_ushort; +pub type MagickStatusType = ::libc::c_uint; +pub type MagickOffsetType = ::libc::c_longlong; +pub type MagickSizeType = ::libc::c_ulonglong; +pub type QuantumAny = MagickSizeType; +pub type ChannelType = u32; +pub const UndefinedChannel: ChannelType = 0; +pub const RedChannel: ChannelType = 1; +pub const GrayChannel: ChannelType = 1; +pub const CyanChannel: ChannelType = 1; +pub const GreenChannel: ChannelType = 2; +pub const MagentaChannel: ChannelType = 2; +pub const BlueChannel: ChannelType = 4; +pub const YellowChannel: ChannelType = 4; +pub const AlphaChannel: ChannelType = 8; +pub const OpacityChannel: ChannelType = 8; +pub const MatteChannel: ChannelType = 8; +pub const BlackChannel: ChannelType = 32; +pub const IndexChannel: ChannelType = 32; +pub const CompositeChannels: ChannelType = 47; +pub const AllChannels: ChannelType = 134217727; +pub const TrueAlphaChannel: ChannelType = 64; +pub const RGBChannels: ChannelType = 128; +pub const GrayChannels: ChannelType = 128; +pub const SyncChannels: ChannelType = 256; +pub const DefaultChannels: ChannelType = 134217719; +pub type ClassType = u32; +pub const UndefinedClass: ClassType = 0; +pub const DirectClass: ClassType = 1; +pub const PseudoClass: ClassType = 2; +pub type MagickBooleanType = u32; +pub const MagickFalse: MagickBooleanType = 0; +pub const MagickTrue: MagickBooleanType = 1; +pub enum _BlobInfo { } +pub type BlobInfo = _BlobInfo; +pub type ExceptionInfo = _ExceptionInfo; +pub type Image = _Image; +pub type ImageInfo = _ImageInfo; +pub type GeometryFlags = u32; +pub const NoValue: GeometryFlags = 0; +pub const XValue: GeometryFlags = 1; +pub const XiValue: GeometryFlags = 1; +pub const YValue: GeometryFlags = 2; +pub const PsiValue: GeometryFlags = 2; +pub const WidthValue: GeometryFlags = 4; +pub const RhoValue: GeometryFlags = 4; +pub const HeightValue: GeometryFlags = 8; +pub const SigmaValue: GeometryFlags = 8; +pub const ChiValue: GeometryFlags = 16; +pub const XiNegative: GeometryFlags = 32; +pub const XNegative: GeometryFlags = 32; +pub const PsiNegative: GeometryFlags = 64; +pub const YNegative: GeometryFlags = 64; +pub const ChiNegative: GeometryFlags = 128; +pub const PercentValue: GeometryFlags = 4096; +pub const AspectValue: GeometryFlags = 8192; +pub const NormalizeValue: GeometryFlags = 8192; +pub const LessValue: GeometryFlags = 16384; +pub const GreaterValue: GeometryFlags = 32768; +pub const MinimumValue: GeometryFlags = 65536; +pub const CorrelateNormalizeValue: GeometryFlags = 65536; +pub const AreaValue: GeometryFlags = 131072; +pub const DecimalValue: GeometryFlags = 262144; +pub const SeparatorValue: GeometryFlags = 524288; +pub const AllValues: GeometryFlags = 2147483647; +pub type GravityType = u32; +pub const UndefinedGravity: GravityType = 0; +pub const ForgetGravity: GravityType = 0; +pub const NorthWestGravity: GravityType = 1; +pub const NorthGravity: GravityType = 2; +pub const NorthEastGravity: GravityType = 3; +pub const WestGravity: GravityType = 4; +pub const CenterGravity: GravityType = 5; +pub const EastGravity: GravityType = 6; +pub const SouthWestGravity: GravityType = 7; +pub const SouthGravity: GravityType = 8; +pub const SouthEastGravity: GravityType = 9; +pub const StaticGravity: GravityType = 10; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _AffineMatrix { + pub sx: f64, + pub rx: f64, + pub ry: f64, + pub sy: f64, + pub tx: f64, + pub ty: f64, +} +impl ::std::default::Default for _AffineMatrix { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type AffineMatrix = _AffineMatrix; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _GeometryInfo { + pub rho: f64, + pub sigma: f64, + pub xi: f64, + pub psi: f64, + pub chi: f64, +} +impl ::std::default::Default for _GeometryInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type GeometryInfo = _GeometryInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _OffsetInfo { + pub x: ssize_t, + pub y: ssize_t, +} +impl ::std::default::Default for _OffsetInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type OffsetInfo = _OffsetInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _RectangleInfo { + pub width: size_t, + pub height: size_t, + pub x: ssize_t, + pub y: ssize_t, +} +impl ::std::default::Default for _RectangleInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type RectangleInfo = _RectangleInfo; +pub type ColorspaceType = u32; +pub const UndefinedColorspace: ColorspaceType = 0; +pub const RGBColorspace: ColorspaceType = 1; +pub const GRAYColorspace: ColorspaceType = 2; +pub const TransparentColorspace: ColorspaceType = 3; +pub const OHTAColorspace: ColorspaceType = 4; +pub const LabColorspace: ColorspaceType = 5; +pub const XYZColorspace: ColorspaceType = 6; +pub const YCbCrColorspace: ColorspaceType = 7; +pub const YCCColorspace: ColorspaceType = 8; +pub const YIQColorspace: ColorspaceType = 9; +pub const YPbPrColorspace: ColorspaceType = 10; +pub const YUVColorspace: ColorspaceType = 11; +pub const CMYKColorspace: ColorspaceType = 12; +pub const sRGBColorspace: ColorspaceType = 13; +pub const HSBColorspace: ColorspaceType = 14; +pub const HSLColorspace: ColorspaceType = 15; +pub const HWBColorspace: ColorspaceType = 16; +pub const Rec601LumaColorspace: ColorspaceType = 17; +pub const Rec601YCbCrColorspace: ColorspaceType = 18; +pub const Rec709LumaColorspace: ColorspaceType = 19; +pub const Rec709YCbCrColorspace: ColorspaceType = 20; +pub const LogColorspace: ColorspaceType = 21; +pub const CMYColorspace: ColorspaceType = 22; +pub const LuvColorspace: ColorspaceType = 23; +pub const HCLColorspace: ColorspaceType = 24; +pub const LCHColorspace: ColorspaceType = 25; +pub const LMSColorspace: ColorspaceType = 26; +pub const LCHabColorspace: ColorspaceType = 27; +pub const LCHuvColorspace: ColorspaceType = 28; +pub const scRGBColorspace: ColorspaceType = 29; +pub const HSIColorspace: ColorspaceType = 30; +pub const HSVColorspace: ColorspaceType = 31; +pub const HCLpColorspace: ColorspaceType = 32; +pub const YDbDrColorspace: ColorspaceType = 33; +pub const xyYColorspace: ColorspaceType = 34; +pub type StorageType = u32; +pub const UndefinedPixel: StorageType = 0; +pub const CharPixel: StorageType = 1; +pub const DoublePixel: StorageType = 2; +pub const FloatPixel: StorageType = 3; +pub const IntegerPixel: StorageType = 4; +pub const LongPixel: StorageType = 5; +pub const QuantumPixel: StorageType = 6; +pub const ShortPixel: StorageType = 7; +pub type InterpolatePixelMethod = u32; +pub const UndefinedInterpolatePixel: InterpolatePixelMethod = 0; +pub const AverageInterpolatePixel: InterpolatePixelMethod = 1; +pub const BicubicInterpolatePixel: InterpolatePixelMethod = 2; +pub const BilinearInterpolatePixel: InterpolatePixelMethod = 3; +pub const FilterInterpolatePixel: InterpolatePixelMethod = 4; +pub const IntegerInterpolatePixel: InterpolatePixelMethod = 5; +pub const MeshInterpolatePixel: InterpolatePixelMethod = 6; +pub const NearestNeighborInterpolatePixel: InterpolatePixelMethod = 7; +pub const SplineInterpolatePixel: InterpolatePixelMethod = 8; +pub const Average9InterpolatePixel: InterpolatePixelMethod = 9; +pub const Average16InterpolatePixel: InterpolatePixelMethod = 10; +pub const BlendInterpolatePixel: InterpolatePixelMethod = 11; +pub const BackgroundInterpolatePixel: InterpolatePixelMethod = 12; +pub const CatromInterpolatePixel: InterpolatePixelMethod = 13; +pub type PixelComponent = u32; +pub const PixelRed: PixelComponent = 0; +pub const PixelCyan: PixelComponent = 0; +pub const PixelGray: PixelComponent = 0; +pub const PixelY: PixelComponent = 0; +pub const PixelGreen: PixelComponent = 1; +pub const PixelMagenta: PixelComponent = 1; +pub const PixelCb: PixelComponent = 1; +pub const PixelBlue: PixelComponent = 2; +pub const PixelYellow: PixelComponent = 2; +pub const PixelCr: PixelComponent = 2; +pub const PixelAlpha: PixelComponent = 3; +pub const PixelBlack: PixelComponent = 4; +pub const PixelIndex: PixelComponent = 4; +pub const MaskPixelComponent: PixelComponent = 5; +pub type PixelIntensityMethod = u32; +pub const UndefinedPixelIntensityMethod: PixelIntensityMethod = 0; +pub const AveragePixelIntensityMethod: PixelIntensityMethod = 1; +pub const BrightnessPixelIntensityMethod: PixelIntensityMethod = 2; +pub const LightnessPixelIntensityMethod: PixelIntensityMethod = 3; +pub const Rec601LumaPixelIntensityMethod: PixelIntensityMethod = 4; +pub const Rec601LuminancePixelIntensityMethod: PixelIntensityMethod = 5; +pub const Rec709LumaPixelIntensityMethod: PixelIntensityMethod = 6; +pub const Rec709LuminancePixelIntensityMethod: PixelIntensityMethod = 7; +pub const RMSPixelIntensityMethod: PixelIntensityMethod = 8; +pub const MSPixelIntensityMethod: PixelIntensityMethod = 9; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _DoublePixelPacket { + pub red: f64, + pub green: f64, + pub blue: f64, + pub opacity: f64, + pub index: f64, +} +impl ::std::default::Default for _DoublePixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type DoublePixelPacket = _DoublePixelPacket; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _LongPixelPacket { + pub red: ::libc::c_uint, + pub green: ::libc::c_uint, + pub blue: ::libc::c_uint, + pub opacity: ::libc::c_uint, + pub index: ::libc::c_uint, +} +impl ::std::default::Default for _LongPixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type LongPixelPacket = _LongPixelPacket; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _MagickPixelPacket { + pub storage_class: ClassType, + pub colorspace: ColorspaceType, + pub matte: MagickBooleanType, + pub fuzz: f64, + pub depth: size_t, + pub red: MagickRealType, + pub green: MagickRealType, + pub blue: MagickRealType, + pub opacity: MagickRealType, + pub index: MagickRealType, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::default::Default for _MagickPixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type MagickPixelPacket = _MagickPixelPacket; +pub type IndexPacket = Quantum; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _PixelPacket { + pub blue: Quantum, + pub green: Quantum, + pub red: Quantum, + pub opacity: Quantum, +} +impl ::std::default::Default for _PixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PixelPacket = _PixelPacket; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _QuantumPixelPacket { + pub red: Quantum, + pub green: Quantum, + pub blue: Quantum, + pub opacity: Quantum, + pub index: Quantum, +} +impl ::std::default::Default for _QuantumPixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type QuantumPixelPacket = _QuantumPixelPacket; +pub enum _CacheView { } +pub type CacheView_ = _CacheView; +pub enum SemaphoreInfo { } +pub type ExceptionType = u32; +pub const UndefinedException: ExceptionType = 0; +pub const WarningException: ExceptionType = 300; +pub const ResourceLimitWarning: ExceptionType = 300; +pub const TypeWarning: ExceptionType = 305; +pub const OptionWarning: ExceptionType = 310; +pub const DelegateWarning: ExceptionType = 315; +pub const MissingDelegateWarning: ExceptionType = 320; +pub const CorruptImageWarning: ExceptionType = 325; +pub const FileOpenWarning: ExceptionType = 330; +pub const BlobWarning: ExceptionType = 335; +pub const StreamWarning: ExceptionType = 340; +pub const CacheWarning: ExceptionType = 345; +pub const CoderWarning: ExceptionType = 350; +pub const FilterWarning: ExceptionType = 352; +pub const ModuleWarning: ExceptionType = 355; +pub const DrawWarning: ExceptionType = 360; +pub const ImageWarning: ExceptionType = 365; +pub const WandWarning: ExceptionType = 370; +pub const RandomWarning: ExceptionType = 375; +pub const XServerWarning: ExceptionType = 380; +pub const MonitorWarning: ExceptionType = 385; +pub const RegistryWarning: ExceptionType = 390; +pub const ConfigureWarning: ExceptionType = 395; +pub const PolicyWarning: ExceptionType = 399; +pub const ErrorException: ExceptionType = 400; +pub const ResourceLimitError: ExceptionType = 400; +pub const TypeError: ExceptionType = 405; +pub const OptionError: ExceptionType = 410; +pub const DelegateError: ExceptionType = 415; +pub const MissingDelegateError: ExceptionType = 420; +pub const CorruptImageError: ExceptionType = 425; +pub const FileOpenError: ExceptionType = 430; +pub const BlobError: ExceptionType = 435; +pub const StreamError: ExceptionType = 440; +pub const CacheError: ExceptionType = 445; +pub const CoderError: ExceptionType = 450; +pub const FilterError: ExceptionType = 452; +pub const ModuleError: ExceptionType = 455; +pub const DrawError: ExceptionType = 460; +pub const ImageError: ExceptionType = 465; +pub const WandError: ExceptionType = 470; +pub const RandomError: ExceptionType = 475; +pub const XServerError: ExceptionType = 480; +pub const MonitorError: ExceptionType = 485; +pub const RegistryError: ExceptionType = 490; +pub const ConfigureError: ExceptionType = 495; +pub const PolicyError: ExceptionType = 499; +pub const FatalErrorException: ExceptionType = 700; +pub const ResourceLimitFatalError: ExceptionType = 700; +pub const TypeFatalError: ExceptionType = 705; +pub const OptionFatalError: ExceptionType = 710; +pub const DelegateFatalError: ExceptionType = 715; +pub const MissingDelegateFatalError: ExceptionType = 720; +pub const CorruptImageFatalError: ExceptionType = 725; +pub const FileOpenFatalError: ExceptionType = 730; +pub const BlobFatalError: ExceptionType = 735; +pub const StreamFatalError: ExceptionType = 740; +pub const CacheFatalError: ExceptionType = 745; +pub const CoderFatalError: ExceptionType = 750; +pub const FilterFatalError: ExceptionType = 752; +pub const ModuleFatalError: ExceptionType = 755; +pub const DrawFatalError: ExceptionType = 760; +pub const ImageFatalError: ExceptionType = 765; +pub const WandFatalError: ExceptionType = 770; +pub const RandomFatalError: ExceptionType = 775; +pub const XServerFatalError: ExceptionType = 780; +pub const MonitorFatalError: ExceptionType = 785; +pub const RegistryFatalError: ExceptionType = 790; +pub const ConfigureFatalError: ExceptionType = 795; +pub const PolicyFatalError: ExceptionType = 799; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ExceptionInfo { + pub severity: ExceptionType, + pub error_number: ::libc::c_int, + pub reason: *mut ::libc::c_char, + pub description: *mut ::libc::c_char, + pub exceptions: *mut ::libc::c_void, + pub relinquish: MagickBooleanType, + pub semaphore: *mut SemaphoreInfo, + pub signature: size_t, +} +impl ::std::default::Default for _ExceptionInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ErrorHandler = + ::std::option::Option; +pub type FatalErrorHandler = + ::std::option::Option; +pub type WarningHandler = + ::std::option::Option; +pub type ComplianceType = u32; +pub const UndefinedCompliance: ComplianceType = 0; +pub const NoCompliance: ComplianceType = 0; +pub const CSSCompliance: ComplianceType = 1; +pub const SVGCompliance: ComplianceType = 1; +pub const X11Compliance: ComplianceType = 2; +pub const XPMCompliance: ComplianceType = 4; +pub const AllCompliance: ComplianceType = 2147483647; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ColorInfo { + pub path: *mut ::libc::c_char, + pub name: *mut ::libc::c_char, + pub compliance: ComplianceType, + pub color: MagickPixelPacket, + pub exempt: MagickBooleanType, + pub stealth: MagickBooleanType, + pub previous: *mut _ColorInfo, + pub next: *mut _ColorInfo, + pub signature: size_t, +} +impl ::std::default::Default for _ColorInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ColorInfo = _ColorInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ErrorInfo { + pub mean_error_per_pixel: f64, + pub normalized_mean_error: f64, + pub normalized_maximum_error: f64, +} +impl ::std::default::Default for _ErrorInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ErrorInfo = _ErrorInfo; +pub type AlphaChannelType = u32; +pub const UndefinedAlphaChannel: AlphaChannelType = 0; +pub const ActivateAlphaChannel: AlphaChannelType = 1; +pub const BackgroundAlphaChannel: AlphaChannelType = 2; +pub const CopyAlphaChannel: AlphaChannelType = 3; +pub const DeactivateAlphaChannel: AlphaChannelType = 4; +pub const ExtractAlphaChannel: AlphaChannelType = 5; +pub const OpaqueAlphaChannel: AlphaChannelType = 6; +pub const ResetAlphaChannel: AlphaChannelType = 7; +pub const SetAlphaChannel: AlphaChannelType = 8; +pub const ShapeAlphaChannel: AlphaChannelType = 9; +pub const TransparentAlphaChannel: AlphaChannelType = 10; +pub const FlattenAlphaChannel: AlphaChannelType = 11; +pub const RemoveAlphaChannel: AlphaChannelType = 12; +pub const AssociateAlphaChannel: AlphaChannelType = 13; +pub const DisassociateAlphaChannel: AlphaChannelType = 14; +pub type ImageType = u32; +pub const UndefinedType: ImageType = 0; +pub const BilevelType: ImageType = 1; +pub const GrayscaleType: ImageType = 2; +pub const GrayscaleMatteType: ImageType = 3; +pub const PaletteType: ImageType = 4; +pub const PaletteMatteType: ImageType = 5; +pub const TrueColorType: ImageType = 6; +pub const TrueColorMatteType: ImageType = 7; +pub const ColorSeparationType: ImageType = 8; +pub const ColorSeparationMatteType: ImageType = 9; +pub const OptimizeType: ImageType = 10; +pub const PaletteBilevelMatteType: ImageType = 11; +pub type InterlaceType = u32; +pub const UndefinedInterlace: InterlaceType = 0; +pub const NoInterlace: InterlaceType = 1; +pub const LineInterlace: InterlaceType = 2; +pub const PlaneInterlace: InterlaceType = 3; +pub const PartitionInterlace: InterlaceType = 4; +pub const GIFInterlace: InterlaceType = 5; +pub const JPEGInterlace: InterlaceType = 6; +pub const PNGInterlace: InterlaceType = 7; +pub type OrientationType = u32; +pub const UndefinedOrientation: OrientationType = 0; +pub const TopLeftOrientation: OrientationType = 1; +pub const TopRightOrientation: OrientationType = 2; +pub const BottomRightOrientation: OrientationType = 3; +pub const BottomLeftOrientation: OrientationType = 4; +pub const LeftTopOrientation: OrientationType = 5; +pub const RightTopOrientation: OrientationType = 6; +pub const RightBottomOrientation: OrientationType = 7; +pub const LeftBottomOrientation: OrientationType = 8; +pub type ResolutionType = u32; +pub const UndefinedResolution: ResolutionType = 0; +pub const PixelsPerInchResolution: ResolutionType = 1; +pub const PixelsPerCentimeterResolution: ResolutionType = 2; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _PrimaryInfo { + pub x: f64, + pub y: f64, + pub z: f64, +} +impl ::std::default::Default for _PrimaryInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PrimaryInfo = _PrimaryInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _SegmentInfo { + pub x1: f64, + pub y1: f64, + pub x2: f64, + pub y2: f64, +} +impl ::std::default::Default for _SegmentInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type SegmentInfo = _SegmentInfo; +pub type TransmitType = u32; +pub const UndefinedTransmitType: TransmitType = 0; +pub const FileTransmitType: TransmitType = 1; +pub const BlobTransmitType: TransmitType = 2; +pub const StreamTransmitType: TransmitType = 3; +pub const ImageTransmitType: TransmitType = 4; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ChromaticityInfo { + pub red_primary: PrimaryInfo, + pub green_primary: PrimaryInfo, + pub blue_primary: PrimaryInfo, + pub white_point: PrimaryInfo, +} +impl ::std::default::Default for _ChromaticityInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChromaticityInfo = _ChromaticityInfo; +pub type StreamHandler = + ::std::option::Option size_t>; +pub type MapMode = u32; +pub const ReadMode: MapMode = 0; +pub const WriteMode: MapMode = 1; +pub const IOMode: MapMode = 2; +pub type VirtualPixelMethod = u32; +pub const UndefinedVirtualPixelMethod: VirtualPixelMethod = 0; +pub const BackgroundVirtualPixelMethod: VirtualPixelMethod = 1; +pub const ConstantVirtualPixelMethod: VirtualPixelMethod = 2; +pub const DitherVirtualPixelMethod: VirtualPixelMethod = 3; +pub const EdgeVirtualPixelMethod: VirtualPixelMethod = 4; +pub const MirrorVirtualPixelMethod: VirtualPixelMethod = 5; +pub const RandomVirtualPixelMethod: VirtualPixelMethod = 6; +pub const TileVirtualPixelMethod: VirtualPixelMethod = 7; +pub const TransparentVirtualPixelMethod: VirtualPixelMethod = 8; +pub const MaskVirtualPixelMethod: VirtualPixelMethod = 9; +pub const BlackVirtualPixelMethod: VirtualPixelMethod = 10; +pub const GrayVirtualPixelMethod: VirtualPixelMethod = 11; +pub const WhiteVirtualPixelMethod: VirtualPixelMethod = 12; +pub const HorizontalTileVirtualPixelMethod: VirtualPixelMethod = 13; +pub const VerticalTileVirtualPixelMethod: VirtualPixelMethod = 14; +pub const HorizontalTileEdgeVirtualPixelMethod: VirtualPixelMethod = 15; +pub const VerticalTileEdgeVirtualPixelMethod: VirtualPixelMethod = 16; +pub const CheckerTileVirtualPixelMethod: VirtualPixelMethod = 17; +pub type CacheView = _CacheView; +pub type CompositeOperator = u32; +pub const UndefinedCompositeOp: CompositeOperator = 0; +pub const NoCompositeOp: CompositeOperator = 1; +pub const ModulusAddCompositeOp: CompositeOperator = 2; +pub const AtopCompositeOp: CompositeOperator = 3; +pub const BlendCompositeOp: CompositeOperator = 4; +pub const BumpmapCompositeOp: CompositeOperator = 5; +pub const ChangeMaskCompositeOp: CompositeOperator = 6; +pub const ClearCompositeOp: CompositeOperator = 7; +pub const ColorBurnCompositeOp: CompositeOperator = 8; +pub const ColorDodgeCompositeOp: CompositeOperator = 9; +pub const ColorizeCompositeOp: CompositeOperator = 10; +pub const CopyBlackCompositeOp: CompositeOperator = 11; +pub const CopyBlueCompositeOp: CompositeOperator = 12; +pub const CopyCompositeOp: CompositeOperator = 13; +pub const CopyCyanCompositeOp: CompositeOperator = 14; +pub const CopyGreenCompositeOp: CompositeOperator = 15; +pub const CopyMagentaCompositeOp: CompositeOperator = 16; +pub const CopyOpacityCompositeOp: CompositeOperator = 17; +pub const CopyRedCompositeOp: CompositeOperator = 18; +pub const CopyYellowCompositeOp: CompositeOperator = 19; +pub const DarkenCompositeOp: CompositeOperator = 20; +pub const DstAtopCompositeOp: CompositeOperator = 21; +pub const DstCompositeOp: CompositeOperator = 22; +pub const DstInCompositeOp: CompositeOperator = 23; +pub const DstOutCompositeOp: CompositeOperator = 24; +pub const DstOverCompositeOp: CompositeOperator = 25; +pub const DifferenceCompositeOp: CompositeOperator = 26; +pub const DisplaceCompositeOp: CompositeOperator = 27; +pub const DissolveCompositeOp: CompositeOperator = 28; +pub const ExclusionCompositeOp: CompositeOperator = 29; +pub const HardLightCompositeOp: CompositeOperator = 30; +pub const HueCompositeOp: CompositeOperator = 31; +pub const InCompositeOp: CompositeOperator = 32; +pub const LightenCompositeOp: CompositeOperator = 33; +pub const LinearLightCompositeOp: CompositeOperator = 34; +pub const LuminizeCompositeOp: CompositeOperator = 35; +pub const MinusDstCompositeOp: CompositeOperator = 36; +pub const ModulateCompositeOp: CompositeOperator = 37; +pub const MultiplyCompositeOp: CompositeOperator = 38; +pub const OutCompositeOp: CompositeOperator = 39; +pub const OverCompositeOp: CompositeOperator = 40; +pub const OverlayCompositeOp: CompositeOperator = 41; +pub const PlusCompositeOp: CompositeOperator = 42; +pub const ReplaceCompositeOp: CompositeOperator = 43; +pub const SaturateCompositeOp: CompositeOperator = 44; +pub const ScreenCompositeOp: CompositeOperator = 45; +pub const SoftLightCompositeOp: CompositeOperator = 46; +pub const SrcAtopCompositeOp: CompositeOperator = 47; +pub const SrcCompositeOp: CompositeOperator = 48; +pub const SrcInCompositeOp: CompositeOperator = 49; +pub const SrcOutCompositeOp: CompositeOperator = 50; +pub const SrcOverCompositeOp: CompositeOperator = 51; +pub const ModulusSubtractCompositeOp: CompositeOperator = 52; +pub const ThresholdCompositeOp: CompositeOperator = 53; +pub const XorCompositeOp: CompositeOperator = 54; +pub const DivideDstCompositeOp: CompositeOperator = 55; +pub const DistortCompositeOp: CompositeOperator = 56; +pub const BlurCompositeOp: CompositeOperator = 57; +pub const PegtopLightCompositeOp: CompositeOperator = 58; +pub const VividLightCompositeOp: CompositeOperator = 59; +pub const PinLightCompositeOp: CompositeOperator = 60; +pub const LinearDodgeCompositeOp: CompositeOperator = 61; +pub const LinearBurnCompositeOp: CompositeOperator = 62; +pub const MathematicsCompositeOp: CompositeOperator = 63; +pub const DivideSrcCompositeOp: CompositeOperator = 64; +pub const MinusSrcCompositeOp: CompositeOperator = 65; +pub const DarkenIntensityCompositeOp: CompositeOperator = 66; +pub const LightenIntensityCompositeOp: CompositeOperator = 67; +pub const HardMixCompositeOp: CompositeOperator = 68; +pub type CompressionType = u32; +pub const UndefinedCompression: CompressionType = 0; +pub const NoCompression: CompressionType = 1; +pub const BZipCompression: CompressionType = 2; +pub const DXT1Compression: CompressionType = 3; +pub const DXT3Compression: CompressionType = 4; +pub const DXT5Compression: CompressionType = 5; +pub const FaxCompression: CompressionType = 6; +pub const Group4Compression: CompressionType = 7; +pub const JPEGCompression: CompressionType = 8; +pub const JPEG2000Compression: CompressionType = 9; +pub const LosslessJPEGCompression: CompressionType = 10; +pub const LZWCompression: CompressionType = 11; +pub const RLECompression: CompressionType = 12; +pub const ZipCompression: CompressionType = 13; +pub const ZipSCompression: CompressionType = 14; +pub const PizCompression: CompressionType = 15; +pub const Pxr24Compression: CompressionType = 16; +pub const B44Compression: CompressionType = 17; +pub const B44ACompression: CompressionType = 18; +pub const LZMACompression: CompressionType = 19; +pub const JBIG1Compression: CompressionType = 20; +pub const JBIG2Compression: CompressionType = 21; +pub enum _Ascii85Info { } +pub type Ascii85Info = _Ascii85Info; +pub type KernelInfoType = u32; +pub const UndefinedKernel: KernelInfoType = 0; +pub const UnityKernel: KernelInfoType = 1; +pub const GaussianKernel: KernelInfoType = 2; +pub const DoGKernel: KernelInfoType = 3; +pub const LoGKernel: KernelInfoType = 4; +pub const BlurKernel: KernelInfoType = 5; +pub const CometKernel: KernelInfoType = 6; +pub const LaplacianKernel: KernelInfoType = 7; +pub const SobelKernel: KernelInfoType = 8; +pub const FreiChenKernel: KernelInfoType = 9; +pub const RobertsKernel: KernelInfoType = 10; +pub const PrewittKernel: KernelInfoType = 11; +pub const CompassKernel: KernelInfoType = 12; +pub const KirschKernel: KernelInfoType = 13; +pub const DiamondKernel: KernelInfoType = 14; +pub const SquareKernel: KernelInfoType = 15; +pub const RectangleKernel: KernelInfoType = 16; +pub const OctagonKernel: KernelInfoType = 17; +pub const DiskKernel: KernelInfoType = 18; +pub const PlusKernel: KernelInfoType = 19; +pub const CrossKernel: KernelInfoType = 20; +pub const RingKernel: KernelInfoType = 21; +pub const PeaksKernel: KernelInfoType = 22; +pub const EdgesKernel: KernelInfoType = 23; +pub const CornersKernel: KernelInfoType = 24; +pub const DiagonalsKernel: KernelInfoType = 25; +pub const LineEndsKernel: KernelInfoType = 26; +pub const LineJunctionsKernel: KernelInfoType = 27; +pub const RidgesKernel: KernelInfoType = 28; +pub const ConvexHullKernel: KernelInfoType = 29; +pub const ThinSEKernel: KernelInfoType = 30; +pub const SkeletonKernel: KernelInfoType = 31; +pub const ChebyshevKernel: KernelInfoType = 32; +pub const ManhattanKernel: KernelInfoType = 33; +pub const OctagonalKernel: KernelInfoType = 34; +pub const EuclideanKernel: KernelInfoType = 35; +pub const UserDefinedKernel: KernelInfoType = 36; +pub const BinomialKernel: KernelInfoType = 37; +pub type MorphologyMethod = u32; +pub const UndefinedMorphology: MorphologyMethod = 0; +pub const ConvolveMorphology: MorphologyMethod = 1; +pub const CorrelateMorphology: MorphologyMethod = 2; +pub const ErodeMorphology: MorphologyMethod = 3; +pub const DilateMorphology: MorphologyMethod = 4; +pub const ErodeIntensityMorphology: MorphologyMethod = 5; +pub const DilateIntensityMorphology: MorphologyMethod = 6; +pub const DistanceMorphology: MorphologyMethod = 7; +pub const OpenMorphology: MorphologyMethod = 8; +pub const CloseMorphology: MorphologyMethod = 9; +pub const OpenIntensityMorphology: MorphologyMethod = 10; +pub const CloseIntensityMorphology: MorphologyMethod = 11; +pub const SmoothMorphology: MorphologyMethod = 12; +pub const EdgeInMorphology: MorphologyMethod = 13; +pub const EdgeOutMorphology: MorphologyMethod = 14; +pub const EdgeMorphology: MorphologyMethod = 15; +pub const TopHatMorphology: MorphologyMethod = 16; +pub const BottomHatMorphology: MorphologyMethod = 17; +pub const HitAndMissMorphology: MorphologyMethod = 18; +pub const ThinningMorphology: MorphologyMethod = 19; +pub const ThickenMorphology: MorphologyMethod = 20; +pub const VoronoiMorphology: MorphologyMethod = 21; +pub const IterativeDistanceMorphology: MorphologyMethod = 22; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct KernelInfo { + pub type_: KernelInfoType, + pub width: size_t, + pub height: size_t, + pub x: ssize_t, + pub y: ssize_t, + pub values: *mut f64, + pub minimum: f64, + pub maximum: f64, + pub negative_range: f64, + pub positive_range: f64, + pub angle: f64, + pub next: *mut KernelInfo, + pub signature: size_t, +} +impl ::std::default::Default for KernelInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PreviewType = u32; +pub const UndefinedPreview: PreviewType = 0; +pub const RotatePreview: PreviewType = 1; +pub const ShearPreview: PreviewType = 2; +pub const RollPreview: PreviewType = 3; +pub const HuePreview: PreviewType = 4; +pub const SaturationPreview: PreviewType = 5; +pub const BrightnessPreview: PreviewType = 6; +pub const GammaPreview: PreviewType = 7; +pub const SpiffPreview: PreviewType = 8; +pub const DullPreview: PreviewType = 9; +pub const GrayscalePreview: PreviewType = 10; +pub const QuantizePreview: PreviewType = 11; +pub const DespecklePreview: PreviewType = 12; +pub const ReduceNoisePreview: PreviewType = 13; +pub const AddNoisePreview: PreviewType = 14; +pub const SharpenPreview: PreviewType = 15; +pub const BlurPreview: PreviewType = 16; +pub const ThresholdPreview: PreviewType = 17; +pub const EdgeDetectPreview: PreviewType = 18; +pub const SpreadPreview: PreviewType = 19; +pub const SolarizePreview: PreviewType = 20; +pub const ShadePreview: PreviewType = 21; +pub const RaisePreview: PreviewType = 22; +pub const SegmentPreview: PreviewType = 23; +pub const SwirlPreview: PreviewType = 24; +pub const ImplodePreview: PreviewType = 25; +pub const WavePreview: PreviewType = 26; +pub const OilPaintPreview: PreviewType = 27; +pub const CharcoalDrawingPreview: PreviewType = 28; +pub const JPEGPreview: PreviewType = 29; +pub type DisposeType = u32; +pub const UnrecognizedDispose: DisposeType = 0; +pub const UndefinedDispose: DisposeType = 0; +pub const NoneDispose: DisposeType = 1; +pub const BackgroundDispose: DisposeType = 2; +pub const PreviousDispose: DisposeType = 3; +pub type ImageLayerMethod = u32; +pub const UndefinedLayer: ImageLayerMethod = 0; +pub const CoalesceLayer: ImageLayerMethod = 1; +pub const CompareAnyLayer: ImageLayerMethod = 2; +pub const CompareClearLayer: ImageLayerMethod = 3; +pub const CompareOverlayLayer: ImageLayerMethod = 4; +pub const DisposeLayer: ImageLayerMethod = 5; +pub const OptimizeLayer: ImageLayerMethod = 6; +pub const OptimizeImageLayer: ImageLayerMethod = 7; +pub const OptimizePlusLayer: ImageLayerMethod = 8; +pub const OptimizeTransLayer: ImageLayerMethod = 9; +pub const RemoveDupsLayer: ImageLayerMethod = 10; +pub const RemoveZeroLayer: ImageLayerMethod = 11; +pub const CompositeLayer: ImageLayerMethod = 12; +pub const MergeLayer: ImageLayerMethod = 13; +pub const FlattenLayer: ImageLayerMethod = 14; +pub const MosaicLayer: ImageLayerMethod = 15; +pub const TrimBoundsLayer: ImageLayerMethod = 16; +pub enum _HashmapInfo { } +pub type HashmapInfo = _HashmapInfo; +pub enum _LinkedListInfo { } +pub type LinkedListInfo = _LinkedListInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _LocaleInfo { + pub path: *mut ::libc::c_char, + pub tag: *mut ::libc::c_char, + pub message: *mut ::libc::c_char, + pub stealth: MagickBooleanType, + pub previous: *mut _LocaleInfo, + pub next: *mut _LocaleInfo, + pub signature: size_t, +} +impl ::std::default::Default for _LocaleInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type LocaleInfo = _LocaleInfo; +pub type MagickProgressMonitor = + ::std::option::Option MagickBooleanType>; +#[repr(C)] +#[derive(Copy)] +pub struct _StringInfo { + pub path: [::libc::c_char; 4096usize], + pub datum: *mut ::libc::c_uchar, + pub length: size_t, + pub signature: size_t, +} +impl ::std::clone::Clone for _StringInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _StringInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type StringInfo = _StringInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ProfileInfo { + pub name: *mut ::libc::c_char, + pub length: size_t, + pub info: *mut ::libc::c_uchar, + pub signature: size_t, +} +impl ::std::default::Default for _ProfileInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ProfileInfo = _ProfileInfo; +pub type RenderingIntent = u32; +pub const UndefinedIntent: RenderingIntent = 0; +pub const SaturationIntent: RenderingIntent = 1; +pub const PerceptualIntent: RenderingIntent = 2; +pub const AbsoluteIntent: RenderingIntent = 3; +pub const RelativeIntent: RenderingIntent = 4; +pub type EndianType = u32; +pub const UndefinedEndian: EndianType = 0; +pub const LSBEndian: EndianType = 1; +pub const MSBEndian: EndianType = 2; +pub type QuantumAlphaType = u32; +pub const UndefinedQuantumAlpha: QuantumAlphaType = 0; +pub const AssociatedQuantumAlpha: QuantumAlphaType = 1; +pub const DisassociatedQuantumAlpha: QuantumAlphaType = 2; +pub type QuantumFormatType = u32; +pub const UndefinedQuantumFormat: QuantumFormatType = 0; +pub const FloatingPointQuantumFormat: QuantumFormatType = 1; +pub const SignedQuantumFormat: QuantumFormatType = 2; +pub const UnsignedQuantumFormat: QuantumFormatType = 3; +pub type QuantumType = u32; +pub const UndefinedQuantum: QuantumType = 0; +pub const AlphaQuantum: QuantumType = 1; +pub const BlackQuantum: QuantumType = 2; +pub const BlueQuantum: QuantumType = 3; +pub const CMYKAQuantum: QuantumType = 4; +pub const CMYKQuantum: QuantumType = 5; +pub const CyanQuantum: QuantumType = 6; +pub const GrayAlphaQuantum: QuantumType = 7; +pub const GrayQuantum: QuantumType = 8; +pub const GreenQuantum: QuantumType = 9; +pub const IndexAlphaQuantum: QuantumType = 10; +pub const IndexQuantum: QuantumType = 11; +pub const MagentaQuantum: QuantumType = 12; +pub const OpacityQuantum: QuantumType = 13; +pub const RedQuantum: QuantumType = 14; +pub const RGBAQuantum: QuantumType = 15; +pub const BGRAQuantum: QuantumType = 16; +pub const RGBOQuantum: QuantumType = 17; +pub const RGBQuantum: QuantumType = 18; +pub const YellowQuantum: QuantumType = 19; +pub const GrayPadQuantum: QuantumType = 20; +pub const RGBPadQuantum: QuantumType = 21; +pub const CbYCrYQuantum: QuantumType = 22; +pub const CbYCrQuantum: QuantumType = 23; +pub const CbYCrAQuantum: QuantumType = 24; +pub const CMYKOQuantum: QuantumType = 25; +pub const BGRQuantum: QuantumType = 26; +pub const BGROQuantum: QuantumType = 27; +pub enum _QuantumInfo { } +pub type QuantumInfo = _QuantumInfo; +pub type FilterTypes = u32; +pub const UndefinedFilter: FilterTypes = 0; +pub const PointFilter: FilterTypes = 1; +pub const BoxFilter: FilterTypes = 2; +pub const TriangleFilter: FilterTypes = 3; +pub const HermiteFilter: FilterTypes = 4; +pub const HanningFilter: FilterTypes = 5; +pub const HammingFilter: FilterTypes = 6; +pub const BlackmanFilter: FilterTypes = 7; +pub const GaussianFilter: FilterTypes = 8; +pub const QuadraticFilter: FilterTypes = 9; +pub const CubicFilter: FilterTypes = 10; +pub const CatromFilter: FilterTypes = 11; +pub const MitchellFilter: FilterTypes = 12; +pub const JincFilter: FilterTypes = 13; +pub const SincFilter: FilterTypes = 14; +pub const SincFastFilter: FilterTypes = 15; +pub const KaiserFilter: FilterTypes = 16; +pub const WelshFilter: FilterTypes = 17; +pub const ParzenFilter: FilterTypes = 18; +pub const BohmanFilter: FilterTypes = 19; +pub const BartlettFilter: FilterTypes = 20; +pub const LagrangeFilter: FilterTypes = 21; +pub const LanczosFilter: FilterTypes = 22; +pub const LanczosSharpFilter: FilterTypes = 23; +pub const Lanczos2Filter: FilterTypes = 24; +pub const Lanczos2SharpFilter: FilterTypes = 25; +pub const RobidouxFilter: FilterTypes = 26; +pub const RobidouxSharpFilter: FilterTypes = 27; +pub const CosineFilter: FilterTypes = 28; +pub const SplineFilter: FilterTypes = 29; +pub const LanczosRadiusFilter: FilterTypes = 30; +pub const SentinelFilter: FilterTypes = 31; +pub enum _ResampleFilter { } +pub type ResampleFilter = _ResampleFilter; +pub enum _ResizeFilter { } +pub type ResizeFilter = _ResizeFilter; +pub type TimerState = u32; +pub const UndefinedTimerState: TimerState = 0; +pub const StoppedTimerState: TimerState = 1; +pub const RunningTimerState: TimerState = 2; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _Timer { + pub start: f64, + pub stop: f64, + pub total: f64, +} +impl ::std::default::Default for _Timer { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type Timer = _Timer; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _TimerInfo { + pub user: Timer, + pub elapsed: Timer, + pub state: TimerState, + pub signature: size_t, +} +impl ::std::default::Default for _TimerInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type TimerInfo = _TimerInfo; +#[repr(C)] +#[derive(Copy)] +pub struct _Image { + pub storage_class: ClassType, + pub colorspace: ColorspaceType, + pub compression: CompressionType, + pub quality: size_t, + pub orientation: OrientationType, + pub taint: MagickBooleanType, + pub matte: MagickBooleanType, + pub columns: size_t, + pub rows: size_t, + pub depth: size_t, + pub colors: size_t, + pub colormap: *mut PixelPacket, + pub background_color: PixelPacket, + pub border_color: PixelPacket, + pub matte_color: PixelPacket, + pub gamma: f64, + pub chromaticity: ChromaticityInfo, + pub rendering_intent: RenderingIntent, + pub profiles: *mut ::libc::c_void, + pub units: ResolutionType, + pub montage: *mut ::libc::c_char, + pub directory: *mut ::libc::c_char, + pub geometry: *mut ::libc::c_char, + pub offset: ssize_t, + pub x_resolution: f64, + pub y_resolution: f64, + pub page: RectangleInfo, + pub extract_info: RectangleInfo, + pub tile_info: RectangleInfo, + pub bias: f64, + pub blur: f64, + pub fuzz: f64, + pub filter: FilterTypes, + pub interlace: InterlaceType, + pub endian: EndianType, + pub gravity: GravityType, + pub compose: CompositeOperator, + pub dispose: DisposeType, + pub clip_mask: *mut _Image, + pub scene: size_t, + pub delay: size_t, + pub ticks_per_second: ssize_t, + pub iterations: size_t, + pub total_colors: size_t, + pub start_loop: ssize_t, + pub error: ErrorInfo, + pub timer: TimerInfo, + pub progress_monitor: MagickProgressMonitor, + pub client_data: *mut ::libc::c_void, + pub cache: *mut ::libc::c_void, + pub attributes: *mut ::libc::c_void, + pub ascii85: *mut Ascii85Info, + pub blob: *mut BlobInfo, + pub filename: [::libc::c_char; 4096usize], + pub magick_filename: [::libc::c_char; 4096usize], + pub magick: [::libc::c_char; 4096usize], + pub magick_columns: size_t, + pub magick_rows: size_t, + pub exception: ExceptionInfo, + pub debug: MagickBooleanType, + pub reference_count: ssize_t, + pub semaphore: *mut SemaphoreInfo, + pub color_profile: ProfileInfo, + pub iptc_profile: ProfileInfo, + pub generic_profile: *mut ProfileInfo, + pub generic_profiles: size_t, + pub signature: size_t, + pub previous: *mut _Image, + pub list: *mut _Image, + pub next: *mut _Image, + pub interpolate: InterpolatePixelMethod, + pub black_point_compensation: MagickBooleanType, + pub transparent_color: PixelPacket, + pub mask: *mut _Image, + pub tile_offset: RectangleInfo, + pub properties: *mut ::libc::c_void, + pub artifacts: *mut ::libc::c_void, + pub type_: ImageType, + pub dither: MagickBooleanType, + pub extent: MagickSizeType, + pub ping: MagickBooleanType, + pub channels: size_t, + pub timestamp: time_t, + pub intensity: PixelIntensityMethod, + pub duration: size_t, + pub tietz_offset: ::libc::c_long, +} +impl ::std::clone::Clone for _Image { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _Image { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct _ImageInfo { + pub compression: CompressionType, + pub orientation: OrientationType, + pub temporary: MagickBooleanType, + pub adjoin: MagickBooleanType, + pub affirm: MagickBooleanType, + pub antialias: MagickBooleanType, + pub size: *mut ::libc::c_char, + pub extract: *mut ::libc::c_char, + pub page: *mut ::libc::c_char, + pub scenes: *mut ::libc::c_char, + pub scene: size_t, + pub number_scenes: size_t, + pub depth: size_t, + pub interlace: InterlaceType, + pub endian: EndianType, + pub units: ResolutionType, + pub quality: size_t, + pub sampling_factor: *mut ::libc::c_char, + pub server_name: *mut ::libc::c_char, + pub font: *mut ::libc::c_char, + pub texture: *mut ::libc::c_char, + pub density: *mut ::libc::c_char, + pub pointsize: f64, + pub fuzz: f64, + pub background_color: PixelPacket, + pub border_color: PixelPacket, + pub matte_color: PixelPacket, + pub dither: MagickBooleanType, + pub monochrome: MagickBooleanType, + pub colors: size_t, + pub colorspace: ColorspaceType, + pub type_: ImageType, + pub preview_type: PreviewType, + pub group: ssize_t, + pub ping: MagickBooleanType, + pub verbose: MagickBooleanType, + pub view: *mut ::libc::c_char, + pub authenticate: *mut ::libc::c_char, + pub channel: ChannelType, + pub attributes: *mut Image, + pub options: *mut ::libc::c_void, + pub progress_monitor: MagickProgressMonitor, + pub client_data: *mut ::libc::c_void, + pub cache: *mut ::libc::c_void, + pub stream: StreamHandler, + pub file: *mut FILE, + pub blob: *mut ::libc::c_void, + pub length: size_t, + pub magick: [::libc::c_char; 4096usize], + pub unique: [::libc::c_char; 4096usize], + pub zero: [::libc::c_char; 4096usize], + pub filename: [::libc::c_char; 4096usize], + pub debug: MagickBooleanType, + pub tile: *mut ::libc::c_char, + pub subimage: size_t, + pub subrange: size_t, + pub pen: PixelPacket, + pub signature: size_t, + pub virtual_pixel_method: VirtualPixelMethod, + pub transparent_color: PixelPacket, + pub profile: *mut ::libc::c_void, + pub synchronize: MagickBooleanType, +} +impl ::std::clone::Clone for _ImageInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _ImageInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type StretchType = u32; +pub const UndefinedStretch: StretchType = 0; +pub const NormalStretch: StretchType = 1; +pub const UltraCondensedStretch: StretchType = 2; +pub const ExtraCondensedStretch: StretchType = 3; +pub const CondensedStretch: StretchType = 4; +pub const SemiCondensedStretch: StretchType = 5; +pub const SemiExpandedStretch: StretchType = 6; +pub const ExpandedStretch: StretchType = 7; +pub const ExtraExpandedStretch: StretchType = 8; +pub const UltraExpandedStretch: StretchType = 9; +pub const AnyStretch: StretchType = 10; +pub type StyleType = u32; +pub const UndefinedStyle: StyleType = 0; +pub const NormalStyle: StyleType = 1; +pub const ItalicStyle: StyleType = 2; +pub const ObliqueStyle: StyleType = 3; +pub const AnyStyle: StyleType = 4; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _TypeInfo { + pub face: size_t, + pub path: *mut ::libc::c_char, + pub name: *mut ::libc::c_char, + pub description: *mut ::libc::c_char, + pub family: *mut ::libc::c_char, + pub style: StyleType, + pub stretch: StretchType, + pub weight: size_t, + pub encoding: *mut ::libc::c_char, + pub foundry: *mut ::libc::c_char, + pub format: *mut ::libc::c_char, + pub metrics: *mut ::libc::c_char, + pub glyphs: *mut ::libc::c_char, + pub stealth: MagickBooleanType, + pub previous: *mut _TypeInfo, + pub next: *mut _TypeInfo, + pub signature: size_t, +} +impl ::std::default::Default for _TypeInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type TypeInfo = _TypeInfo; +pub type AlignType = u32; +pub const UndefinedAlign: AlignType = 0; +pub const LeftAlign: AlignType = 1; +pub const CenterAlign: AlignType = 2; +pub const RightAlign: AlignType = 3; +pub type ClipPathUnits = u32; +pub const UndefinedPathUnits: ClipPathUnits = 0; +pub const UserSpace: ClipPathUnits = 1; +pub const UserSpaceOnUse: ClipPathUnits = 2; +pub const ObjectBoundingBox: ClipPathUnits = 3; +pub type DecorationType = u32; +pub const UndefinedDecoration: DecorationType = 0; +pub const NoDecoration: DecorationType = 1; +pub const UnderlineDecoration: DecorationType = 2; +pub const OverlineDecoration: DecorationType = 3; +pub const LineThroughDecoration: DecorationType = 4; +pub type DirectionType = u32; +pub const UndefinedDirection: DirectionType = 0; +pub const RightToLeftDirection: DirectionType = 1; +pub const LeftToRightDirection: DirectionType = 2; +pub type FillRule = u32; +pub const UndefinedRule: FillRule = 0; +pub const EvenOddRule: FillRule = 1; +pub const NonZeroRule: FillRule = 2; +pub type GradientType = u32; +pub const UndefinedGradient: GradientType = 0; +pub const LinearGradient: GradientType = 1; +pub const RadialGradient: GradientType = 2; +pub type LineCap = u32; +pub const UndefinedCap: LineCap = 0; +pub const ButtCap: LineCap = 1; +pub const RoundCap: LineCap = 2; +pub const SquareCap: LineCap = 3; +pub type LineJoin = u32; +pub const UndefinedJoin: LineJoin = 0; +pub const MiterJoin: LineJoin = 1; +pub const RoundJoin: LineJoin = 2; +pub const BevelJoin: LineJoin = 3; +pub type PaintMethod = u32; +pub const UndefinedMethod: PaintMethod = 0; +pub const PointMethod: PaintMethod = 1; +pub const ReplaceMethod: PaintMethod = 2; +pub const FloodfillMethod: PaintMethod = 3; +pub const FillToBorderMethod: PaintMethod = 4; +pub const ResetMethod: PaintMethod = 5; +pub type PrimitiveType = u32; +pub const UndefinedPrimitive: PrimitiveType = 0; +pub const PointPrimitive: PrimitiveType = 1; +pub const LinePrimitive: PrimitiveType = 2; +pub const RectanglePrimitive: PrimitiveType = 3; +pub const RoundRectanglePrimitive: PrimitiveType = 4; +pub const ArcPrimitive: PrimitiveType = 5; +pub const EllipsePrimitive: PrimitiveType = 6; +pub const CirclePrimitive: PrimitiveType = 7; +pub const PolylinePrimitive: PrimitiveType = 8; +pub const PolygonPrimitive: PrimitiveType = 9; +pub const BezierPrimitive: PrimitiveType = 10; +pub const ColorPrimitive: PrimitiveType = 11; +pub const MattePrimitive: PrimitiveType = 12; +pub const TextPrimitive: PrimitiveType = 13; +pub const ImagePrimitive: PrimitiveType = 14; +pub const PathPrimitive: PrimitiveType = 15; +pub type ReferenceType = u32; +pub const UndefinedReference: ReferenceType = 0; +pub const GradientReference: ReferenceType = 1; +pub type SpreadMethod = u32; +pub const UndefinedSpread: SpreadMethod = 0; +pub const PadSpread: SpreadMethod = 1; +pub const ReflectSpread: SpreadMethod = 2; +pub const RepeatSpread: SpreadMethod = 3; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _PointInfo { + pub x: f64, + pub y: f64, +} +impl ::std::default::Default for _PointInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PointInfo = _PointInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _StopInfo { + pub color: MagickPixelPacket, + pub offset: MagickRealType, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::default::Default for _StopInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type StopInfo = _StopInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _GradientInfo { + pub type_: GradientType, + pub bounding_box: RectangleInfo, + pub gradient_vector: SegmentInfo, + pub stops: *mut StopInfo, + pub number_stops: size_t, + pub spread: SpreadMethod, + pub debug: MagickBooleanType, + pub signature: size_t, + pub center: PointInfo, + pub radius: MagickRealType, + pub angle: MagickRealType, + pub radii: PointInfo, +} +impl ::std::default::Default for _GradientInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type GradientInfo = _GradientInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ElementReference { + pub id: *mut ::libc::c_char, + pub type_: ReferenceType, + pub gradient: GradientInfo, + pub signature: size_t, + pub previous: *mut _ElementReference, + pub next: *mut _ElementReference, +} +impl ::std::default::Default for _ElementReference { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ElementReference = _ElementReference; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _DrawInfo { + pub primitive: *mut ::libc::c_char, + pub geometry: *mut ::libc::c_char, + pub viewbox: RectangleInfo, + pub affine: AffineMatrix, + pub gravity: GravityType, + pub fill: PixelPacket, + pub stroke: PixelPacket, + pub stroke_width: f64, + pub gradient: GradientInfo, + pub fill_pattern: *mut Image, + pub tile: *mut Image, + pub stroke_pattern: *mut Image, + pub stroke_antialias: MagickBooleanType, + pub text_antialias: MagickBooleanType, + pub fill_rule: FillRule, + pub linecap: LineCap, + pub linejoin: LineJoin, + pub miterlimit: size_t, + pub dash_offset: f64, + pub decorate: DecorationType, + pub compose: CompositeOperator, + pub text: *mut ::libc::c_char, + pub face: size_t, + pub font: *mut ::libc::c_char, + pub metrics: *mut ::libc::c_char, + pub family: *mut ::libc::c_char, + pub style: StyleType, + pub stretch: StretchType, + pub weight: size_t, + pub encoding: *mut ::libc::c_char, + pub pointsize: f64, + pub density: *mut ::libc::c_char, + pub align: AlignType, + pub undercolor: PixelPacket, + pub border_color: PixelPacket, + pub server_name: *mut ::libc::c_char, + pub dash_pattern: *mut f64, + pub clip_mask: *mut ::libc::c_char, + pub bounds: SegmentInfo, + pub clip_units: ClipPathUnits, + pub opacity: Quantum, + pub render: MagickBooleanType, + pub element_reference: ElementReference, + pub debug: MagickBooleanType, + pub signature: size_t, + pub kerning: f64, + pub interword_spacing: f64, + pub interline_spacing: f64, + pub direction: DirectionType, + pub fill_opacity: f64, + pub stroke_opacity: f64, +} +impl ::std::default::Default for _DrawInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type DrawInfo = _DrawInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _PrimitiveInfo { + pub point: PointInfo, + pub coordinates: size_t, + pub primitive: PrimitiveType, + pub method: PaintMethod, + pub text: *mut ::libc::c_char, +} +impl ::std::default::Default for _PrimitiveInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PrimitiveInfo = _PrimitiveInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _TypeMetric { + pub pixels_per_em: PointInfo, + pub ascent: f64, + pub descent: f64, + pub width: f64, + pub height: f64, + pub max_advance: f64, + pub underline_position: f64, + pub underline_thickness: f64, + pub bounds: SegmentInfo, + pub origin: PointInfo, +} +impl ::std::default::Default for _TypeMetric { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type TypeMetric = _TypeMetric; +pub type NoiseType = u32; +pub const UndefinedNoise: NoiseType = 0; +pub const UniformNoise: NoiseType = 1; +pub const GaussianNoise: NoiseType = 2; +pub const MultiplicativeGaussianNoise: NoiseType = 3; +pub const ImpulseNoise: NoiseType = 4; +pub const LaplacianNoise: NoiseType = 5; +pub const PoissonNoise: NoiseType = 6; +pub const RandomNoise: NoiseType = 7; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ChannelStatistics { + pub depth: size_t, + pub minima: f64, + pub maxima: f64, + pub sum: f64, + pub sum_squared: f64, + pub sum_cubed: f64, + pub sum_fourth_power: f64, + pub mean: f64, + pub variance: f64, + pub standard_deviation: f64, + pub kurtosis: f64, + pub skewness: f64, + pub entropy: f64, +} +impl ::std::default::Default for _ChannelStatistics { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChannelStatistics = _ChannelStatistics; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ChannelMoments { + pub I: [f64; 32usize], + pub centroid: PointInfo, + pub ellipse_axis: PointInfo, + pub ellipse_angle: f64, + pub ellipse_eccentricity: f64, + pub ellipse_intensity: f64, +} +impl ::std::default::Default for _ChannelMoments { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChannelMoments = _ChannelMoments; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ChannelPerceptualHash { + pub P: [f64; 32usize], + pub Q: [f64; 32usize], +} +impl ::std::default::Default for _ChannelPerceptualHash { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChannelPerceptualHash = _ChannelPerceptualHash; +pub type MagickEvaluateOperator = u32; +pub const UndefinedEvaluateOperator: MagickEvaluateOperator = 0; +pub const AddEvaluateOperator: MagickEvaluateOperator = 1; +pub const AndEvaluateOperator: MagickEvaluateOperator = 2; +pub const DivideEvaluateOperator: MagickEvaluateOperator = 3; +pub const LeftShiftEvaluateOperator: MagickEvaluateOperator = 4; +pub const MaxEvaluateOperator: MagickEvaluateOperator = 5; +pub const MinEvaluateOperator: MagickEvaluateOperator = 6; +pub const MultiplyEvaluateOperator: MagickEvaluateOperator = 7; +pub const OrEvaluateOperator: MagickEvaluateOperator = 8; +pub const RightShiftEvaluateOperator: MagickEvaluateOperator = 9; +pub const SetEvaluateOperator: MagickEvaluateOperator = 10; +pub const SubtractEvaluateOperator: MagickEvaluateOperator = 11; +pub const XorEvaluateOperator: MagickEvaluateOperator = 12; +pub const PowEvaluateOperator: MagickEvaluateOperator = 13; +pub const LogEvaluateOperator: MagickEvaluateOperator = 14; +pub const ThresholdEvaluateOperator: MagickEvaluateOperator = 15; +pub const ThresholdBlackEvaluateOperator: MagickEvaluateOperator = 16; +pub const ThresholdWhiteEvaluateOperator: MagickEvaluateOperator = 17; +pub const GaussianNoiseEvaluateOperator: MagickEvaluateOperator = 18; +pub const ImpulseNoiseEvaluateOperator: MagickEvaluateOperator = 19; +pub const LaplacianNoiseEvaluateOperator: MagickEvaluateOperator = 20; +pub const MultiplicativeNoiseEvaluateOperator: MagickEvaluateOperator = 21; +pub const PoissonNoiseEvaluateOperator: MagickEvaluateOperator = 22; +pub const UniformNoiseEvaluateOperator: MagickEvaluateOperator = 23; +pub const CosineEvaluateOperator: MagickEvaluateOperator = 24; +pub const SineEvaluateOperator: MagickEvaluateOperator = 25; +pub const AddModulusEvaluateOperator: MagickEvaluateOperator = 26; +pub const MeanEvaluateOperator: MagickEvaluateOperator = 27; +pub const AbsEvaluateOperator: MagickEvaluateOperator = 28; +pub const ExponentialEvaluateOperator: MagickEvaluateOperator = 29; +pub const MedianEvaluateOperator: MagickEvaluateOperator = 30; +pub const SumEvaluateOperator: MagickEvaluateOperator = 31; +pub const RootMeanSquareEvaluateOperator: MagickEvaluateOperator = 32; +pub type MagickFunction = u32; +pub const UndefinedFunction: MagickFunction = 0; +pub const PolynomialFunction: MagickFunction = 1; +pub const SinusoidFunction: MagickFunction = 2; +pub const ArcsinFunction: MagickFunction = 3; +pub const ArctanFunction: MagickFunction = 4; +pub type StatisticType = u32; +pub const UndefinedStatistic: StatisticType = 0; +pub const GradientStatistic: StatisticType = 1; +pub const MaximumStatistic: StatisticType = 2; +pub const MeanStatistic: StatisticType = 3; +pub const MedianStatistic: StatisticType = 4; +pub const MinimumStatistic: StatisticType = 5; +pub const ModeStatistic: StatisticType = 6; +pub const NonpeakStatistic: StatisticType = 7; +pub const StandardDeviationStatistic: StatisticType = 8; +pub const RootMeanSquareStatistic: StatisticType = 9; +pub type CacheType = u32; +pub const UndefinedCache: CacheType = 0; +pub const MemoryCache: CacheType = 1; +pub const MapCache: CacheType = 2; +pub const DiskCache: CacheType = 3; +pub const PingCache: CacheType = 4; +pub const DistributedCache: CacheType = 5; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _CoderInfo { + pub path: *mut ::libc::c_char, + pub magick: *mut ::libc::c_char, + pub name: *mut ::libc::c_char, + pub exempt: MagickBooleanType, + pub stealth: MagickBooleanType, + pub previous: *mut _CoderInfo, + pub next: *mut _CoderInfo, + pub signature: size_t, +} +impl ::std::default::Default for _CoderInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type CoderInfo = _CoderInfo; +pub type MetricType = u32; +pub const UndefinedMetric: MetricType = 0; +pub const AbsoluteErrorMetric: MetricType = 1; +pub const MeanAbsoluteErrorMetric: MetricType = 2; +pub const MeanErrorPerPixelMetric: MetricType = 3; +pub const MeanSquaredErrorMetric: MetricType = 4; +pub const PeakAbsoluteErrorMetric: MetricType = 5; +pub const PeakSignalToNoiseRatioMetric: MetricType = 6; +pub const RootMeanSquaredErrorMetric: MetricType = 7; +pub const NormalizedCrossCorrelationErrorMetric: MetricType = 8; +pub const FuzzErrorMetric: MetricType = 9; +pub const UndefinedErrorMetric: MetricType = 0; +pub const PerceptualHashErrorMetric: MetricType = 255; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ConfigureInfo { + pub path: *mut ::libc::c_char, + pub name: *mut ::libc::c_char, + pub value: *mut ::libc::c_char, + pub exempt: MagickBooleanType, + pub stealth: MagickBooleanType, + pub previous: *mut _ConfigureInfo, + pub next: *mut _ConfigureInfo, + pub signature: size_t, +} +impl ::std::default::Default for _ConfigureInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ConfigureInfo = _ConfigureInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _FrameInfo { + pub width: size_t, + pub height: size_t, + pub x: ssize_t, + pub y: ssize_t, + pub inner_bevel: ssize_t, + pub outer_bevel: ssize_t, +} +impl ::std::default::Default for _FrameInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type FrameInfo = _FrameInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _DelegateInfo { + pub path: *mut ::libc::c_char, + pub decode: *mut ::libc::c_char, + pub encode: *mut ::libc::c_char, + pub commands: *mut ::libc::c_char, + pub mode: ssize_t, + pub thread_support: MagickBooleanType, + pub spawn: MagickBooleanType, + pub stealth: MagickBooleanType, + pub previous: *mut _DelegateInfo, + pub next: *mut _DelegateInfo, + pub signature: size_t, + pub semaphore: *mut SemaphoreInfo, +} +impl ::std::default::Default for _DelegateInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type DelegateInfo = _DelegateInfo; +pub type DitherMethod = u32; +pub const UndefinedDitherMethod: DitherMethod = 0; +pub const NoDitherMethod: DitherMethod = 1; +pub const RiemersmaDitherMethod: DitherMethod = 2; +pub const FloydSteinbergDitherMethod: DitherMethod = 3; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _QuantizeInfo { + pub number_colors: size_t, + pub tree_depth: size_t, + pub dither: MagickBooleanType, + pub colorspace: ColorspaceType, + pub measure_error: MagickBooleanType, + pub signature: size_t, + pub dither_method: DitherMethod, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::default::Default for _QuantizeInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type QuantizeInfo = _QuantizeInfo; +pub type RegistryType = u32; +pub const UndefinedRegistryType: RegistryType = 0; +pub const ImageRegistryType: RegistryType = 1; +pub const ImageInfoRegistryType: RegistryType = 2; +pub const StringRegistryType: RegistryType = 3; +pub type MagickLayerMethod = u32; +pub const UndefinedMagickLayerMethod: MagickLayerMethod = 0; +pub type ExtendedSignedIntegralType = MagickOffsetType; +pub type ExtendedUnsignedIntegralType = MagickSizeType; +pub type ExtendedRationalType = MagickRealType; +pub enum _ViewInfo { } +pub type ViewInfo = _ViewInfo; +pub type MonitorHandler = + ::std::option::Option MagickBooleanType>; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ImageAttribute { + pub key: *mut ::libc::c_char, + pub value: *mut ::libc::c_char, + pub compression: MagickBooleanType, + pub previous: *mut _ImageAttribute, + pub next: *mut _ImageAttribute, +} +impl ::std::default::Default for _ImageAttribute { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ImageAttribute = _ImageAttribute; +pub type DistortImageMethod = u32; +pub const UndefinedDistortion: DistortImageMethod = 0; +pub const AffineDistortion: DistortImageMethod = 1; +pub const AffineProjectionDistortion: DistortImageMethod = 2; +pub const ScaleRotateTranslateDistortion: DistortImageMethod = 3; +pub const PerspectiveDistortion: DistortImageMethod = 4; +pub const PerspectiveProjectionDistortion: DistortImageMethod = 5; +pub const BilinearForwardDistortion: DistortImageMethod = 6; +pub const BilinearDistortion: DistortImageMethod = 6; +pub const BilinearReverseDistortion: DistortImageMethod = 7; +pub const PolynomialDistortion: DistortImageMethod = 8; +pub const ArcDistortion: DistortImageMethod = 9; +pub const PolarDistortion: DistortImageMethod = 10; +pub const DePolarDistortion: DistortImageMethod = 11; +pub const Cylinder2PlaneDistortion: DistortImageMethod = 12; +pub const Plane2CylinderDistortion: DistortImageMethod = 13; +pub const BarrelDistortion: DistortImageMethod = 14; +pub const BarrelInverseDistortion: DistortImageMethod = 15; +pub const ShepardsDistortion: DistortImageMethod = 16; +pub const ResizeDistortion: DistortImageMethod = 17; +pub const SentinelDistortion: DistortImageMethod = 18; +pub type SparseColorMethod = u32; +pub const UndefinedColorInterpolate: SparseColorMethod = 0; +pub const BarycentricColorInterpolate: SparseColorMethod = 1; +pub const BilinearColorInterpolate: SparseColorMethod = 7; +pub const PolynomialColorInterpolate: SparseColorMethod = 8; +pub const ShepardsColorInterpolate: SparseColorMethod = 16; +pub const VoronoiColorInterpolate: SparseColorMethod = 18; +pub const InverseColorInterpolate: SparseColorMethod = 19; +pub const ManhattanColorInterpolate: SparseColorMethod = 20; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ChannelFeatures { + pub angular_second_moment: [f64; 4usize], + pub contrast: [f64; 4usize], + pub correlation: [f64; 4usize], + pub variance_sum_of_squares: [f64; 4usize], + pub inverse_difference_moment: [f64; 4usize], + pub sum_average: [f64; 4usize], + pub sum_variance: [f64; 4usize], + pub sum_entropy: [f64; 4usize], + pub entropy: [f64; 4usize], + pub difference_variance: [f64; 4usize], + pub difference_entropy: [f64; 4usize], + pub measure_of_correlation_1: [f64; 4usize], + pub measure_of_correlation_2: [f64; 4usize], + pub maximum_correlation_coefficient: [f64; 4usize], +} +impl ::std::default::Default for _ChannelFeatures { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChannelFeatures = _ChannelFeatures; +pub type ComplexOperator = u32; +pub const UndefinedComplexOperator: ComplexOperator = 0; +pub const AddComplexOperator: ComplexOperator = 1; +pub const ConjugateComplexOperator: ComplexOperator = 2; +pub const DivideComplexOperator: ComplexOperator = 3; +pub const MagnitudePhaseComplexOperator: ComplexOperator = 4; +pub const MultiplyComplexOperator: ComplexOperator = 5; +pub const RealImaginaryComplexOperator: ComplexOperator = 6; +pub const SubtractComplexOperator: ComplexOperator = 7; +pub enum _RandomInfo { } +pub type RandomInfo = _RandomInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ColorPacket { + pub pixel: PixelPacket, + pub index: IndexPacket, + pub count: MagickSizeType, +} +impl ::std::default::Default for _ColorPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ColorPacket = _ColorPacket; +pub enum _ImageView { } +pub type ImageView = _ImageView; +pub type DuplexTransferImageViewMethod = + ::std::option::Option MagickBooleanType>; +pub type GetImageViewMethod = + ::std::option::Option MagickBooleanType>; +pub type SetImageViewMethod = + ::std::option::Option MagickBooleanType>; +pub type TransferImageViewMethod = + ::std::option::Option MagickBooleanType>; +pub type UpdateImageViewMethod = + ::std::option::Option MagickBooleanType>; +pub type LogEventType = u32; +pub const UndefinedEvents: LogEventType = 0; +pub const NoEvents: LogEventType = 0; +pub const TraceEvent: LogEventType = 1; +pub const AnnotateEvent: LogEventType = 2; +pub const BlobEvent: LogEventType = 4; +pub const CacheEvent: LogEventType = 8; +pub const CoderEvent: LogEventType = 16; +pub const ConfigureEvent: LogEventType = 32; +pub const DeprecateEvent: LogEventType = 64; +pub const DrawEvent: LogEventType = 128; +pub const ExceptionEvent: LogEventType = 256; +pub const ImageEvent: LogEventType = 512; +pub const LocaleEvent: LogEventType = 1024; +pub const ModuleEvent: LogEventType = 2048; +pub const PolicyEvent: LogEventType = 4096; +pub const ResourceEvent: LogEventType = 8192; +pub const TransformEvent: LogEventType = 16384; +pub const UserEvent: LogEventType = 36864; +pub const WandEvent: LogEventType = 65536; +pub const X11Event: LogEventType = 131072; +pub const AccelerateEvent: LogEventType = 262144; +pub const AllEvents: LogEventType = 2147483647; +pub enum _LogInfo { } +pub type LogInfo = _LogInfo; +pub type MagickLogMethod = + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _MagicInfo { + pub path: *mut ::libc::c_char, + pub name: *mut ::libc::c_char, + pub target: *mut ::libc::c_char, + pub magic: *mut ::libc::c_uchar, + pub length: size_t, + pub offset: MagickOffsetType, + pub exempt: MagickBooleanType, + pub stealth: MagickBooleanType, + pub previous: *mut _MagicInfo, + pub next: *mut _MagicInfo, + pub signature: size_t, +} +impl ::std::default::Default for _MagicInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type MagicInfo = _MagicInfo; +pub type MagickFormatType = u32; +pub const UndefinedFormatType: MagickFormatType = 0; +pub const ImplicitFormatType: MagickFormatType = 1; +pub const ExplicitFormatType: MagickFormatType = 2; +pub type MagickThreadSupport = u32; +pub const NoThreadSupport: MagickThreadSupport = 0; +pub const DecoderThreadSupport: MagickThreadSupport = 1; +pub const EncoderThreadSupport: MagickThreadSupport = 2; +pub type DecodeImageHandler = + ::std::option::Option *mut Image>; +pub type EncodeImageHandler = + ::std::option::Option MagickBooleanType>; +pub type IsImageFormatHandler = + ::std::option::Option MagickBooleanType>; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _MagickInfo { + pub name: *mut ::libc::c_char, + pub description: *mut ::libc::c_char, + pub version: *mut ::libc::c_char, + pub note: *mut ::libc::c_char, + pub module: *mut ::libc::c_char, + pub image_info: *mut ImageInfo, + pub decoder: DecodeImageHandler, + pub encoder: EncodeImageHandler, + pub magick: IsImageFormatHandler, + pub client_data: *mut ::libc::c_void, + pub adjoin: MagickBooleanType, + pub raw: MagickBooleanType, + pub endian_support: MagickBooleanType, + pub blob_support: MagickBooleanType, + pub seekable_stream: MagickBooleanType, + pub format_type: MagickFormatType, + pub thread_support: MagickStatusType, + pub stealth: MagickBooleanType, + pub previous: *mut _MagickInfo, + pub next: *mut _MagickInfo, + pub signature: size_t, + pub mime_type: *mut ::libc::c_char, + pub semaphore: *mut SemaphoreInfo, +} +impl ::std::default::Default for _MagickInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type MagickInfo = _MagickInfo; +pub enum _MatrixInfo { } +pub type MatrixInfo = _MatrixInfo; +pub enum _MemoryInfo { } +pub type MemoryInfo = _MemoryInfo; +pub type AcquireMemoryHandler = + ::std::option::Option *mut ::libc::c_void>; +pub type DestroyMemoryHandler = + ::std::option::Option; +pub type ResizeMemoryHandler = + ::std::option::Option *mut ::libc::c_void>; +pub type MagickModuleType = u32; +pub const MagickImageCoderModule: MagickModuleType = 0; +pub const MagickImageFilterModule: MagickModuleType = 1; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _ModuleInfo { + pub path: *mut ::libc::c_char, + pub tag: *mut ::libc::c_char, + pub handle: *mut ::libc::c_void, + pub unregister_module: ::std::option::Option, + pub register_module: ::std::option::Option size_t>, + pub timestamp: time_t, + pub stealth: MagickBooleanType, + pub previous: *mut _ModuleInfo, + pub next: *mut _ModuleInfo, + pub signature: size_t, +} +impl ::std::default::Default for _ModuleInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ModuleInfo = _ModuleInfo; +pub type ImageFilterHandler = + ::std::option::Option size_t>; +pub enum _MimeInfo { } +pub type MimeInfo = _MimeInfo; +pub type MontageMode = u32; +pub const UndefinedMode: MontageMode = 0; +pub const FrameMode: MontageMode = 1; +pub const UnframeMode: MontageMode = 2; +pub const ConcatenateMode: MontageMode = 3; +#[repr(C)] +#[derive(Copy)] +pub struct _MontageInfo { + pub geometry: *mut ::libc::c_char, + pub tile: *mut ::libc::c_char, + pub title: *mut ::libc::c_char, + pub frame: *mut ::libc::c_char, + pub texture: *mut ::libc::c_char, + pub font: *mut ::libc::c_char, + pub pointsize: f64, + pub border_width: size_t, + pub shadow: MagickBooleanType, + pub fill: PixelPacket, + pub stroke: PixelPacket, + pub background_color: PixelPacket, + pub border_color: PixelPacket, + pub matte_color: PixelPacket, + pub gravity: GravityType, + pub filename: [::libc::c_char; 4096usize], + pub debug: MagickBooleanType, + pub signature: size_t, +} +impl ::std::clone::Clone for _MontageInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for _MontageInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type MontageInfo = _MontageInfo; +pub type MagickOpenCLProgram = u32; +pub const MAGICK_OPENCL_ACCELERATE: MagickOpenCLProgram = 0; +pub const MAGICK_OPENCL_NUM_PROGRAMS: MagickOpenCLProgram = 1; +pub type ImageMagickOpenCLMode = u32; +pub const MAGICK_OPENCL_OFF: ImageMagickOpenCLMode = 0; +pub const MAGICK_OPENCL_DEVICE_SELECT_AUTO: ImageMagickOpenCLMode = 1; +pub const MAGICK_OPENCL_DEVICE_SELECT_USER: ImageMagickOpenCLMode = 2; +pub const MAGICK_OPENCL_DEVICE_SELECT_AUTO_CLEAR_CACHE: ImageMagickOpenCLMode + = + 3; +pub type MagickOpenCLEnvParam = u32; +pub const MAGICK_OPENCL_ENV_PARAM_DEVICE: MagickOpenCLEnvParam = 0; +pub const MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED: MagickOpenCLEnvParam = 1; +pub const MAGICK_OPENCL_ENV_PARAM_OPENCL_INITIALIZED: MagickOpenCLEnvParam = + 2; +pub const MAGICK_OPENCL_ENV_PARAM_PROGRAM_CACHE_DISABLED: MagickOpenCLEnvParam + = + 3; +pub const MAGICK_OPENCL_ENV_PARAM_REGENERATE_PROFILE: MagickOpenCLEnvParam = + 4; +pub const MAGICK_OPENCL_ENV_PARAM_PLATFORM_VENDOR: MagickOpenCLEnvParam = 5; +pub const MAGICK_OPENCL_ENV_PARAM_DEVICE_NAME: MagickOpenCLEnvParam = 6; +pub enum _MagickCLEnv { } +pub type MagickCLEnv = *mut _MagickCLEnv; +pub type CommandOption = i32; +pub const MagickUndefinedOptions: CommandOption = -1; +pub const MagickAlignOptions: CommandOption = 0; +pub const MagickAlphaOptions: CommandOption = 1; +pub const MagickBooleanOptions: CommandOption = 2; +pub const MagickCacheOptions: CommandOption = 3; +pub const MagickChannelOptions: CommandOption = 4; +pub const MagickClassOptions: CommandOption = 5; +pub const MagickClipPathOptions: CommandOption = 6; +pub const MagickCoderOptions: CommandOption = 7; +pub const MagickColorOptions: CommandOption = 8; +pub const MagickColorspaceOptions: CommandOption = 9; +pub const MagickCommandOptions: CommandOption = 10; +pub const MagickComposeOptions: CommandOption = 11; +pub const MagickCompressOptions: CommandOption = 12; +pub const MagickConfigureOptions: CommandOption = 13; +pub const MagickDataTypeOptions: CommandOption = 14; +pub const MagickDebugOptions: CommandOption = 15; +pub const MagickDecorateOptions: CommandOption = 16; +pub const MagickDelegateOptions: CommandOption = 17; +pub const MagickDirectionOptions: CommandOption = 18; +pub const MagickDisposeOptions: CommandOption = 19; +pub const MagickDistortOptions: CommandOption = 20; +pub const MagickDitherOptions: CommandOption = 21; +pub const MagickEndianOptions: CommandOption = 22; +pub const MagickEvaluateOptions: CommandOption = 23; +pub const MagickFillRuleOptions: CommandOption = 24; +pub const MagickFilterOptions: CommandOption = 25; +pub const MagickFontOptions: CommandOption = 26; +pub const MagickFontsOptions: CommandOption = 27; +pub const MagickFormatOptions: CommandOption = 28; +pub const MagickFunctionOptions: CommandOption = 29; +pub const MagickGravityOptions: CommandOption = 30; +pub const MagickIntentOptions: CommandOption = 31; +pub const MagickInterlaceOptions: CommandOption = 32; +pub const MagickInterpolateOptions: CommandOption = 33; +pub const MagickKernelOptions: CommandOption = 34; +pub const MagickLayerOptions: CommandOption = 35; +pub const MagickLineCapOptions: CommandOption = 36; +pub const MagickLineJoinOptions: CommandOption = 37; +pub const MagickListOptions: CommandOption = 38; +pub const MagickLocaleOptions: CommandOption = 39; +pub const MagickLogEventOptions: CommandOption = 40; +pub const MagickLogOptions: CommandOption = 41; +pub const MagickMagicOptions: CommandOption = 42; +pub const MagickMethodOptions: CommandOption = 43; +pub const MagickMetricOptions: CommandOption = 44; +pub const MagickMimeOptions: CommandOption = 45; +pub const MagickModeOptions: CommandOption = 46; +pub const MagickModuleOptions: CommandOption = 47; +pub const MagickMorphologyOptions: CommandOption = 48; +pub const MagickNoiseOptions: CommandOption = 49; +pub const MagickOrientationOptions: CommandOption = 50; +pub const MagickPixelIntensityOptions: CommandOption = 51; +pub const MagickPolicyOptions: CommandOption = 52; +pub const MagickPolicyDomainOptions: CommandOption = 53; +pub const MagickPolicyRightsOptions: CommandOption = 54; +pub const MagickPreviewOptions: CommandOption = 55; +pub const MagickPrimitiveOptions: CommandOption = 56; +pub const MagickQuantumFormatOptions: CommandOption = 57; +pub const MagickResolutionOptions: CommandOption = 58; +pub const MagickResourceOptions: CommandOption = 59; +pub const MagickSparseColorOptions: CommandOption = 60; +pub const MagickStatisticOptions: CommandOption = 61; +pub const MagickStorageOptions: CommandOption = 62; +pub const MagickStretchOptions: CommandOption = 63; +pub const MagickStyleOptions: CommandOption = 64; +pub const MagickThresholdOptions: CommandOption = 65; +pub const MagickTypeOptions: CommandOption = 66; +pub const MagickValidateOptions: CommandOption = 67; +pub const MagickVirtualPixelOptions: CommandOption = 68; +pub const MagickComplexOptions: CommandOption = 69; +pub const MagickIntensityOptions: CommandOption = 70; +pub const MagickGradientOptions: CommandOption = 71; +pub const MagickWeightOptions: CommandOption = 72; +pub const MagickComplianceOptions: CommandOption = 73; +pub type ValidateType = u32; +pub const UndefinedValidate: ValidateType = 0; +pub const NoValidate: ValidateType = 0; +pub const ColorspaceValidate: ValidateType = 1; +pub const CompareValidate: ValidateType = 2; +pub const CompositeValidate: ValidateType = 4; +pub const ConvertValidate: ValidateType = 8; +pub const FormatsDiskValidate: ValidateType = 16; +pub const FormatsMapValidate: ValidateType = 32; +pub const FormatsMemoryValidate: ValidateType = 64; +pub const IdentifyValidate: ValidateType = 128; +pub const ImportExportValidate: ValidateType = 256; +pub const MontageValidate: ValidateType = 512; +pub const StreamValidate: ValidateType = 1024; +pub const AllValidate: ValidateType = 2147483647; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _OptionInfo { + pub mnemonic: *const ::libc::c_char, + pub type_: ssize_t, + pub flags: ssize_t, + pub stealth: MagickBooleanType, + _bindgen_padding_0_: [u8; 4usize], +} +impl ::std::default::Default for _OptionInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type OptionInfo = _OptionInfo; +pub type CommandOptionFlags = u32; +pub const UndefinedOptionFlag: CommandOptionFlags = 0; +pub const FireOptionFlag: CommandOptionFlags = 1; +pub const ImageInfoOptionFlag: CommandOptionFlags = 2; +pub const DrawInfoOptionFlag: CommandOptionFlags = 4; +pub const QuantizeInfoOptionFlag: CommandOptionFlags = 8; +pub const GlobalOptionFlag: CommandOptionFlags = 16; +pub const SimpleOperatorOptionFlag: CommandOptionFlags = 256; +pub const ListOperatorOptionFlag: CommandOptionFlags = 512; +pub const SpecialOperatorOptionFlag: CommandOptionFlags = 1024; +pub const GenesisOptionFlag: CommandOptionFlags = 1024; +pub const NonConvertOptionFlag: CommandOptionFlags = 16384; +pub const DeprecateOptionFlag: CommandOptionFlags = 32768; +pub type PolicyDomain = u32; +pub const UndefinedPolicyDomain: PolicyDomain = 0; +pub const CoderPolicyDomain: PolicyDomain = 1; +pub const DelegatePolicyDomain: PolicyDomain = 2; +pub const FilterPolicyDomain: PolicyDomain = 3; +pub const PathPolicyDomain: PolicyDomain = 4; +pub const ResourcePolicyDomain: PolicyDomain = 5; +pub const SystemPolicyDomain: PolicyDomain = 6; +pub const CachePolicyDomain: PolicyDomain = 7; +pub type PolicyRights = u32; +pub const UndefinedPolicyRights: PolicyRights = 0; +pub const NoPolicyRights: PolicyRights = 0; +pub const ReadPolicyRights: PolicyRights = 1; +pub const WritePolicyRights: PolicyRights = 2; +pub const ExecutePolicyRights: PolicyRights = 4; +pub enum _PolicyInfo { } +pub type PolicyInfo = _PolicyInfo; +pub type ResourceType = u32; +pub const UndefinedResource: ResourceType = 0; +pub const AreaResource: ResourceType = 1; +pub const DiskResource: ResourceType = 2; +pub const FileResource: ResourceType = 3; +pub const MapResource: ResourceType = 4; +pub const MemoryResource: ResourceType = 5; +pub const ThreadResource: ResourceType = 6; +pub const TimeResource: ResourceType = 7; +pub const ThrottleResource: ResourceType = 8; +pub const WidthResource: ResourceType = 9; +pub const HeightResource: ResourceType = 10; +pub enum _SplayTreeInfo { } +pub type SplayTreeInfo = _SplayTreeInfo; +pub enum _TokenInfo { } +pub type TokenInfo = _TokenInfo; +pub enum _ThresholdMap { } +pub type ThresholdMap = _ThresholdMap; +pub type PathType = u32; +pub const UndefinedPath: PathType = 0; +pub const MagickPath: PathType = 1; +pub const RootPath: PathType = 2; +pub const HeadPath: PathType = 3; +pub const TailPath: PathType = 4; +pub const BasePath: PathType = 5; +pub const ExtensionPath: PathType = 6; +pub const SubimagePath: PathType = 7; +pub const CanonicalPath: PathType = 8; +pub enum _XMLTreeInfo { } +pub type XMLTreeInfo = _XMLTreeInfo; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct _XImportInfo { + pub frame: MagickBooleanType, + pub borders: MagickBooleanType, + pub screen: MagickBooleanType, + pub descend: MagickBooleanType, + pub silent: MagickBooleanType, +} +impl ::std::default::Default for _XImportInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type XImportInfo = _XImportInfo; +pub enum _PixelWand { } +pub type PixelWand = _PixelWand; +pub enum _DrawingWand { } +pub type DrawingWand = _DrawingWand; +pub enum _PixelIterator { } +pub type PixelIterator = _PixelIterator; +pub type DrawContext = *mut _DrawingWand; +pub enum _PixelView { } +pub type PixelView = _PixelView; +pub type DuplexTransferPixelViewMethod = + ::std::option::Option MagickBooleanType>; +pub type GetPixelViewMethod = + ::std::option::Option MagickBooleanType>; +pub type SetPixelViewMethod = + ::std::option::Option MagickBooleanType>; +pub type TransferPixelViewMethod = + ::std::option::Option MagickBooleanType>; +pub type UpdatePixelViewMethod = + ::std::option::Option MagickBooleanType>; +pub type MagickCommand = + ::std::option::Option MagickBooleanType>; +pub enum _WandView { } +pub type WandView = _WandView; +pub type DuplexTransferWandViewMethod = + ::std::option::Option MagickBooleanType>; +pub type GetWandViewMethod = + ::std::option::Option MagickBooleanType>; +pub type SetWandViewMethod = + ::std::option::Option MagickBooleanType>; +pub type TransferWandViewMethod = + ::std::option::Option MagickBooleanType>; +pub type UpdateWandViewMethod = + ::std::option::Option MagickBooleanType>; +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Copy, Clone)] +#[derive(Debug)] +pub struct __va_list_tag { + pub gp_offset: ::libc::c_uint, + pub fp_offset: ::libc::c_uint, + pub overflow_arg_area: *mut ::libc::c_void, + pub reg_save_area: *mut ::libc::c_void, +} +impl ::std::default::Default for __va_list_tag { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[link(name = "MagickWand-6", kind = "dylib")] +extern "C" { + pub static mut __stdinp: *mut FILE; + pub static mut __stdoutp: *mut FILE; + pub static mut __stderrp: *mut FILE; + pub static sys_nerr: ::libc::c_int; + pub static mut sys_errlist: [*const ::libc::c_char; 0usize]; + pub static mut __mb_cur_max: ::libc::c_int; + pub static mut suboptarg: *mut ::libc::c_char; + pub static mut signgam: ::libc::c_int; + pub static mut tzname: [*mut ::libc::c_char; 0usize]; + pub static mut getdate_err: ::libc::c_int; + pub static mut timezone: ::libc::c_long; + pub static mut daylight: ::libc::c_int; +} +#[link(name = "MagickWand-6", kind = "dylib")] +extern "C" { + pub fn renameat(arg1: ::libc::c_int, arg2: *const ::libc::c_char, + arg3: ::libc::c_int, arg4: *const ::libc::c_char) + -> ::libc::c_int; + pub fn clearerr(arg1: *mut FILE); + pub fn fclose(arg1: *mut FILE) -> ::libc::c_int; + pub fn feof(arg1: *mut FILE) -> ::libc::c_int; + pub fn ferror(arg1: *mut FILE) -> ::libc::c_int; + pub fn fflush(arg1: *mut FILE) -> ::libc::c_int; + pub fn fgetc(arg1: *mut FILE) -> ::libc::c_int; + pub fn fgetpos(arg1: *mut FILE, arg2: *mut fpos_t) -> ::libc::c_int; + pub fn fgets(arg1: *mut ::libc::c_char, arg2: ::libc::c_int, + arg3: *mut FILE) -> *mut ::libc::c_char; + pub fn fopen(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char) + -> *mut FILE; + pub fn fprintf(arg1: *mut FILE, arg2: *const ::libc::c_char, ...) + -> ::libc::c_int; + pub fn fputc(arg1: ::libc::c_int, arg2: *mut FILE) -> ::libc::c_int; + pub fn fputs(arg1: *const ::libc::c_char, arg2: *mut FILE) + -> ::libc::c_int; + pub fn fread(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: *mut FILE) -> size_t; + pub fn freopen(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char, + arg3: *mut FILE) -> *mut FILE; + pub fn fscanf(arg1: *mut FILE, arg2: *const ::libc::c_char, ...) + -> ::libc::c_int; + pub fn fseek(arg1: *mut FILE, arg2: ::libc::c_long, arg3: ::libc::c_int) + -> ::libc::c_int; + pub fn fsetpos(arg1: *mut FILE, arg2: *const fpos_t) -> ::libc::c_int; + pub fn ftell(arg1: *mut FILE) -> ::libc::c_long; + pub fn fwrite(arg1: *const ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: *mut FILE) -> size_t; + pub fn getc(arg1: *mut FILE) -> ::libc::c_int; + pub fn getchar() -> ::libc::c_int; + pub fn gets(arg1: *mut ::libc::c_char) -> *mut ::libc::c_char; + pub fn perror(arg1: *const ::libc::c_char); + pub fn printf(arg1: *const ::libc::c_char, ...) -> ::libc::c_int; + pub fn putc(arg1: ::libc::c_int, arg2: *mut FILE) -> ::libc::c_int; + pub fn putchar(arg1: ::libc::c_int) -> ::libc::c_int; + pub fn puts(arg1: *const ::libc::c_char) -> ::libc::c_int; + pub fn remove(arg1: *const ::libc::c_char) -> ::libc::c_int; + pub fn rename(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char) + -> ::libc::c_int; + pub fn rewind(arg1: *mut FILE); + pub fn scanf(arg1: *const ::libc::c_char, ...) -> ::libc::c_int; + pub fn setbuf(arg1: *mut FILE, arg2: *mut ::libc::c_char); + pub fn setvbuf(arg1: *mut FILE, arg2: *mut ::libc::c_char, + arg3: ::libc::c_int, arg4: size_t) -> ::libc::c_int; + pub fn sprintf(arg1: *mut ::libc::c_char, + arg2: *const ::libc::c_char, ...) -> ::libc::c_int; + pub fn sscanf(arg1: *const ::libc::c_char, + arg2: *const ::libc::c_char, ...) -> ::libc::c_int; + pub fn tmpfile() -> *mut FILE; + pub fn tmpnam(arg1: *mut ::libc::c_char) -> *mut ::libc::c_char; + pub fn ungetc(arg1: ::libc::c_int, arg2: *mut FILE) -> ::libc::c_int; + pub fn vfprintf(arg1: *mut FILE, arg2: *const ::libc::c_char, + arg3: va_list) -> ::libc::c_int; + pub fn vprintf(arg1: *const ::libc::c_char, arg2: va_list) + -> ::libc::c_int; + pub fn vsprintf(arg1: *mut ::libc::c_char, arg2: *const ::libc::c_char, + arg3: va_list) -> ::libc::c_int; + pub fn ctermid(arg1: *mut ::libc::c_char) -> *mut ::libc::c_char; + pub fn fdopen(arg1: ::libc::c_int, arg2: *const ::libc::c_char) + -> *mut FILE; + pub fn fileno(arg1: *mut FILE) -> ::libc::c_int; + pub fn pclose(arg1: *mut FILE) -> ::libc::c_int; + pub fn popen(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char) + -> *mut FILE; + pub fn __srget(arg1: *mut FILE) -> ::libc::c_int; + pub fn __svfscanf(arg1: *mut FILE, arg2: *const ::libc::c_char, + arg3: va_list) -> ::libc::c_int; + pub fn __swbuf(arg1: ::libc::c_int, arg2: *mut FILE) -> ::libc::c_int; + pub fn __sputc(_c: ::libc::c_int, _p: *mut FILE) -> ::libc::c_int; + pub fn flockfile(arg1: *mut FILE); + pub fn ftrylockfile(arg1: *mut FILE) -> ::libc::c_int; + pub fn funlockfile(arg1: *mut FILE); + pub fn getc_unlocked(arg1: *mut FILE) -> ::libc::c_int; + pub fn getchar_unlocked() -> ::libc::c_int; + pub fn putc_unlocked(arg1: ::libc::c_int, arg2: *mut FILE) + -> ::libc::c_int; + pub fn putchar_unlocked(arg1: ::libc::c_int) -> ::libc::c_int; + pub fn getw(arg1: *mut FILE) -> ::libc::c_int; + pub fn putw(arg1: ::libc::c_int, arg2: *mut FILE) -> ::libc::c_int; + pub fn tempnam(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn fseeko(arg1: *mut FILE, arg2: off_t, arg3: ::libc::c_int) + -> ::libc::c_int; + pub fn ftello(arg1: *mut FILE) -> off_t; + pub fn snprintf(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: *const ::libc::c_char, ...) -> ::libc::c_int; + pub fn vfscanf(arg1: *mut FILE, arg2: *const ::libc::c_char, + arg3: va_list) -> ::libc::c_int; + pub fn vscanf(arg1: *const ::libc::c_char, arg2: va_list) + -> ::libc::c_int; + pub fn vsnprintf(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: *const ::libc::c_char, arg4: va_list) + -> ::libc::c_int; + pub fn vsscanf(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char, + arg3: va_list) -> ::libc::c_int; + pub fn dprintf(arg1: ::libc::c_int, arg2: *const ::libc::c_char, ...) + -> ::libc::c_int; + pub fn vdprintf(arg1: ::libc::c_int, arg2: *const ::libc::c_char, + arg3: va_list) -> ::libc::c_int; + pub fn getdelim(arg1: *mut *mut ::libc::c_char, arg2: *mut size_t, + arg3: ::libc::c_int, arg4: *mut FILE) -> ssize_t; + pub fn getline(arg1: *mut *mut ::libc::c_char, arg2: *mut size_t, + arg3: *mut FILE) -> ssize_t; + pub fn asprintf(arg1: *mut *mut ::libc::c_char, + arg2: *const ::libc::c_char, ...) -> ::libc::c_int; + pub fn ctermid_r(arg1: *mut ::libc::c_char) -> *mut ::libc::c_char; + pub fn fgetln(arg1: *mut FILE, arg2: *mut size_t) -> *mut ::libc::c_char; + pub fn fmtcheck(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn fpurge(arg1: *mut FILE) -> ::libc::c_int; + pub fn setbuffer(arg1: *mut FILE, arg2: *mut ::libc::c_char, + arg3: ::libc::c_int); + pub fn setlinebuf(arg1: *mut FILE) -> ::libc::c_int; + pub fn vasprintf(arg1: *mut *mut ::libc::c_char, + arg2: *const ::libc::c_char, arg3: va_list) + -> ::libc::c_int; + pub fn zopen(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char, + arg3: ::libc::c_int) -> *mut FILE; + pub fn funopen(arg1: *const ::libc::c_void, + arg2: + ::std::option::Option ::libc::c_int>, + arg3: + ::std::option::Option ::libc::c_int>, + arg4: + ::std::option::Option fpos_t>, + arg5: + ::std::option::Option ::libc::c_int>) + -> *mut FILE; + pub fn __sprintf_chk(arg1: *mut ::libc::c_char, arg2: ::libc::c_int, + arg3: size_t, arg4: *const ::libc::c_char, ...) + -> ::libc::c_int; + pub fn __snprintf_chk(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: ::libc::c_int, arg4: size_t, + arg5: *const ::libc::c_char, ...) -> ::libc::c_int; + pub fn __vsprintf_chk(arg1: *mut ::libc::c_char, arg2: ::libc::c_int, + arg3: size_t, arg4: *const ::libc::c_char, + arg5: va_list) -> ::libc::c_int; + pub fn __vsnprintf_chk(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: ::libc::c_int, arg4: size_t, + arg5: *const ::libc::c_char, arg6: va_list) + -> ::libc::c_int; + pub fn signal(arg1: ::libc::c_int, + arg2: + ::std::option::Option) + -> + ::std::option::Option)>; + pub fn getpriority(arg1: ::libc::c_int, arg2: id_t) -> ::libc::c_int; + pub fn getiopolicy_np(arg1: ::libc::c_int, arg2: ::libc::c_int) + -> ::libc::c_int; + pub fn getrlimit(arg1: ::libc::c_int, arg2: *mut rlimit) -> ::libc::c_int; + pub fn getrusage(arg1: ::libc::c_int, arg2: *mut rusage) -> ::libc::c_int; + pub fn setpriority(arg1: ::libc::c_int, arg2: id_t, arg3: ::libc::c_int) + -> ::libc::c_int; + pub fn setiopolicy_np(arg1: ::libc::c_int, arg2: ::libc::c_int, + arg3: ::libc::c_int) -> ::libc::c_int; + pub fn setrlimit(arg1: ::libc::c_int, arg2: *const rlimit) + -> ::libc::c_int; + pub fn wait(arg1: *mut ::libc::c_int) -> pid_t; + pub fn waitpid(arg1: pid_t, arg2: *mut ::libc::c_int, arg3: ::libc::c_int) + -> pid_t; + pub fn waitid(arg1: idtype_t, arg2: id_t, arg3: *mut siginfo_t, + arg4: ::libc::c_int) -> ::libc::c_int; + pub fn wait3(arg1: *mut ::libc::c_int, arg2: ::libc::c_int, + arg3: *mut rusage) -> pid_t; + pub fn wait4(arg1: pid_t, arg2: *mut ::libc::c_int, arg3: ::libc::c_int, + arg4: *mut rusage) -> pid_t; + pub fn alloca(arg1: size_t) -> *mut ::libc::c_void; + pub fn abort(); + pub fn abs(arg1: ::libc::c_int) -> ::libc::c_int; + pub fn atexit(arg1: ::std::option::Option) + -> ::libc::c_int; + pub fn atof(arg1: *const ::libc::c_char) -> f64; + pub fn atoi(arg1: *const ::libc::c_char) -> ::libc::c_int; + pub fn atol(arg1: *const ::libc::c_char) -> ::libc::c_long; + pub fn atoll(arg1: *const ::libc::c_char) -> ::libc::c_longlong; + pub fn bsearch(arg1: *const ::libc::c_void, arg2: *const ::libc::c_void, + arg3: size_t, arg4: size_t, + arg5: + ::std::option::Option ::libc::c_int>) + -> *mut ::libc::c_void; + pub fn calloc(arg1: size_t, arg2: size_t) -> *mut ::libc::c_void; + pub fn div(arg1: ::libc::c_int, arg2: ::libc::c_int) -> div_t; + pub fn exit(arg1: ::libc::c_int); + pub fn free(arg1: *mut ::libc::c_void); + pub fn getenv(arg1: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn labs(arg1: ::libc::c_long) -> ::libc::c_long; + pub fn ldiv(arg1: ::libc::c_long, arg2: ::libc::c_long) -> ldiv_t; + pub fn llabs(arg1: ::libc::c_longlong) -> ::libc::c_longlong; + pub fn lldiv(arg1: ::libc::c_longlong, arg2: ::libc::c_longlong) + -> lldiv_t; + pub fn malloc(arg1: size_t) -> *mut ::libc::c_void; + pub fn mblen(arg1: *const ::libc::c_char, arg2: size_t) -> ::libc::c_int; + pub fn mbstowcs(arg1: *mut wchar_t, arg2: *const ::libc::c_char, + arg3: size_t) -> size_t; + pub fn mbtowc(arg1: *mut wchar_t, arg2: *const ::libc::c_char, + arg3: size_t) -> ::libc::c_int; + pub fn posix_memalign(arg1: *mut *mut ::libc::c_void, arg2: size_t, + arg3: size_t) -> ::libc::c_int; + pub fn qsort(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: + ::std::option::Option ::libc::c_int>); + pub fn rand() -> ::libc::c_int; + pub fn realloc(arg1: *mut ::libc::c_void, arg2: size_t) + -> *mut ::libc::c_void; + pub fn srand(arg1: ::libc::c_uint); + pub fn strtod(arg1: *const ::libc::c_char, arg2: *mut *mut ::libc::c_char) + -> f64; + pub fn strtof(arg1: *const ::libc::c_char, arg2: *mut *mut ::libc::c_char) + -> f32; + pub fn strtol(arg1: *const ::libc::c_char, arg2: *mut *mut ::libc::c_char, + arg3: ::libc::c_int) -> ::libc::c_long; + pub fn strtold(arg1: *const ::libc::c_char, + arg2: *mut *mut ::libc::c_char) -> f64; + pub fn strtoll(arg1: *const ::libc::c_char, + arg2: *mut *mut ::libc::c_char, arg3: ::libc::c_int) + -> ::libc::c_longlong; + pub fn strtoul(arg1: *const ::libc::c_char, + arg2: *mut *mut ::libc::c_char, arg3: ::libc::c_int) + -> ::libc::c_ulong; + pub fn strtoull(arg1: *const ::libc::c_char, + arg2: *mut *mut ::libc::c_char, arg3: ::libc::c_int) + -> ::libc::c_ulonglong; + pub fn system(arg1: *const ::libc::c_char) -> ::libc::c_int; + pub fn wcstombs(arg1: *mut ::libc::c_char, arg2: *const wchar_t, + arg3: size_t) -> size_t; + pub fn wctomb(arg1: *mut ::libc::c_char, arg2: wchar_t) -> ::libc::c_int; + pub fn _Exit(arg1: ::libc::c_int); + pub fn a64l(arg1: *const ::libc::c_char) -> ::libc::c_long; + pub fn drand48() -> f64; + pub fn ecvt(arg1: f64, arg2: ::libc::c_int, arg3: *mut ::libc::c_int, + arg4: *mut ::libc::c_int) -> *mut ::libc::c_char; + pub fn erand48(arg1: *mut ::libc::c_ushort) -> f64; + pub fn fcvt(arg1: f64, arg2: ::libc::c_int, arg3: *mut ::libc::c_int, + arg4: *mut ::libc::c_int) -> *mut ::libc::c_char; + pub fn gcvt(arg1: f64, arg2: ::libc::c_int, arg3: *mut ::libc::c_char) + -> *mut ::libc::c_char; + pub fn getsubopt(arg1: *mut *mut ::libc::c_char, + arg2: *const *mut ::libc::c_char, + arg3: *mut *mut ::libc::c_char) -> ::libc::c_int; + pub fn grantpt(arg1: ::libc::c_int) -> ::libc::c_int; + pub fn initstate(arg1: ::libc::c_uint, arg2: *mut ::libc::c_char, + arg3: size_t) -> *mut ::libc::c_char; + pub fn jrand48(arg1: *mut ::libc::c_ushort) -> ::libc::c_long; + pub fn l64a(arg1: ::libc::c_long) -> *mut ::libc::c_char; + pub fn lcong48(arg1: *mut ::libc::c_ushort); + pub fn lrand48() -> ::libc::c_long; + pub fn mktemp(arg1: *mut ::libc::c_char) -> *mut ::libc::c_char; + pub fn mkstemp(arg1: *mut ::libc::c_char) -> ::libc::c_int; + pub fn mrand48() -> ::libc::c_long; + pub fn nrand48(arg1: *mut ::libc::c_ushort) -> ::libc::c_long; + pub fn posix_openpt(arg1: ::libc::c_int) -> ::libc::c_int; + pub fn ptsname(arg1: ::libc::c_int) -> *mut ::libc::c_char; + pub fn putenv(arg1: *mut ::libc::c_char) -> ::libc::c_int; + pub fn random() -> ::libc::c_long; + pub fn rand_r(arg1: *mut ::libc::c_uint) -> ::libc::c_int; + pub fn realpath(arg1: *const ::libc::c_char, arg2: *mut ::libc::c_char) + -> *mut ::libc::c_char; + pub fn seed48(arg1: *mut ::libc::c_ushort) -> *mut ::libc::c_ushort; + pub fn setenv(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char, + arg3: ::libc::c_int) -> ::libc::c_int; + pub fn setkey(arg1: *const ::libc::c_char); + pub fn setstate(arg1: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn srand48(arg1: ::libc::c_long); + pub fn srandom(arg1: ::libc::c_uint); + pub fn unlockpt(arg1: ::libc::c_int) -> ::libc::c_int; + pub fn unsetenv(arg1: *const ::libc::c_char) -> ::libc::c_int; + pub fn arc4random() -> u_int32_t; + pub fn arc4random_addrandom(arg1: *mut ::libc::c_uchar, + arg2: ::libc::c_int); + pub fn arc4random_buf(arg1: *mut ::libc::c_void, arg2: size_t); + pub fn arc4random_stir(); + pub fn arc4random_uniform(arg1: u_int32_t) -> u_int32_t; + pub fn cgetcap(arg1: *mut ::libc::c_char, arg2: *const ::libc::c_char, + arg3: ::libc::c_int) -> *mut ::libc::c_char; + pub fn cgetclose() -> ::libc::c_int; + pub fn cgetent(arg1: *mut *mut ::libc::c_char, + arg2: *mut *mut ::libc::c_char, + arg3: *const ::libc::c_char) -> ::libc::c_int; + pub fn cgetfirst(arg1: *mut *mut ::libc::c_char, + arg2: *mut *mut ::libc::c_char) -> ::libc::c_int; + pub fn cgetmatch(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char) + -> ::libc::c_int; + pub fn cgetnext(arg1: *mut *mut ::libc::c_char, + arg2: *mut *mut ::libc::c_char) -> ::libc::c_int; + pub fn cgetnum(arg1: *mut ::libc::c_char, arg2: *const ::libc::c_char, + arg3: *mut ::libc::c_long) -> ::libc::c_int; + pub fn cgetset(arg1: *const ::libc::c_char) -> ::libc::c_int; + pub fn cgetstr(arg1: *mut ::libc::c_char, arg2: *const ::libc::c_char, + arg3: *mut *mut ::libc::c_char) -> ::libc::c_int; + pub fn cgetustr(arg1: *mut ::libc::c_char, arg2: *const ::libc::c_char, + arg3: *mut *mut ::libc::c_char) -> ::libc::c_int; + pub fn daemon(arg1: ::libc::c_int, arg2: ::libc::c_int) -> ::libc::c_int; + pub fn devname(arg1: dev_t, arg2: mode_t) -> *mut ::libc::c_char; + pub fn devname_r(arg1: dev_t, arg2: mode_t, buf: *mut ::libc::c_char, + len: ::libc::c_int) -> *mut ::libc::c_char; + pub fn getbsize(arg1: *mut ::libc::c_int, arg2: *mut ::libc::c_long) + -> *mut ::libc::c_char; + pub fn getloadavg(arg1: *mut f64, arg2: ::libc::c_int) -> ::libc::c_int; + pub fn getprogname() -> *const ::libc::c_char; + pub fn heapsort(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: + ::std::option::Option ::libc::c_int>) + -> ::libc::c_int; + pub fn mergesort(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: + ::std::option::Option ::libc::c_int>) + -> ::libc::c_int; + pub fn psort(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: + ::std::option::Option ::libc::c_int>); + pub fn psort_r(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: *mut ::libc::c_void, + arg5: + ::std::option::Option ::libc::c_int>); + pub fn qsort_r(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: *mut ::libc::c_void, + arg5: + ::std::option::Option ::libc::c_int>); + pub fn radixsort(arg1: *mut *const ::libc::c_uchar, arg2: ::libc::c_int, + arg3: *const ::libc::c_uchar, arg4: ::libc::c_uint) + -> ::libc::c_int; + pub fn setprogname(arg1: *const ::libc::c_char); + pub fn sradixsort(arg1: *mut *const ::libc::c_uchar, arg2: ::libc::c_int, + arg3: *const ::libc::c_uchar, arg4: ::libc::c_uint) + -> ::libc::c_int; + pub fn sranddev(); + pub fn srandomdev(); + pub fn reallocf(arg1: *mut ::libc::c_void, arg2: size_t) + -> *mut ::libc::c_void; + pub fn strtoq(arg1: *const ::libc::c_char, arg2: *mut *mut ::libc::c_char, + arg3: ::libc::c_int) -> ::libc::c_longlong; + pub fn strtouq(arg1: *const ::libc::c_char, + arg2: *mut *mut ::libc::c_char, arg3: ::libc::c_int) + -> ::libc::c_ulonglong; + pub fn valloc(arg1: size_t) -> *mut ::libc::c_void; + pub fn __math_errhandling() -> ::libc::c_int; + pub fn __fpclassifyf(arg1: f32) -> ::libc::c_int; + pub fn __fpclassifyd(arg1: f64) -> ::libc::c_int; + pub fn __fpclassifyl(arg1: f64) -> ::libc::c_int; + pub fn __inline_isfinitef(__x: f32) -> ::libc::c_int; + pub fn __inline_isfinited(__x: f64) -> ::libc::c_int; + pub fn __inline_isfinitel(__x: f64) -> ::libc::c_int; + pub fn __inline_isinff(__x: f32) -> ::libc::c_int; + pub fn __inline_isinfd(__x: f64) -> ::libc::c_int; + pub fn __inline_isinfl(__x: f64) -> ::libc::c_int; + pub fn __inline_isnanf(__x: f32) -> ::libc::c_int; + pub fn __inline_isnand(__x: f64) -> ::libc::c_int; + pub fn __inline_isnanl(__x: f64) -> ::libc::c_int; + pub fn __inline_isnormalf(__x: f32) -> ::libc::c_int; + pub fn __inline_isnormald(__x: f64) -> ::libc::c_int; + pub fn __inline_isnormall(__x: f64) -> ::libc::c_int; + pub fn __inline_signbitf(__x: f32) -> ::libc::c_int; + pub fn __inline_signbitd(__x: f64) -> ::libc::c_int; + pub fn __inline_signbitl(__x: f64) -> ::libc::c_int; + pub fn acosf(arg1: f32) -> f32; + pub fn acos(arg1: f64) -> f64; + pub fn acosl(arg1: f64) -> f64; + pub fn asinf(arg1: f32) -> f32; + pub fn asin(arg1: f64) -> f64; + pub fn asinl(arg1: f64) -> f64; + pub fn atanf(arg1: f32) -> f32; + pub fn atan(arg1: f64) -> f64; + pub fn atanl(arg1: f64) -> f64; + pub fn atan2f(arg1: f32, arg2: f32) -> f32; + pub fn atan2(arg1: f64, arg2: f64) -> f64; + pub fn atan2l(arg1: f64, arg2: f64) -> f64; + pub fn cosf(arg1: f32) -> f32; + pub fn cos(arg1: f64) -> f64; + pub fn cosl(arg1: f64) -> f64; + pub fn sinf(arg1: f32) -> f32; + pub fn sin(arg1: f64) -> f64; + pub fn sinl(arg1: f64) -> f64; + pub fn tanf(arg1: f32) -> f32; + pub fn tan(arg1: f64) -> f64; + pub fn tanl(arg1: f64) -> f64; + pub fn acoshf(arg1: f32) -> f32; + pub fn acosh(arg1: f64) -> f64; + pub fn acoshl(arg1: f64) -> f64; + pub fn asinhf(arg1: f32) -> f32; + pub fn asinh(arg1: f64) -> f64; + pub fn asinhl(arg1: f64) -> f64; + pub fn atanhf(arg1: f32) -> f32; + pub fn atanh(arg1: f64) -> f64; + pub fn atanhl(arg1: f64) -> f64; + pub fn coshf(arg1: f32) -> f32; + pub fn cosh(arg1: f64) -> f64; + pub fn coshl(arg1: f64) -> f64; + pub fn sinhf(arg1: f32) -> f32; + pub fn sinh(arg1: f64) -> f64; + pub fn sinhl(arg1: f64) -> f64; + pub fn tanhf(arg1: f32) -> f32; + pub fn tanh(arg1: f64) -> f64; + pub fn tanhl(arg1: f64) -> f64; + pub fn expf(arg1: f32) -> f32; + pub fn exp(arg1: f64) -> f64; + pub fn expl(arg1: f64) -> f64; + pub fn exp2f(arg1: f32) -> f32; + pub fn exp2(arg1: f64) -> f64; + pub fn exp2l(arg1: f64) -> f64; + pub fn expm1f(arg1: f32) -> f32; + pub fn expm1(arg1: f64) -> f64; + pub fn expm1l(arg1: f64) -> f64; + pub fn logf(arg1: f32) -> f32; + pub fn log(arg1: f64) -> f64; + pub fn logl(arg1: f64) -> f64; + pub fn log10f(arg1: f32) -> f32; + pub fn log10(arg1: f64) -> f64; + pub fn log10l(arg1: f64) -> f64; + pub fn log2f(arg1: f32) -> f32; + pub fn log2(arg1: f64) -> f64; + pub fn log2l(arg1: f64) -> f64; + pub fn log1pf(arg1: f32) -> f32; + pub fn log1p(arg1: f64) -> f64; + pub fn log1pl(arg1: f64) -> f64; + pub fn logbf(arg1: f32) -> f32; + pub fn logb(arg1: f64) -> f64; + pub fn logbl(arg1: f64) -> f64; + pub fn modff(arg1: f32, arg2: *mut f32) -> f32; + pub fn modf(arg1: f64, arg2: *mut f64) -> f64; + pub fn modfl(arg1: f64, arg2: *mut f64) -> f64; + pub fn ldexpf(arg1: f32, arg2: ::libc::c_int) -> f32; + pub fn ldexp(arg1: f64, arg2: ::libc::c_int) -> f64; + pub fn ldexpl(arg1: f64, arg2: ::libc::c_int) -> f64; + pub fn frexpf(arg1: f32, arg2: *mut ::libc::c_int) -> f32; + pub fn frexp(arg1: f64, arg2: *mut ::libc::c_int) -> f64; + pub fn frexpl(arg1: f64, arg2: *mut ::libc::c_int) -> f64; + pub fn ilogbf(arg1: f32) -> ::libc::c_int; + pub fn ilogb(arg1: f64) -> ::libc::c_int; + pub fn ilogbl(arg1: f64) -> ::libc::c_int; + pub fn scalbnf(arg1: f32, arg2: ::libc::c_int) -> f32; + pub fn scalbn(arg1: f64, arg2: ::libc::c_int) -> f64; + pub fn scalbnl(arg1: f64, arg2: ::libc::c_int) -> f64; + pub fn scalblnf(arg1: f32, arg2: ::libc::c_long) -> f32; + pub fn scalbln(arg1: f64, arg2: ::libc::c_long) -> f64; + pub fn scalblnl(arg1: f64, arg2: ::libc::c_long) -> f64; + pub fn fabsf(arg1: f32) -> f32; + pub fn fabs(arg1: f64) -> f64; + pub fn fabsl(arg1: f64) -> f64; + pub fn cbrtf(arg1: f32) -> f32; + pub fn cbrt(arg1: f64) -> f64; + pub fn cbrtl(arg1: f64) -> f64; + pub fn hypotf(arg1: f32, arg2: f32) -> f32; + pub fn hypot(arg1: f64, arg2: f64) -> f64; + pub fn hypotl(arg1: f64, arg2: f64) -> f64; + pub fn powf(arg1: f32, arg2: f32) -> f32; + pub fn pow(arg1: f64, arg2: f64) -> f64; + pub fn powl(arg1: f64, arg2: f64) -> f64; + pub fn sqrtf(arg1: f32) -> f32; + pub fn sqrt(arg1: f64) -> f64; + pub fn sqrtl(arg1: f64) -> f64; + pub fn erff(arg1: f32) -> f32; + pub fn erf(arg1: f64) -> f64; + pub fn erfl(arg1: f64) -> f64; + pub fn erfcf(arg1: f32) -> f32; + pub fn erfc(arg1: f64) -> f64; + pub fn erfcl(arg1: f64) -> f64; + pub fn lgammaf(arg1: f32) -> f32; + pub fn lgamma(arg1: f64) -> f64; + pub fn lgammal(arg1: f64) -> f64; + pub fn tgammaf(arg1: f32) -> f32; + pub fn tgamma(arg1: f64) -> f64; + pub fn tgammal(arg1: f64) -> f64; + pub fn ceilf(arg1: f32) -> f32; + pub fn ceil(arg1: f64) -> f64; + pub fn ceill(arg1: f64) -> f64; + pub fn floorf(arg1: f32) -> f32; + pub fn floor(arg1: f64) -> f64; + pub fn floorl(arg1: f64) -> f64; + pub fn nearbyintf(arg1: f32) -> f32; + pub fn nearbyint(arg1: f64) -> f64; + pub fn nearbyintl(arg1: f64) -> f64; + pub fn rintf(arg1: f32) -> f32; + pub fn rint(arg1: f64) -> f64; + pub fn rintl(arg1: f64) -> f64; + pub fn lrintf(arg1: f32) -> ::libc::c_long; + pub fn lrint(arg1: f64) -> ::libc::c_long; + pub fn lrintl(arg1: f64) -> ::libc::c_long; + pub fn roundf(arg1: f32) -> f32; + pub fn round(arg1: f64) -> f64; + pub fn roundl(arg1: f64) -> f64; + pub fn lroundf(arg1: f32) -> ::libc::c_long; + pub fn lround(arg1: f64) -> ::libc::c_long; + pub fn lroundl(arg1: f64) -> ::libc::c_long; + pub fn llrintf(arg1: f32) -> ::libc::c_longlong; + pub fn llrint(arg1: f64) -> ::libc::c_longlong; + pub fn llrintl(arg1: f64) -> ::libc::c_longlong; + pub fn llroundf(arg1: f32) -> ::libc::c_longlong; + pub fn llround(arg1: f64) -> ::libc::c_longlong; + pub fn llroundl(arg1: f64) -> ::libc::c_longlong; + pub fn truncf(arg1: f32) -> f32; + pub fn trunc(arg1: f64) -> f64; + pub fn truncl(arg1: f64) -> f64; + pub fn fmodf(arg1: f32, arg2: f32) -> f32; + pub fn fmod(arg1: f64, arg2: f64) -> f64; + pub fn fmodl(arg1: f64, arg2: f64) -> f64; + pub fn remainderf(arg1: f32, arg2: f32) -> f32; + pub fn remainder(arg1: f64, arg2: f64) -> f64; + pub fn remainderl(arg1: f64, arg2: f64) -> f64; + pub fn remquof(arg1: f32, arg2: f32, arg3: *mut ::libc::c_int) -> f32; + pub fn remquo(arg1: f64, arg2: f64, arg3: *mut ::libc::c_int) -> f64; + pub fn remquol(arg1: f64, arg2: f64, arg3: *mut ::libc::c_int) -> f64; + pub fn copysignf(arg1: f32, arg2: f32) -> f32; + pub fn copysign(arg1: f64, arg2: f64) -> f64; + pub fn copysignl(arg1: f64, arg2: f64) -> f64; + pub fn nanf(arg1: *const ::libc::c_char) -> f32; + pub fn nan(arg1: *const ::libc::c_char) -> f64; + pub fn nanl(arg1: *const ::libc::c_char) -> f64; + pub fn nextafterf(arg1: f32, arg2: f32) -> f32; + pub fn nextafter(arg1: f64, arg2: f64) -> f64; + pub fn nextafterl(arg1: f64, arg2: f64) -> f64; + pub fn nexttoward(arg1: f64, arg2: f64) -> f64; + pub fn nexttowardf(arg1: f32, arg2: f64) -> f32; + pub fn nexttowardl(arg1: f64, arg2: f64) -> f64; + pub fn fdimf(arg1: f32, arg2: f32) -> f32; + pub fn fdim(arg1: f64, arg2: f64) -> f64; + pub fn fdiml(arg1: f64, arg2: f64) -> f64; + pub fn fmaxf(arg1: f32, arg2: f32) -> f32; + pub fn fmax(arg1: f64, arg2: f64) -> f64; + pub fn fmaxl(arg1: f64, arg2: f64) -> f64; + pub fn fminf(arg1: f32, arg2: f32) -> f32; + pub fn fmin(arg1: f64, arg2: f64) -> f64; + pub fn fminl(arg1: f64, arg2: f64) -> f64; + pub fn fmaf(arg1: f32, arg2: f32, arg3: f32) -> f32; + pub fn fma(arg1: f64, arg2: f64, arg3: f64) -> f64; + pub fn fmal(arg1: f64, arg2: f64, arg3: f64) -> f64; + pub fn __inff() -> f32; + pub fn __inf() -> f64; + pub fn __infl() -> f64; + pub fn __nan() -> f32; + pub fn __exp10f(arg1: f32) -> f32; + pub fn __exp10(arg1: f64) -> f64; + pub fn __sincosf(__x: f32, __sinp: *mut f32, __cosp: *mut f32); + pub fn __sincos(__x: f64, __sinp: *mut f64, __cosp: *mut f64); + pub fn __cospif(arg1: f32) -> f32; + pub fn __cospi(arg1: f64) -> f64; + pub fn __sinpif(arg1: f32) -> f32; + pub fn __sinpi(arg1: f64) -> f64; + pub fn __tanpif(arg1: f32) -> f32; + pub fn __tanpi(arg1: f64) -> f64; + pub fn __sincospif(__x: f32, __sinp: *mut f32, __cosp: *mut f32); + pub fn __sincospi(__x: f64, __sinp: *mut f64, __cosp: *mut f64); + pub fn __sincosf_stret(arg1: f32) -> __float2; + pub fn __sincos_stret(arg1: f64) -> __double2; + pub fn __sincospif_stret(arg1: f32) -> __float2; + pub fn __sincospi_stret(arg1: f64) -> __double2; + pub fn j0(arg1: f64) -> f64; + pub fn j1(arg1: f64) -> f64; + pub fn jn(arg1: ::libc::c_int, arg2: f64) -> f64; + pub fn y0(arg1: f64) -> f64; + pub fn y1(arg1: f64) -> f64; + pub fn yn(arg1: ::libc::c_int, arg2: f64) -> f64; + pub fn scalb(arg1: f64, arg2: f64) -> f64; + pub fn rinttol(arg1: f64) -> ::libc::c_long; + pub fn roundtol(arg1: f64) -> ::libc::c_long; + pub fn drem(arg1: f64, arg2: f64) -> f64; + pub fn finite(arg1: f64) -> ::libc::c_int; + pub fn gamma(arg1: f64) -> f64; + pub fn significand(arg1: f64) -> f64; + pub fn matherr(arg1: *mut exception) -> ::libc::c_int; + pub fn asctime(arg1: *const tm) -> *mut ::libc::c_char; + pub fn clock() -> clock_t; + pub fn ctime(arg1: *const time_t) -> *mut ::libc::c_char; + pub fn difftime(arg1: time_t, arg2: time_t) -> f64; + pub fn getdate(arg1: *const ::libc::c_char) -> *mut tm; + pub fn gmtime(arg1: *const time_t) -> *mut tm; + pub fn localtime(arg1: *const time_t) -> *mut tm; + pub fn mktime(arg1: *mut tm) -> time_t; + pub fn strftime(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: *const ::libc::c_char, arg4: *const tm) -> size_t; + pub fn strptime(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char, + arg3: *mut tm) -> *mut ::libc::c_char; + pub fn time(arg1: *mut time_t) -> time_t; + pub fn tzset(); + pub fn asctime_r(arg1: *const tm, arg2: *mut ::libc::c_char) + -> *mut ::libc::c_char; + pub fn ctime_r(arg1: *const time_t, arg2: *mut ::libc::c_char) + -> *mut ::libc::c_char; + pub fn gmtime_r(arg1: *const time_t, arg2: *mut tm) -> *mut tm; + pub fn localtime_r(arg1: *const time_t, arg2: *mut tm) -> *mut tm; + pub fn posix2time(arg1: time_t) -> time_t; + pub fn tzsetwall(); + pub fn time2posix(arg1: time_t) -> time_t; + pub fn timelocal(arg1: *mut tm) -> time_t; + pub fn timegm(arg1: *mut tm) -> time_t; + pub fn nanosleep(arg1: *const timespec, arg2: *mut timespec) + -> ::libc::c_int; + pub fn GetPageGeometry(arg1: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn IsGeometry(arg1: *const ::libc::c_char) -> MagickBooleanType; + pub fn IsSceneGeometry(arg1: *const ::libc::c_char, + arg2: MagickBooleanType) -> MagickBooleanType; + pub fn GetGeometry(arg1: *const ::libc::c_char, arg2: *mut ssize_t, + arg3: *mut ssize_t, arg4: *mut size_t, + arg5: *mut size_t) -> MagickStatusType; + pub fn ParseAbsoluteGeometry(arg1: *const ::libc::c_char, + arg2: *mut RectangleInfo) + -> MagickStatusType; + pub fn ParseAffineGeometry(arg1: *const ::libc::c_char, + arg2: *mut AffineMatrix, + arg3: *mut ExceptionInfo) -> MagickStatusType; + pub fn ParseGeometry(arg1: *const ::libc::c_char, arg2: *mut GeometryInfo) + -> MagickStatusType; + pub fn ParseGravityGeometry(arg1: *const Image, + arg2: *const ::libc::c_char, + arg3: *mut RectangleInfo, + arg4: *mut ExceptionInfo) -> MagickStatusType; + pub fn ParseMetaGeometry(arg1: *const ::libc::c_char, arg2: *mut ssize_t, + arg3: *mut ssize_t, arg4: *mut size_t, + arg5: *mut size_t) -> MagickStatusType; + pub fn ParsePageGeometry(arg1: *const Image, arg2: *const ::libc::c_char, + arg3: *mut RectangleInfo, + arg4: *mut ExceptionInfo) -> MagickStatusType; + pub fn ParseRegionGeometry(arg1: *const Image, + arg2: *const ::libc::c_char, + arg3: *mut RectangleInfo, + arg4: *mut ExceptionInfo) -> MagickStatusType; + pub fn GravityAdjustGeometry(arg1: size_t, arg2: size_t, + arg3: GravityType, arg4: *mut RectangleInfo); + pub fn SetGeometry(arg1: *const Image, arg2: *mut RectangleInfo); + pub fn SetGeometryInfo(arg1: *mut GeometryInfo); + pub fn RGBTransformImage(arg1: *mut Image, arg2: ColorspaceType) + -> MagickBooleanType; + pub fn SetImageColorspace(arg1: *mut Image, arg2: ColorspaceType) + -> MagickBooleanType; + pub fn SetImageGray(arg1: *mut Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn SetImageMonochrome(arg1: *mut Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn TransformImageColorspace(arg1: *mut Image, arg2: ColorspaceType) + -> MagickBooleanType; + pub fn TransformRGBImage(arg1: *mut Image, arg2: ColorspaceType) + -> MagickBooleanType; + pub fn ConstituteImage(arg1: size_t, arg2: size_t, + arg3: *const ::libc::c_char, arg4: StorageType, + arg5: *const ::libc::c_void, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn PingImage(arg1: *const ImageInfo, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn PingImages(arg1: *const ImageInfo, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn ReadImage(arg1: *const ImageInfo, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn ReadImages(arg1: *const ImageInfo, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn ReadInlineImage(arg1: *const ImageInfo, + arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn WriteImage(arg1: *const ImageInfo, arg2: *mut Image) + -> MagickBooleanType; + pub fn WriteImages(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *const ::libc::c_char, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ExportImagePixels(arg1: *const Image, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t, + arg6: *const ::libc::c_char, arg7: StorageType, + arg8: *mut ::libc::c_void, + arg9: *mut ExceptionInfo) -> MagickBooleanType; + pub fn ImportImagePixels(arg1: *mut Image, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t, + arg6: *const ::libc::c_char, arg7: StorageType, + arg8: *const ::libc::c_void) + -> MagickBooleanType; + pub fn InterpolateMagickPixelPacket(arg1: *const Image, + arg2: *const CacheView_, + arg3: InterpolatePixelMethod, + arg4: f64, arg5: f64, + arg6: *mut MagickPixelPacket, + arg7: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn CloneMagickPixelPacket(arg1: *const MagickPixelPacket) + -> *mut MagickPixelPacket; + pub fn DecodePixelGamma(arg1: MagickRealType) -> MagickRealType; + pub fn EncodePixelGamma(arg1: MagickRealType) -> MagickRealType; + pub fn GetMagickPixelIntensity(image: *const Image, + arg1: *const MagickPixelPacket) + -> MagickRealType; + pub fn GetPixelIntensity(image: *const Image, arg1: *const PixelPacket) + -> MagickRealType; + pub fn ConformMagickPixelPacket(arg1: *mut Image, + arg2: *const MagickPixelPacket, + arg3: *mut MagickPixelPacket, + arg4: *mut ExceptionInfo); + pub fn GetMagickPixelPacket(arg1: *const Image, + arg2: *mut MagickPixelPacket); + pub fn SemaphoreComponentGenesis() -> MagickBooleanType; + pub fn AllocateSemaphoreInfo() -> *mut SemaphoreInfo; + pub fn ActivateSemaphoreInfo(arg1: *mut *mut SemaphoreInfo); + pub fn DestroySemaphoreInfo(arg1: *mut *mut SemaphoreInfo); + pub fn LockSemaphoreInfo(arg1: *mut SemaphoreInfo); + pub fn SemaphoreComponentTerminus(); + pub fn UnlockSemaphoreInfo(arg1: *mut SemaphoreInfo); + pub fn GetExceptionMessage(arg1: ::libc::c_int) -> *mut ::libc::c_char; + pub fn GetLocaleExceptionMessage(arg1: ExceptionType, + arg2: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn SetErrorHandler(arg1: ErrorHandler) -> ErrorHandler; + pub fn AcquireExceptionInfo() -> *mut ExceptionInfo; + pub fn CloneExceptionInfo(arg1: *mut ExceptionInfo) -> *mut ExceptionInfo; + pub fn DestroyExceptionInfo(arg1: *mut ExceptionInfo) + -> *mut ExceptionInfo; + pub fn SetFatalErrorHandler(arg1: FatalErrorHandler) -> FatalErrorHandler; + pub fn ThrowException(arg1: *mut ExceptionInfo, arg2: ExceptionType, + arg3: *const ::libc::c_char, + arg4: *const ::libc::c_char) -> MagickBooleanType; + pub fn ThrowMagickException(arg1: *mut ExceptionInfo, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, arg4: size_t, + arg5: ExceptionType, + arg6: *const ::libc::c_char, + arg7: *const ::libc::c_char, ...) + -> MagickBooleanType; + pub fn ThrowMagickExceptionList(arg1: *mut ExceptionInfo, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, arg4: size_t, + arg5: ExceptionType, + arg6: *const ::libc::c_char, + arg7: *const ::libc::c_char, + arg8: va_list) -> MagickBooleanType; + pub fn CatchException(arg1: *mut ExceptionInfo); + pub fn ClearMagickException(arg1: *mut ExceptionInfo); + pub fn InheritException(arg1: *mut ExceptionInfo, + arg2: *const ExceptionInfo); + pub fn MagickError(arg1: ExceptionType, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char); + pub fn MagickFatalError(arg1: ExceptionType, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char); + pub fn MagickWarning(arg1: ExceptionType, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char); + pub fn SetWarningHandler(arg1: WarningHandler) -> WarningHandler; + pub fn GetColorList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *mut ::libc::c_char; + pub fn GetColorInfo(arg1: *const ::libc::c_char, arg2: *mut ExceptionInfo) + -> *const ColorInfo; + pub fn GetColorInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *const ColorInfo; + pub fn ColorComponentGenesis() -> MagickBooleanType; + pub fn IsColorSimilar(arg1: *const Image, arg2: *const PixelPacket, + arg3: *const PixelPacket) -> MagickBooleanType; + pub fn IsImageSimilar(arg1: *const Image, arg2: *const Image, + x: *mut ssize_t, y: *mut ssize_t, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn IsMagickColorSimilar(arg1: *const MagickPixelPacket, + arg2: *const MagickPixelPacket) + -> MagickBooleanType; + pub fn IsOpacitySimilar(arg1: *const Image, arg2: *const PixelPacket, + arg3: *const PixelPacket) -> MagickBooleanType; + pub fn ListColorInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn QueryColorCompliance(arg1: *const ::libc::c_char, + arg2: ComplianceType, arg3: *mut PixelPacket, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn QueryColorDatabase(arg1: *const ::libc::c_char, + arg2: *mut PixelPacket, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn QueryColorname(arg1: *const Image, arg2: *const PixelPacket, + arg3: ComplianceType, arg4: *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn QueryMagickColorCompliance(arg1: *const ::libc::c_char, + arg2: ComplianceType, + arg3: *mut MagickPixelPacket, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn QueryMagickColor(arg1: *const ::libc::c_char, + arg2: *mut MagickPixelPacket, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn QueryMagickColorname(arg1: *const Image, + arg2: *const MagickPixelPacket, + arg3: ComplianceType, + arg4: *mut ::libc::c_char, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ColorComponentTerminus(); + pub fn ConcatenateColorComponent(arg1: *const MagickPixelPacket, + arg2: ChannelType, arg3: ComplianceType, + arg4: *mut ::libc::c_char); + pub fn GetColorTuple(arg1: *const MagickPixelPacket, + arg2: MagickBooleanType, arg3: *mut ::libc::c_char); + pub fn ReadStream(arg1: *const ImageInfo, arg2: StreamHandler, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn WriteStream(arg1: *const ImageInfo, arg2: *mut Image, + arg3: StreamHandler) -> MagickBooleanType; + pub fn GetBlobFileHandle(arg1: *const Image) -> *mut FILE; + pub fn BlobToImage(arg1: *const ImageInfo, arg2: *const ::libc::c_void, + arg3: size_t, arg4: *mut ExceptionInfo) -> *mut Image; + pub fn PingBlob(arg1: *const ImageInfo, arg2: *const ::libc::c_void, + arg3: size_t, arg4: *mut ExceptionInfo) -> *mut Image; + pub fn BlobToFile(arg1: *mut ::libc::c_char, arg2: *const ::libc::c_void, + arg3: size_t, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn FileToImage(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn GetBlobError(arg1: *const Image) -> MagickBooleanType; + pub fn ImageToFile(arg1: *mut Image, arg2: *mut ::libc::c_char, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn InjectImageBlob(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *mut Image, arg4: *const ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn IsBlobExempt(arg1: *const Image) -> MagickBooleanType; + pub fn IsBlobSeekable(arg1: *const Image) -> MagickBooleanType; + pub fn IsBlobTemporary(arg1: *const Image) -> MagickBooleanType; + pub fn GetBlobSize(arg1: *const Image) -> MagickSizeType; + pub fn GetBlobStreamHandler(arg1: *const Image) -> StreamHandler; + pub fn FileToBlob(arg1: *const ::libc::c_char, arg2: size_t, + arg3: *mut size_t, arg4: *mut ExceptionInfo) + -> *mut ::libc::c_uchar; + pub fn GetBlobStreamData(arg1: *const Image) -> *mut ::libc::c_uchar; + pub fn ImageToBlob(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *mut size_t, arg4: *mut ExceptionInfo) + -> *mut ::libc::c_uchar; + pub fn ImagesToBlob(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *mut size_t, arg4: *mut ExceptionInfo) + -> *mut ::libc::c_uchar; + pub fn DestroyBlob(arg1: *mut Image); + pub fn DuplicateBlob(arg1: *mut Image, arg2: *const Image); + pub fn SetBlobExempt(arg1: *mut Image, arg2: MagickBooleanType); + pub fn AcquireAuthenticCacheView(arg1: *const Image, + arg2: *mut ExceptionInfo) + -> *mut CacheView; + pub fn AcquireCacheView(arg1: *const Image) -> *mut CacheView; + pub fn AcquireVirtualCacheView(arg1: *const Image, + arg2: *mut ExceptionInfo) + -> *mut CacheView; + pub fn CloneCacheView(arg1: *const CacheView) -> *mut CacheView; + pub fn DestroyCacheView(arg1: *mut CacheView) -> *mut CacheView; + pub fn GetCacheViewStorageClass(arg1: *const CacheView) -> ClassType; + pub fn GetCacheViewColorspace(arg1: *const CacheView) -> ColorspaceType; + pub fn GetCacheViewVirtualIndexQueue(arg1: *const CacheView) + -> *const IndexPacket; + pub fn GetCacheViewVirtualPixels(arg1: *const CacheView, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, + arg5: size_t, arg6: *mut ExceptionInfo) + -> *const PixelPacket; + pub fn GetCacheViewVirtualPixelQueue(arg1: *const CacheView) + -> *const PixelPacket; + pub fn GetCacheViewException(arg1: *const CacheView) + -> *mut ExceptionInfo; + pub fn GetCacheViewAuthenticIndexQueue(arg1: *mut CacheView) + -> *mut IndexPacket; + pub fn GetOneCacheViewAuthenticPixel(arg1: *const CacheView, + arg2: ssize_t, arg3: ssize_t, + arg4: *mut PixelPacket, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetOneCacheViewVirtualMethodPixel(arg1: *const CacheView, + arg2: VirtualPixelMethod, + arg3: ssize_t, arg4: ssize_t, + arg5: *mut PixelPacket, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetOneCacheViewVirtualPixel(arg1: *const CacheView, arg2: ssize_t, + arg3: ssize_t, arg4: *mut PixelPacket, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn SetCacheViewStorageClass(arg1: *mut CacheView, arg2: ClassType) + -> MagickBooleanType; + pub fn SetCacheViewVirtualPixelMethod(arg1: *mut CacheView, + arg2: VirtualPixelMethod) + -> MagickBooleanType; + pub fn SyncCacheViewAuthenticPixels(arg1: *mut CacheView, + arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetCacheViewExtent(arg1: *const CacheView) -> MagickSizeType; + pub fn GetCacheViewChannels(arg1: *const CacheView) -> size_t; + pub fn GetCacheViewAuthenticPixelQueue(arg1: *mut CacheView) + -> *mut PixelPacket; + pub fn GetCacheViewAuthenticPixels(arg1: *mut CacheView, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, + arg5: size_t, arg6: *mut ExceptionInfo) + -> *mut PixelPacket; + pub fn QueueCacheViewAuthenticPixels(arg1: *mut CacheView, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, + arg5: size_t, + arg6: *mut ExceptionInfo) + -> *mut PixelPacket; + pub fn CompositeImage(arg1: *mut Image, arg2: CompositeOperator, + arg3: *const Image, arg4: ssize_t, arg5: ssize_t) + -> MagickBooleanType; + pub fn CompositeImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: CompositeOperator, arg4: *const Image, + arg5: ssize_t, arg6: ssize_t) + -> MagickBooleanType; + pub fn TextureImage(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn HuffmanDecodeImage(arg1: *mut Image) -> MagickBooleanType; + pub fn HuffmanEncodeImage(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *mut Image) -> MagickBooleanType; + pub fn LZWEncodeImage(arg1: *mut Image, arg2: size_t, + arg3: *mut ::libc::c_uchar) -> MagickBooleanType; + pub fn PackbitsEncodeImage(arg1: *mut Image, arg2: size_t, + arg3: *mut ::libc::c_uchar) + -> MagickBooleanType; + pub fn ZLIBEncodeImage(arg1: *mut Image, arg2: size_t, + arg3: *mut ::libc::c_uchar) -> MagickBooleanType; + pub fn Ascii85Encode(arg1: *mut Image, arg2: ::libc::c_uchar); + pub fn Ascii85Flush(arg1: *mut Image); + pub fn Ascii85Initialize(arg1: *mut Image); + pub fn AcquireKernelInfo(arg1: *const ::libc::c_char) -> *mut KernelInfo; + pub fn AcquireKernelBuiltIn(arg1: KernelInfoType, + arg2: *const GeometryInfo) -> *mut KernelInfo; + pub fn CloneKernelInfo(arg1: *const KernelInfo) -> *mut KernelInfo; + pub fn DestroyKernelInfo(arg1: *mut KernelInfo) -> *mut KernelInfo; + pub fn MorphologyImage(arg1: *const Image, arg2: MorphologyMethod, + arg3: ssize_t, arg4: *const KernelInfo, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn MorphologyImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: MorphologyMethod, arg4: ssize_t, + arg5: *const KernelInfo, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn ScaleGeometryKernelInfo(arg1: *mut KernelInfo, + arg2: *const ::libc::c_char); + pub fn ScaleKernelInfo(arg1: *mut KernelInfo, arg2: f64, + arg3: GeometryFlags); + pub fn ShowKernelInfo(arg1: *const KernelInfo); + pub fn UnityAddKernelInfo(arg1: *mut KernelInfo, arg2: f64); + pub fn AdaptiveBlurImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn AdaptiveBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn AdaptiveSharpenImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn AdaptiveSharpenImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, + arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn BlurImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn BlurImageChannel(arg1: *const Image, arg2: ChannelType, arg3: f64, + arg4: f64, arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn ConvolveImage(arg1: *const Image, arg2: size_t, arg3: *const f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ConvolveImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: size_t, arg4: *const f64, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn DespeckleImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn EdgeImage(arg1: *const Image, arg2: f64, arg3: *mut ExceptionInfo) + -> *mut Image; + pub fn EmbossImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn FilterImage(arg1: *const Image, arg2: *const KernelInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn FilterImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: *const KernelInfo, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn GaussianBlurImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn GaussianBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn KuwaharaImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn KuwaharaImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn LocalContrastImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn MotionBlurImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: f64, arg5: *mut ExceptionInfo) -> *mut Image; + pub fn MotionBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, arg5: f64, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn PreviewImage(arg1: *const Image, arg2: PreviewType, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn RotationalBlurImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn RotationalBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn SelectiveBlurImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: f64, arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn SelectiveBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, arg5: f64, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn ShadeImage(arg1: *const Image, arg2: MagickBooleanType, arg3: f64, + arg4: f64, arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SharpenImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn SharpenImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn SpreadImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn UnsharpMaskImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: f64, arg5: f64, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn UnsharpMaskImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, arg5: f64, arg6: f64, + arg7: *mut ExceptionInfo) -> *mut Image; + pub fn CoalesceImages(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn DisposeImages(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn CompareImageLayers(arg1: *const Image, arg2: ImageLayerMethod, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn DeconstructImages(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn MergeImageLayers(arg1: *mut Image, arg2: ImageLayerMethod, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn OptimizeImageLayers(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn OptimizePlusImageLayers(arg1: *const Image, + arg2: *mut ExceptionInfo) -> *mut Image; + pub fn CompositeLayers(arg1: *mut Image, arg2: CompositeOperator, + arg3: *mut Image, arg4: ssize_t, arg5: ssize_t, + arg6: *mut ExceptionInfo); + pub fn OptimizeImageTransparency(arg1: *const Image, + arg2: *mut ExceptionInfo); + pub fn RemoveDuplicateLayers(arg1: *mut *mut Image, + arg2: *mut ExceptionInfo); + pub fn RemoveZeroDelayLayers(arg1: *mut *mut Image, + arg2: *mut ExceptionInfo); + pub fn DestroyHashmap(arg1: *mut HashmapInfo) -> *mut HashmapInfo; + pub fn NewHashmap(arg1: size_t, + arg2: + ::std::option::Option size_t>, + arg3: + ::std::option::Option MagickBooleanType>, + arg4: + ::std::option::Option *mut ::libc::c_void>, + arg5: + ::std::option::Option *mut ::libc::c_void>) + -> *mut HashmapInfo; + pub fn DestroyLinkedList(arg1: *mut LinkedListInfo, + arg2: + ::std::option::Option + *mut ::libc::c_void>) + -> *mut LinkedListInfo; + pub fn NewLinkedList(arg1: size_t) -> *mut LinkedListInfo; + pub fn AppendValueToLinkedList(arg1: *mut LinkedListInfo, + arg2: *const ::libc::c_void) + -> MagickBooleanType; + pub fn CompareHashmapString(arg1: *const ::libc::c_void, + arg2: *const ::libc::c_void) + -> MagickBooleanType; + pub fn CompareHashmapStringInfo(arg1: *const ::libc::c_void, + arg2: *const ::libc::c_void) + -> MagickBooleanType; + pub fn InsertValueInLinkedList(arg1: *mut LinkedListInfo, arg2: size_t, + arg3: *const ::libc::c_void) + -> MagickBooleanType; + pub fn InsertValueInSortedLinkedList(arg1: *mut LinkedListInfo, + arg2: + ::std::option::Option + ::libc::c_int>, + arg3: *mut *mut ::libc::c_void, + arg4: *const ::libc::c_void) + -> MagickBooleanType; + pub fn IsHashmapEmpty(arg1: *const HashmapInfo) -> MagickBooleanType; + pub fn IsLinkedListEmpty(arg1: *const LinkedListInfo) + -> MagickBooleanType; + pub fn LinkedListToArray(arg1: *mut LinkedListInfo, + arg2: *mut *mut ::libc::c_void) + -> MagickBooleanType; + pub fn PutEntryInHashmap(arg1: *mut HashmapInfo, + arg2: *const ::libc::c_void, + arg3: *const ::libc::c_void) + -> MagickBooleanType; + pub fn GetNumberOfElementsInLinkedList(arg1: *const LinkedListInfo) + -> size_t; + pub fn GetNumberOfEntriesInHashmap(arg1: *const HashmapInfo) -> size_t; + pub fn HashPointerType(arg1: *const ::libc::c_void) -> size_t; + pub fn HashStringType(arg1: *const ::libc::c_void) -> size_t; + pub fn HashStringInfoType(arg1: *const ::libc::c_void) -> size_t; + pub fn ClearLinkedList(arg1: *mut LinkedListInfo, + arg2: + ::std::option::Option + *mut ::libc::c_void>); + pub fn GetLastValueInLinkedList(arg1: *mut LinkedListInfo) + -> *mut ::libc::c_void; + pub fn GetNextKeyInHashmap(arg1: *mut HashmapInfo) -> *mut ::libc::c_void; + pub fn GetNextValueInHashmap(arg1: *mut HashmapInfo) + -> *mut ::libc::c_void; + pub fn GetNextValueInLinkedList(arg1: *mut LinkedListInfo) + -> *mut ::libc::c_void; + pub fn GetValueFromHashmap(arg1: *mut HashmapInfo, + arg2: *const ::libc::c_void) + -> *mut ::libc::c_void; + pub fn GetValueFromLinkedList(arg1: *mut LinkedListInfo, arg2: size_t) + -> *mut ::libc::c_void; + pub fn RemoveElementByValueFromLinkedList(arg1: *mut LinkedListInfo, + arg2: *const ::libc::c_void) + -> *mut ::libc::c_void; + pub fn RemoveElementFromLinkedList(arg1: *mut LinkedListInfo, + arg2: size_t) -> *mut ::libc::c_void; + pub fn RemoveEntryFromHashmap(arg1: *mut HashmapInfo, + arg2: *const ::libc::c_void) + -> *mut ::libc::c_void; + pub fn RemoveLastElementFromLinkedList(arg1: *mut LinkedListInfo) + -> *mut ::libc::c_void; + pub fn ResetHashmapIterator(arg1: *mut HashmapInfo); + pub fn ResetLinkedListIterator(arg1: *mut LinkedListInfo); + pub fn GetLocaleList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *mut ::libc::c_char; + pub fn GetLocaleMessage(arg1: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn GetLocaleInfo_(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) -> *const LocaleInfo; + pub fn GetLocaleInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *const LocaleInfo; + pub fn InterpretLocaleValue(arg1: *const ::libc::c_char, + arg2: *mut *mut ::libc::c_char) -> f64; + pub fn LocaleCompare(arg1: *const ::libc::c_char, + arg2: *const ::libc::c_char) -> ::libc::c_int; + pub fn LocaleNCompare(arg1: *const ::libc::c_char, + arg2: *const ::libc::c_char, arg3: size_t) + -> ::libc::c_int; + pub fn DestroyLocaleOptions(arg1: *mut LinkedListInfo) + -> *mut LinkedListInfo; + pub fn GetLocaleOptions(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) -> *mut LinkedListInfo; + pub fn ListLocaleInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn LocaleComponentGenesis() -> MagickBooleanType; + pub fn FormatLocaleFile(arg1: *mut FILE, arg2: *const ::libc::c_char, ...) + -> ssize_t; + pub fn FormatLocaleFileList(arg1: *mut FILE, arg2: *const ::libc::c_char, + arg3: va_list) -> ssize_t; + pub fn FormatLocaleString(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: *const ::libc::c_char, ...) -> ssize_t; + pub fn FormatLocaleStringList(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: *const ::libc::c_char, arg4: va_list) + -> ssize_t; + pub fn LocaleComponentTerminus(); + pub fn LocaleLower(arg1: *mut ::libc::c_char); + pub fn LocaleUpper(arg1: *mut ::libc::c_char); + pub fn SetImageProgressMonitor(arg1: *mut Image, + arg2: MagickProgressMonitor, + arg3: *mut ::libc::c_void) + -> MagickProgressMonitor; + pub fn SetImageInfoProgressMonitor(arg1: *mut ImageInfo, + arg2: MagickProgressMonitor, + arg3: *mut ::libc::c_void) + -> MagickProgressMonitor; + pub fn AcquireString(arg1: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn CloneString(arg1: *mut *mut ::libc::c_char, + arg2: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn ConstantString(arg1: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn DestroyString(arg1: *mut ::libc::c_char) -> *mut ::libc::c_char; + pub fn DestroyStringList(arg1: *mut *mut ::libc::c_char) + -> *mut *mut ::libc::c_char; + pub fn EscapeString(arg1: *const ::libc::c_char, arg2: ::libc::c_char) + -> *mut ::libc::c_char; + pub fn FileToString(arg1: *const ::libc::c_char, arg2: size_t, + arg3: *mut ExceptionInfo) -> *mut ::libc::c_char; + pub fn GetEnvironmentValue(arg1: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn SanitizeString(arg1: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn StringInfoToHexString(arg1: *const StringInfo) + -> *mut ::libc::c_char; + pub fn StringInfoToString(arg1: *const StringInfo) -> *mut ::libc::c_char; + pub fn StringToArgv(arg1: *const ::libc::c_char, arg2: *mut ::libc::c_int) + -> *mut *mut ::libc::c_char; + pub fn StringToken(arg1: *const ::libc::c_char, + arg2: *mut *mut ::libc::c_char) -> *mut ::libc::c_char; + pub fn StringToList(arg1: *const ::libc::c_char) + -> *mut *mut ::libc::c_char; + pub fn GetStringInfoPath(arg1: *const StringInfo) + -> *const ::libc::c_char; + pub fn InterpretSiPrefixValue(arg1: *const ::libc::c_char, + arg2: *mut *mut ::libc::c_char) -> f64; + pub fn StringToArrayOfDoubles(arg1: *const ::libc::c_char, + arg2: *mut ssize_t, + arg3: *mut ExceptionInfo) -> *mut f64; + pub fn CompareStringInfo(arg1: *const StringInfo, arg2: *const StringInfo) + -> ::libc::c_int; + pub fn ConcatenateString(arg1: *mut *mut ::libc::c_char, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn IsStringTrue(arg1: *const ::libc::c_char) -> MagickBooleanType; + pub fn IsStringNotFalse(arg1: *const ::libc::c_char) -> MagickBooleanType; + pub fn SubstituteString(arg1: *mut *mut ::libc::c_char, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) -> MagickBooleanType; + pub fn ConcatenateMagickString(arg1: *mut ::libc::c_char, + arg2: *const ::libc::c_char, arg3: size_t) + -> size_t; + pub fn CopyMagickString(arg1: *mut ::libc::c_char, + arg2: *const ::libc::c_char, arg3: size_t) + -> size_t; + pub fn GetStringInfoLength(arg1: *const StringInfo) -> size_t; + pub fn FormatMagickSize(arg1: MagickSizeType, arg2: MagickBooleanType, + arg3: *mut ::libc::c_char) -> ssize_t; + pub fn FormatMagickTime(arg1: time_t, arg2: size_t, + arg3: *mut ::libc::c_char) -> ssize_t; + pub fn AcquireStringInfo(arg1: size_t) -> *mut StringInfo; + pub fn BlobToStringInfo(arg1: *const ::libc::c_void, arg2: size_t) + -> *mut StringInfo; + pub fn CloneStringInfo(arg1: *const StringInfo) -> *mut StringInfo; + pub fn ConfigureFileToStringInfo(arg1: *const ::libc::c_char) + -> *mut StringInfo; + pub fn DestroyStringInfo(arg1: *mut StringInfo) -> *mut StringInfo; + pub fn FileToStringInfo(arg1: *const ::libc::c_char, arg2: size_t, + arg3: *mut ExceptionInfo) -> *mut StringInfo; + pub fn SplitStringInfo(arg1: *mut StringInfo, arg2: size_t) + -> *mut StringInfo; + pub fn StringToStringInfo(arg1: *const ::libc::c_char) -> *mut StringInfo; + pub fn GetStringInfoDatum(arg1: *const StringInfo) + -> *mut ::libc::c_uchar; + pub fn ConcatenateStringInfo(arg1: *mut StringInfo, + arg2: *const StringInfo); + pub fn PrintStringInfo(file: *mut FILE, arg1: *const ::libc::c_char, + arg2: *const StringInfo); + pub fn ResetStringInfo(arg1: *mut StringInfo); + pub fn SetStringInfo(arg1: *mut StringInfo, arg2: *const StringInfo); + pub fn SetStringInfoDatum(arg1: *mut StringInfo, + arg2: *const ::libc::c_uchar); + pub fn SetStringInfoLength(arg1: *mut StringInfo, arg2: size_t); + pub fn SetStringInfoPath(arg1: *mut StringInfo, + arg2: *const ::libc::c_char); + pub fn StripString(arg1: *mut ::libc::c_char); + pub fn GetNextImageProfile(arg1: *const Image) -> *mut ::libc::c_char; + pub fn GetImageProfile(arg1: *const Image, arg2: *const ::libc::c_char) + -> *const StringInfo; + pub fn CloneImageProfiles(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn DeleteImageProfile(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn ProfileImage(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_void, arg4: size_t, + arg5: MagickBooleanType) -> MagickBooleanType; + pub fn SetImageProfile(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *const StringInfo) -> MagickBooleanType; + pub fn SyncImageProfiles(arg1: *mut Image) -> MagickBooleanType; + pub fn RemoveImageProfile(arg1: *mut Image, arg2: *const ::libc::c_char) + -> *mut StringInfo; + pub fn DestroyImageProfiles(arg1: *mut Image); + pub fn ResetImageProfileIterator(arg1: *const Image); + pub fn GetQuantumEndian(arg1: *const QuantumInfo) -> EndianType; + pub fn SetQuantumDepth(arg1: *const Image, arg2: *mut QuantumInfo, + arg3: size_t) -> MagickBooleanType; + pub fn SetQuantumEndian(arg1: *const Image, arg2: *mut QuantumInfo, + arg3: EndianType) -> MagickBooleanType; + pub fn SetQuantumFormat(arg1: *const Image, arg2: *mut QuantumInfo, + arg3: QuantumFormatType) -> MagickBooleanType; + pub fn SetQuantumPad(arg1: *const Image, arg2: *mut QuantumInfo, + arg3: size_t) -> MagickBooleanType; + pub fn GetQuantumFormat(arg1: *const QuantumInfo) -> QuantumFormatType; + pub fn AcquireQuantumInfo(arg1: *const ImageInfo, arg2: *mut Image) + -> *mut QuantumInfo; + pub fn DestroyQuantumInfo(arg1: *mut QuantumInfo) -> *mut QuantumInfo; + pub fn GetQuantumType(arg1: *mut Image, arg2: *mut ExceptionInfo) + -> QuantumType; + pub fn ExportQuantumPixels(arg1: *const Image, arg2: *const CacheView, + arg3: *const QuantumInfo, arg4: QuantumType, + arg5: *mut ::libc::c_uchar, + arg6: *mut ExceptionInfo) -> size_t; + pub fn GetQuantumExtent(arg1: *const Image, arg2: *const QuantumInfo, + arg3: QuantumType) -> size_t; + pub fn ImportQuantumPixels(arg1: *mut Image, arg2: *mut CacheView, + arg3: *const QuantumInfo, arg4: QuantumType, + arg5: *const ::libc::c_uchar, + arg6: *mut ExceptionInfo) -> size_t; + pub fn GetQuantumPixels(arg1: *const QuantumInfo) -> *mut ::libc::c_uchar; + pub fn GetQuantumInfo(arg1: *const ImageInfo, arg2: *mut QuantumInfo); + pub fn SetQuantumAlphaType(arg1: *mut QuantumInfo, + arg2: QuantumAlphaType); + pub fn SetQuantumImageType(arg1: *mut Image, arg2: QuantumType); + pub fn SetQuantumMinIsWhite(arg1: *mut QuantumInfo, + arg2: MagickBooleanType); + pub fn SetQuantumPack(arg1: *mut QuantumInfo, arg2: MagickBooleanType); + pub fn SetQuantumQuantum(arg1: *mut QuantumInfo, arg2: size_t); + pub fn SetQuantumScale(arg1: *mut QuantumInfo, arg2: f64); + pub fn ResamplePixelColor(arg1: *mut ResampleFilter, arg2: f64, arg3: f64, + arg4: *mut MagickPixelPacket) + -> MagickBooleanType; + pub fn SetResampleFilterInterpolateMethod(arg1: *mut ResampleFilter, + arg2: InterpolatePixelMethod) + -> MagickBooleanType; + pub fn SetResampleFilterVirtualPixelMethod(arg1: *mut ResampleFilter, + arg2: VirtualPixelMethod) + -> MagickBooleanType; + pub fn AcquireResampleFilter(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut ResampleFilter; + pub fn DestroyResampleFilter(arg1: *mut ResampleFilter) + -> *mut ResampleFilter; + pub fn ScaleResampleFilter(arg1: *mut ResampleFilter, arg2: f64, + arg3: f64, arg4: f64, arg5: f64); + pub fn SetResampleFilter(arg1: *mut ResampleFilter, arg2: FilterTypes, + arg3: f64); + pub fn AdaptiveResizeImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn InterpolativeResizeImage(arg1: *const Image, arg2: size_t, + arg3: size_t, + arg4: InterpolatePixelMethod, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn LiquidRescaleImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: f64, arg5: f64, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn MagnifyImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn MinifyImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn ResampleImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: FilterTypes, arg5: f64, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn ResizeImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: FilterTypes, arg5: f64, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn SampleImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ScaleImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ThumbnailImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn GetElapsedTime(arg1: *mut TimerInfo) -> f64; + pub fn GetUserTime(arg1: *mut TimerInfo) -> f64; + pub fn ContinueTimer(arg1: *mut TimerInfo) -> MagickBooleanType; + pub fn AcquireTimerInfo() -> *mut TimerInfo; + pub fn DestroyTimerInfo(arg1: *mut TimerInfo) -> *mut TimerInfo; + pub fn GetTimerInfo(arg1: *mut TimerInfo); + pub fn ResetTimer(arg1: *mut TimerInfo); + pub fn StartTimer(arg1: *mut TimerInfo, arg2: MagickBooleanType); + pub fn CatchImageException(arg1: *mut Image) -> ExceptionType; + pub fn GetImageInfoFile(arg1: *const ImageInfo) -> *mut FILE; + pub fn AcquireImage(arg1: *const ImageInfo) -> *mut Image; + pub fn AppendImages(arg1: *const Image, arg2: MagickBooleanType, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn CloneImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: MagickBooleanType, arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn DestroyImage(arg1: *mut Image) -> *mut Image; + pub fn GetImageClipMask(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn GetImageMask(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn NewMagickImage(arg1: *const ImageInfo, arg2: size_t, arg3: size_t, + arg4: *const MagickPixelPacket) -> *mut Image; + pub fn ReferenceImage(arg1: *mut Image) -> *mut Image; + pub fn SmushImages(arg1: *const Image, arg2: MagickBooleanType, + arg3: ssize_t, arg4: *mut ExceptionInfo) -> *mut Image; + pub fn AcquireImageInfo() -> *mut ImageInfo; + pub fn CloneImageInfo(arg1: *const ImageInfo) -> *mut ImageInfo; + pub fn DestroyImageInfo(arg1: *mut ImageInfo) -> *mut ImageInfo; + pub fn ClipImage(arg1: *mut Image) -> MagickBooleanType; + pub fn ClipImagePath(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn CopyImagePixels(arg1: *mut Image, arg2: *const Image, + arg3: *const RectangleInfo, + arg4: *const OffsetInfo, arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn IsTaintImage(arg1: *const Image) -> MagickBooleanType; + pub fn IsMagickConflict(arg1: *const ::libc::c_char) -> MagickBooleanType; + pub fn IsHighDynamicRangeImage(arg1: *const Image, + arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn IsImageObject(arg1: *const Image) -> MagickBooleanType; + pub fn ListMagickInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ModifyImage(arg1: *mut *mut Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ResetImagePage(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn SetImageBackgroundColor(arg1: *mut Image) -> MagickBooleanType; + pub fn SetImageClipMask(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn SetImageColor(arg1: *mut Image, arg2: *const MagickPixelPacket) + -> MagickBooleanType; + pub fn SetImageExtent(arg1: *mut Image, arg2: size_t, arg3: size_t) + -> MagickBooleanType; + pub fn SetImageInfo(arg1: *mut ImageInfo, arg2: ::libc::c_uint, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn SetImageMask(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn SetImageOpacity(arg1: *mut Image, arg2: Quantum) + -> MagickBooleanType; + pub fn SetImageChannels(arg1: *mut Image, arg2: size_t) + -> MagickBooleanType; + pub fn SetImageStorageClass(arg1: *mut Image, arg2: ClassType) + -> MagickBooleanType; + pub fn StripImage(arg1: *mut Image) -> MagickBooleanType; + pub fn SyncImage(arg1: *mut Image) -> MagickBooleanType; + pub fn SyncImageSettings(arg1: *const ImageInfo, arg2: *mut Image) + -> MagickBooleanType; + pub fn SyncImagesSettings(arg1: *mut ImageInfo, arg2: *mut Image) + -> MagickBooleanType; + pub fn InterpretImageFilename(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *const ::libc::c_char, + arg4: ::libc::c_int, + arg5: *mut ::libc::c_char) -> size_t; + pub fn GetImageReferenceCount(arg1: *mut Image) -> ssize_t; + pub fn GetImageChannels(arg1: *mut Image) -> size_t; + pub fn GetImageVirtualPixelMethod(arg1: *const Image) + -> VirtualPixelMethod; + pub fn SetImageVirtualPixelMethod(arg1: *const Image, + arg2: VirtualPixelMethod) + -> VirtualPixelMethod; + pub fn AcquireNextImage(arg1: *const ImageInfo, arg2: *mut Image); + pub fn DestroyImagePixels(arg1: *mut Image); + pub fn DisassociateImageStream(arg1: *mut Image); + pub fn GetImageException(arg1: *mut Image, arg2: *mut ExceptionInfo); + pub fn GetImageInfo(arg1: *mut ImageInfo); + pub fn SetImageInfoBlob(arg1: *mut ImageInfo, arg2: *const ::libc::c_void, + arg3: size_t); + pub fn SetImageInfoFile(arg1: *mut ImageInfo, arg2: *mut FILE); + pub fn GetTypeList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *mut ::libc::c_char; + pub fn ListTypeInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn TypeComponentGenesis() -> MagickBooleanType; + pub fn GetTypeInfo(arg1: *const ::libc::c_char, arg2: *mut ExceptionInfo) + -> *const TypeInfo; + pub fn GetTypeInfoByFamily(arg1: *const ::libc::c_char, arg2: StyleType, + arg3: StretchType, arg4: size_t, + arg5: *mut ExceptionInfo) -> *const TypeInfo; + pub fn GetTypeInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *const TypeInfo; + pub fn TypeComponentTerminus(); + pub fn AcquireDrawInfo() -> *mut DrawInfo; + pub fn CloneDrawInfo(arg1: *const ImageInfo, arg2: *const DrawInfo) + -> *mut DrawInfo; + pub fn DestroyDrawInfo(arg1: *mut DrawInfo) -> *mut DrawInfo; + pub fn DrawAffineImage(arg1: *mut Image, arg2: *const Image, + arg3: *const AffineMatrix) -> MagickBooleanType; + pub fn DrawClipPath(arg1: *mut Image, arg2: *const DrawInfo, + arg3: *const ::libc::c_char) -> MagickBooleanType; + pub fn DrawGradientImage(arg1: *mut Image, arg2: *const DrawInfo) + -> MagickBooleanType; + pub fn DrawImage(arg1: *mut Image, arg2: *const DrawInfo) + -> MagickBooleanType; + pub fn DrawPatternPath(arg1: *mut Image, arg2: *const DrawInfo, + arg3: *const ::libc::c_char, arg4: *mut *mut Image) + -> MagickBooleanType; + pub fn DrawPrimitive(arg1: *mut Image, arg2: *const DrawInfo, + arg3: *const PrimitiveInfo) -> MagickBooleanType; + pub fn GetAffineMatrix(arg1: *mut AffineMatrix); + pub fn GetDrawInfo(arg1: *const ImageInfo, arg2: *mut DrawInfo); + pub fn AddNoiseImage(arg1: *const Image, arg2: NoiseType, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn AddNoiseImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: NoiseType, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn BlueShiftImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn CharcoalImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ColorizeImage(arg1: *const Image, arg2: *const ::libc::c_char, + arg3: PixelPacket, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn ColorMatrixImage(arg1: *const Image, kernel: *const KernelInfo, + arg2: *mut ExceptionInfo) -> *mut Image; + pub fn FxImage(arg1: *const Image, arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn FxImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ImplodeImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn MorphImages(arg1: *const Image, arg2: size_t, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn PolaroidImage(arg1: *const Image, arg2: *const DrawInfo, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn SepiaToneImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ShadowImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: ssize_t, arg5: ssize_t, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn SketchImage(arg1: *const Image, arg2: f64, arg3: f64, arg4: f64, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SteganoImage(arg1: *const Image, arg2: *const Image, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn StereoImage(arg1: *const Image, arg2: *const Image, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn StereoAnaglyphImage(arg1: *const Image, arg2: *const Image, + arg3: ssize_t, arg4: ssize_t, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SwirlImage(arg1: *const Image, arg2: f64, arg3: *mut ExceptionInfo) + -> *mut Image; + pub fn TintImage(arg1: *const Image, arg2: *const ::libc::c_char, + arg3: PixelPacket, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn VignetteImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: ssize_t, arg5: ssize_t, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn WaveImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn WaveletDenoiseImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn PlasmaImage(arg1: *mut Image, arg2: *const SegmentInfo, + arg3: size_t, arg4: size_t) -> MagickBooleanType; + pub fn SolarizeImage(arg1: *mut Image, arg2: f64) -> MagickBooleanType; + pub fn SolarizeImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: f64, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageChannelStatistics(arg1: *const Image, + arg2: *mut ExceptionInfo) + -> *mut ChannelStatistics; + pub fn GetImageChannelMoments(arg1: *const Image, + arg2: *mut ExceptionInfo) + -> *mut ChannelMoments; + pub fn GetImageChannelPerceptualHash(arg1: *const Image, + arg2: *mut ExceptionInfo) + -> *mut ChannelPerceptualHash; + pub fn EvaluateImages(arg1: *const Image, arg2: MagickEvaluateOperator, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn PolynomialImage(arg1: *const Image, arg2: size_t, arg3: *const f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn PolynomialImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: size_t, arg4: *const f64, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn StatisticImage(arg1: *const Image, arg2: StatisticType, + arg3: size_t, arg4: size_t, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn StatisticImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: StatisticType, arg4: size_t, + arg5: size_t, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn EvaluateImage(arg1: *mut Image, arg2: MagickEvaluateOperator, + arg3: f64, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn EvaluateImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: MagickEvaluateOperator, arg4: f64, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn FunctionImage(arg1: *mut Image, arg2: MagickFunction, arg3: size_t, + arg4: *const f64, arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn FunctionImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: MagickFunction, arg4: size_t, + arg5: *const f64, arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageChannelEntropy(arg1: *const Image, arg2: ChannelType, + arg3: *mut f64, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageChannelExtrema(arg1: *const Image, arg2: ChannelType, + arg3: *mut size_t, arg4: *mut size_t, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageChannelMean(arg1: *const Image, arg2: ChannelType, + arg3: *mut f64, arg4: *mut f64, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetImageChannelKurtosis(arg1: *const Image, arg2: ChannelType, + arg3: *mut f64, arg4: *mut f64, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageChannelRange(arg1: *const Image, arg2: ChannelType, + arg3: *mut f64, arg4: *mut f64, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageEntropy(arg1: *const Image, arg2: *mut f64, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetImageExtrema(arg1: *const Image, arg2: *mut size_t, + arg3: *mut size_t, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageMean(arg1: *const Image, arg2: *mut f64, arg3: *mut f64, + arg4: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetImageKurtosis(arg1: *const Image, arg2: *mut f64, + arg3: *mut f64, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageRange(arg1: *const Image, arg2: *mut f64, arg3: *mut f64, + arg4: *mut ExceptionInfo) -> MagickBooleanType; + pub fn AccelerateAddNoiseImage(arg1: *const Image, arg2: ChannelType, + arg3: NoiseType, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn AccelerateBlurImage(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn AccelerateConvolveImageChannel(arg1: *const Image, + arg2: ChannelType, + arg3: *const KernelInfo, + arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn AccelerateDespeckleImage(arg1: *const Image, + arg2: *mut ExceptionInfo) -> *mut Image; + pub fn AccelerateLocalContrastImage(arg1: *const Image, arg2: f64, + arg3: f64, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn AccelerateMotionBlurImage(arg1: *const Image, arg2: ChannelType, + arg3: *const f64, arg4: size_t, + arg5: *const OffsetInfo, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn AccelerateRadialBlurImage(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn AccelerateResizeImage(arg1: *const Image, arg2: size_t, + arg3: size_t, arg4: *const ResizeFilter, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn AccelerateUnsharpMaskImage(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: f64, arg5: f64, + arg6: f64, arg7: *mut ExceptionInfo) + -> *mut Image; + pub fn AccelerateWaveletDenoiseImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) + -> *mut Image; + pub fn AccelerateCompositeImage(arg1: *mut Image, arg2: ChannelType, + arg3: CompositeOperator, + arg4: *const Image, arg5: ssize_t, + arg6: ssize_t, arg7: f32, arg8: f32, + arg9: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateContrastImage(arg1: *mut Image, arg2: MagickBooleanType, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateContrastStretchImageChannel(arg1: *mut Image, + arg2: ChannelType, arg3: f64, + arg4: f64, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateEqualizeImage(arg1: *mut Image, arg2: ChannelType, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateFunctionImage(arg1: *mut Image, arg2: ChannelType, + arg3: MagickFunction, arg4: size_t, + arg5: *const f64, arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateGrayscaleImage(arg1: *mut Image, + arg2: PixelIntensityMethod, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateModulateImage(arg1: *mut Image, arg2: f64, arg3: f64, + arg4: f64, arg5: ColorspaceType, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateConvolveImage(arg1: *const Image, + arg2: *const KernelInfo, arg3: *mut Image, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateNegateImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: MagickBooleanType, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AnimateImages(arg1: *const ImageInfo, arg2: *mut Image) + -> MagickBooleanType; + pub fn AnnotateComponentGenesis() -> MagickBooleanType; + pub fn AnnotateImage(arg1: *mut Image, arg2: *const DrawInfo) + -> MagickBooleanType; + pub fn GetMultilineTypeMetrics(arg1: *mut Image, arg2: *const DrawInfo, + arg3: *mut TypeMetric) + -> MagickBooleanType; + pub fn GetTypeMetrics(arg1: *mut Image, arg2: *const DrawInfo, + arg3: *mut TypeMetric) -> MagickBooleanType; + pub fn FormatMagickCaption(arg1: *mut Image, arg2: *mut DrawInfo, + arg3: MagickBooleanType, arg4: *mut TypeMetric, + arg5: *mut *mut ::libc::c_char) -> ssize_t; + pub fn AnnotateComponentTerminus(); + pub fn GetNextImageArtifact(arg1: *const Image) -> *mut ::libc::c_char; + pub fn RemoveImageArtifact(arg1: *mut Image, arg2: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn GetImageArtifact(arg1: *const Image, arg2: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn CloneImageArtifacts(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn DefineImageArtifact(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DeleteImageArtifact(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn SetImageArtifact(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) -> MagickBooleanType; + pub fn DestroyImageArtifacts(arg1: *mut Image); + pub fn ResetImageArtifactIterator(arg1: *const Image); + pub fn GetImageType(arg1: *const Image, arg2: *mut ExceptionInfo) + -> ImageType; + pub fn IdentifyImageGray(arg1: *const Image, arg2: *mut ExceptionInfo) + -> ImageType; + pub fn IdentifyImageType(arg1: *const Image, arg2: *mut ExceptionInfo) + -> ImageType; + pub fn IdentifyImageMonochrome(arg1: *const Image, + arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn IsGrayImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn IsMonochromeImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn IsOpaqueImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn SetImageChannelDepth(arg1: *mut Image, arg2: ChannelType, + arg3: size_t) -> MagickBooleanType; + pub fn SetImageDepth(arg1: *mut Image, arg2: size_t) -> MagickBooleanType; + pub fn SetImageType(arg1: *mut Image, arg2: ImageType) + -> MagickBooleanType; + pub fn GetImageBoundingBox(arg1: *const Image, + exception: *mut ExceptionInfo) + -> RectangleInfo; + pub fn GetImageChannelDepth(arg1: *const Image, arg2: ChannelType, + arg3: *mut ExceptionInfo) -> size_t; + pub fn GetImageDepth(arg1: *const Image, arg2: *mut ExceptionInfo) + -> size_t; + pub fn GetImageQuantumDepth(arg1: *const Image, arg2: MagickBooleanType) + -> size_t; + pub fn GetImagePixelCacheType(arg1: *const Image) -> CacheType; + pub fn GetVirtualIndexQueue(arg1: *const Image) -> *const IndexPacket; + pub fn GetVirtualPixels(arg1: *const Image, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t, + arg6: *mut ExceptionInfo) -> *const PixelPacket; + pub fn GetVirtualPixelQueue(arg1: *const Image) -> *const PixelPacket; + pub fn AcquirePixelCachePixels(arg1: *const Image, + arg2: *mut MagickSizeType, + arg3: *mut ExceptionInfo) + -> *const ::libc::c_void; + pub fn GetAuthenticIndexQueue(arg1: *const Image) -> *mut IndexPacket; + pub fn CacheComponentGenesis() -> MagickBooleanType; + pub fn GetOneVirtualMagickPixel(arg1: *const Image, arg2: ssize_t, + arg3: ssize_t, + arg4: *mut MagickPixelPacket, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetOneVirtualPixel(arg1: *const Image, arg2: ssize_t, + arg3: ssize_t, arg4: *mut PixelPacket, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetOneVirtualMethodPixel(arg1: *const Image, + arg2: VirtualPixelMethod, arg3: ssize_t, + arg4: ssize_t, arg5: *mut PixelPacket, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetOneAuthenticPixel(arg1: *mut Image, arg2: ssize_t, + arg3: ssize_t, arg4: *mut PixelPacket, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn PersistPixelCache(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: MagickBooleanType, + arg4: *mut MagickOffsetType, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn SyncAuthenticPixels(arg1: *mut Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageExtent(arg1: *const Image) -> MagickSizeType; + pub fn GetAuthenticPixels(arg1: *mut Image, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t, + arg6: *mut ExceptionInfo) -> *mut PixelPacket; + pub fn GetAuthenticPixelQueue(arg1: *const Image) -> *mut PixelPacket; + pub fn QueueAuthenticPixels(arg1: *mut Image, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t, + arg6: *mut ExceptionInfo) -> *mut PixelPacket; + pub fn GetPixelCacheVirtualMethod(arg1: *const Image) + -> VirtualPixelMethod; + pub fn SetPixelCacheVirtualMethod(arg1: *const Image, + arg2: VirtualPixelMethod) + -> VirtualPixelMethod; + pub fn CacheComponentTerminus(); + pub fn GetPixelCachePixels(arg1: *mut Image, arg2: *mut MagickSizeType, + arg3: *mut ExceptionInfo) + -> *mut ::libc::c_void; + pub fn CombineImages(arg1: *const Image, arg2: ChannelType, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn SeparateImage(arg1: *const Image, arg2: ChannelType, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn SeparateImages(arg1: *const Image, arg2: ChannelType, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn GetImageAlphaChannel(arg1: *const Image) -> MagickBooleanType; + pub fn SeparateImageChannel(arg1: *mut Image, arg2: ChannelType) + -> MagickBooleanType; + pub fn SetImageAlphaChannel(arg1: *mut Image, arg2: AlphaChannelType) + -> MagickBooleanType; + pub fn DecipherImage(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn EncipherImage(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn PasskeyDecipherImage(arg1: *mut Image, arg2: *const StringInfo, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn PasskeyEncipherImage(arg1: *mut Image, arg2: *const StringInfo, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetClientPath() -> *const ::libc::c_char; + pub fn GetClientName() -> *const ::libc::c_char; + pub fn SetClientName(arg1: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn SetClientPath(arg1: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn GetCoderList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *mut ::libc::c_char; + pub fn GetCoderInfo(arg1: *const ::libc::c_char, arg2: *mut ExceptionInfo) + -> *const CoderInfo; + pub fn GetCoderInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *const CoderInfo; + pub fn CoderComponentGenesis() -> MagickBooleanType; + pub fn ListCoderInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn CoderComponentTerminus(); + pub fn AcquireImageColormap(arg1: *mut Image, arg2: size_t) + -> MagickBooleanType; + pub fn CycleColormapImage(arg1: *mut Image, arg2: ssize_t) + -> MagickBooleanType; + pub fn SortColormapByIntensity(arg1: *mut Image) -> MagickBooleanType; + pub fn GetImageChannelDistortions(arg1: *mut Image, arg2: *const Image, + arg3: MetricType, + arg4: *mut ExceptionInfo) -> *mut f64; + pub fn CompareImageChannels(arg1: *mut Image, arg2: *const Image, + arg3: ChannelType, arg4: MetricType, + arg5: *mut f64, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn CompareImages(arg1: *mut Image, arg2: *const Image, + arg3: MetricType, arg4: *mut f64, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SimilarityImage(arg1: *mut Image, arg2: *const Image, + arg3: *mut RectangleInfo, arg4: *mut f64, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SimilarityMetricImage(arg1: *mut Image, arg2: *const Image, + arg3: MetricType, arg4: *mut RectangleInfo, + arg5: *mut f64, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn GetImageChannelDistortion(arg1: *mut Image, arg2: *const Image, + arg3: ChannelType, arg4: MetricType, + arg5: *mut f64, arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageDistortion(arg1: *mut Image, arg2: *const Image, + arg3: MetricType, arg4: *mut f64, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn IsImagesEqual(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn GetConfigureList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *mut ::libc::c_char; + pub fn GetConfigureOption(arg1: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn GetConfigureValue(arg1: *const ConfigureInfo) + -> *const ::libc::c_char; + pub fn GetConfigureInfo(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) -> *const ConfigureInfo; + pub fn GetConfigureInfoList(arg1: *const ::libc::c_char, + arg2: *mut size_t, arg3: *mut ExceptionInfo) + -> *mut *const ConfigureInfo; + pub fn DestroyConfigureOptions(arg1: *mut LinkedListInfo) + -> *mut LinkedListInfo; + pub fn GetConfigurePaths(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) -> *mut LinkedListInfo; + pub fn GetConfigureOptions(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) + -> *mut LinkedListInfo; + pub fn ConfigureComponentGenesis() -> MagickBooleanType; + pub fn ListConfigureInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ConfigureComponentTerminus(); + pub fn BorderImage(arg1: *const Image, arg2: *const RectangleInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn FrameImage(arg1: *const Image, arg2: *const FrameInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn RaiseImage(arg1: *mut Image, arg2: *const RectangleInfo, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn GetDelegateCommand(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *const ::libc::c_char, + arg4: *const ::libc::c_char, + arg5: *mut ExceptionInfo) + -> *mut ::libc::c_char; + pub fn GetDelegateList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *mut ::libc::c_char; + pub fn GetDelegateCommands(arg1: *const DelegateInfo) + -> *const ::libc::c_char; + pub fn GetDelegateInfo(arg1: *const ::libc::c_char, + arg2: *const ::libc::c_char, + exception: *mut ExceptionInfo) + -> *const DelegateInfo; + pub fn GetDelegateInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *const DelegateInfo; + pub fn ExternalDelegateCommand(arg1: MagickBooleanType, + arg2: MagickBooleanType, + arg3: *const ::libc::c_char, + arg4: *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> ::libc::c_int; + pub fn GetDelegateMode(arg1: *const DelegateInfo) -> ssize_t; + pub fn DelegateComponentGenesis() -> MagickBooleanType; + pub fn GetDelegateThreadSupport(arg1: *const DelegateInfo) + -> MagickBooleanType; + pub fn InvokeDelegate(arg1: *mut ImageInfo, arg2: *mut Image, + arg3: *const ::libc::c_char, + arg4: *const ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn ListDelegateInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn DelegateComponentTerminus(); + pub fn CompressImageColormap(arg1: *mut Image) -> MagickBooleanType; + pub fn GetImageQuantizeError(arg1: *mut Image) -> MagickBooleanType; + pub fn PosterizeImage(arg1: *mut Image, arg2: size_t, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn PosterizeImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: size_t, arg4: MagickBooleanType) + -> MagickBooleanType; + pub fn QuantizeImage(arg1: *const QuantizeInfo, arg2: *mut Image) + -> MagickBooleanType; + pub fn QuantizeImages(arg1: *const QuantizeInfo, arg2: *mut Image) + -> MagickBooleanType; + pub fn RemapImage(arg1: *const QuantizeInfo, arg2: *mut Image, + arg3: *const Image) -> MagickBooleanType; + pub fn RemapImages(arg1: *const QuantizeInfo, arg2: *mut Image, + arg3: *const Image) -> MagickBooleanType; + pub fn AcquireQuantizeInfo(arg1: *const ImageInfo) -> *mut QuantizeInfo; + pub fn CloneQuantizeInfo(arg1: *const QuantizeInfo) -> *mut QuantizeInfo; + pub fn DestroyQuantizeInfo(arg1: *mut QuantizeInfo) -> *mut QuantizeInfo; + pub fn GetQuantizeInfo(arg1: *mut QuantizeInfo); + pub fn GetNextImageRegistry() -> *mut ::libc::c_char; + pub fn DefineImageRegistry(arg1: RegistryType, + arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn DeleteImageRegistry(arg1: *const ::libc::c_char) + -> MagickBooleanType; + pub fn RegistryComponentGenesis() -> MagickBooleanType; + pub fn SetImageRegistry(arg1: RegistryType, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_void, + arg4: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetImageRegistry(arg1: RegistryType, arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) -> *mut ::libc::c_void; + pub fn RegistryComponentTerminus(); + pub fn RemoveImageRegistry(arg1: *const ::libc::c_char) + -> *mut ::libc::c_void; + pub fn ResetImageRegistryIterator(); + pub fn CloseCacheView(arg1: *mut CacheView) -> *mut CacheView; + pub fn OpenCacheView(arg1: *const Image) -> *mut CacheView; + pub fn AllocateString(arg1: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn InterpretImageAttributes(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn PostscriptGeometry(arg1: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn TranslateText(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn GetImageAttribute(arg1: *const Image, arg2: *const ::libc::c_char) + -> *const ImageAttribute; + pub fn GetImageClippingPathAttribute(arg1: *mut Image) + -> *const ImageAttribute; + pub fn GetNextImageAttribute(arg1: *const Image) -> *const ImageAttribute; + pub fn AcquireCacheViewIndexes(arg1: *const CacheView) + -> *const IndexPacket; + pub fn AcquireIndexes(arg1: *const Image) -> *const IndexPacket; + pub fn AcquirePixels(arg1: *const Image) -> *const PixelPacket; + pub fn AcquireCacheViewPixels(arg1: *const CacheView, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t, + arg6: *mut ExceptionInfo) + -> *const PixelPacket; + pub fn AcquireImagePixels(arg1: *const Image, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t, + arg6: *mut ExceptionInfo) -> *const PixelPacket; + pub fn OpenMagickStream(arg1: *const ::libc::c_char, + arg2: *const ::libc::c_char) -> *mut FILE; + pub fn AllocateImage(arg1: *const ImageInfo) -> *mut Image; + pub fn AverageImages(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn ExtractSubimageFromImage(arg1: *mut Image, arg2: *const Image, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn GetImageFromMagickRegistry(arg1: *const ::libc::c_char, + id: *mut ssize_t, + arg2: *mut ExceptionInfo) -> *mut Image; + pub fn GetImageList(arg1: *const Image, arg2: ssize_t, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn GetNextImage(arg1: *const Image) -> *mut Image; + pub fn GetPreviousImage(arg1: *const Image) -> *mut Image; + pub fn FlattenImages(arg1: *mut Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn MaximumImages(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn MedianFilterImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ModeImage(arg1: *const Image, arg2: f64, arg3: *mut ExceptionInfo) + -> *mut Image; + pub fn MinimumImages(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn MosaicImages(arg1: *mut Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn PopImageList(arg1: *mut *mut Image) -> *mut Image; + pub fn RadialBlurImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn RadialBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: f64, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn RecolorImage(arg1: *const Image, arg2: size_t, arg3: *const f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ReduceNoiseImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ShiftImageList(arg1: *mut *mut Image) -> *mut Image; + pub fn SpliceImageList(arg1: *mut Image, arg2: ssize_t, arg3: size_t, + arg4: *const Image, arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn ZoomImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn GetCacheViewIndexes(arg1: *mut CacheView) -> *mut IndexPacket; + pub fn GetIndexes(arg1: *const Image) -> *mut IndexPacket; + pub fn ValidateColormapIndex(arg1: *mut Image, arg2: size_t) + -> IndexPacket; + pub fn GetImageGeometry(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: ::libc::c_uint, arg4: *mut RectangleInfo) + -> ::libc::c_int; + pub fn ParseImageGeometry(arg1: *const ::libc::c_char, arg2: *mut ssize_t, + arg3: *mut ssize_t, arg4: *mut size_t, + arg5: *mut size_t) -> ::libc::c_int; + pub fn SystemCommand(arg1: MagickBooleanType, arg2: MagickBooleanType, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) -> ::libc::c_int; + pub fn AcquireOneCacheViewPixel(arg1: *const CacheView, arg2: ssize_t, + arg3: ssize_t, arg4: *mut PixelPacket, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AcquireOneCacheViewVirtualPixel(arg1: *const CacheView, + arg2: VirtualPixelMethod, + arg3: ssize_t, arg4: ssize_t, + arg5: *mut PixelPacket, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AffinityImage(arg1: *const QuantizeInfo, arg2: *mut Image, + arg3: *const Image) -> MagickBooleanType; + pub fn AffinityImages(arg1: *const QuantizeInfo, arg2: *mut Image, + arg3: *const Image) -> MagickBooleanType; + pub fn AllocateImageColormap(arg1: *mut Image, arg2: size_t) + -> MagickBooleanType; + pub fn ClipPathImage(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn CloneImageAttributes(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn ColorFloodfillImage(arg1: *mut Image, arg2: *const DrawInfo, + arg3: PixelPacket, arg4: ssize_t, + arg5: ssize_t, arg6: PaintMethod) + -> MagickBooleanType; + pub fn ConstituteComponentGenesis() -> MagickBooleanType; + pub fn DeleteImageAttribute(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DeleteMagickRegistry(arg1: ssize_t) -> MagickBooleanType; + pub fn DescribeImage(arg1: *mut Image, arg2: *mut FILE, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn FormatImageAttribute(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, ...) + -> MagickBooleanType; + pub fn FormatImageAttributeList(arg1: *mut Image, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, + arg4: va_list) -> MagickBooleanType; + pub fn FormatImagePropertyList(arg1: *mut Image, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, arg4: va_list) + -> MagickBooleanType; + pub fn FuzzyColorCompare(arg1: *const Image, arg2: *const PixelPacket, + arg3: *const PixelPacket) -> MagickBooleanType; + pub fn FuzzyOpacityCompare(arg1: *const Image, arg2: *const PixelPacket, + arg3: *const PixelPacket) -> MagickBooleanType; + pub fn InitializeModuleList(arg1: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn IsMagickInstantiated() -> MagickBooleanType; + pub fn LevelImageColors(arg1: *mut Image, arg2: ChannelType, + arg3: *const MagickPixelPacket, + arg4: *const MagickPixelPacket, + arg5: MagickBooleanType) -> MagickBooleanType; + pub fn LoadMimeLists(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) -> MagickBooleanType; + pub fn MagickMonitor(arg1: *const ::libc::c_char, arg2: MagickOffsetType, + arg3: MagickSizeType, arg4: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn MapImage(arg1: *mut Image, arg2: *const Image, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn MapImages(arg1: *mut Image, arg2: *const Image, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn MatteFloodfillImage(arg1: *mut Image, arg2: PixelPacket, + arg3: Quantum, arg4: ssize_t, arg5: ssize_t, + arg6: PaintMethod) -> MagickBooleanType; + pub fn OpaqueImage(arg1: *mut Image, arg2: PixelPacket, arg3: PixelPacket) + -> MagickBooleanType; + pub fn PaintFloodfillImage(arg1: *mut Image, arg2: ChannelType, + arg3: *const MagickPixelPacket, arg4: ssize_t, + arg5: ssize_t, arg6: *const DrawInfo, + arg7: PaintMethod) -> MagickBooleanType; + pub fn PaintOpaqueImage(arg1: *mut Image, arg2: *const MagickPixelPacket, + arg3: *const MagickPixelPacket) + -> MagickBooleanType; + pub fn PaintOpaqueImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const MagickPixelPacket, + arg4: *const MagickPixelPacket) + -> MagickBooleanType; + pub fn PaintTransparentImage(arg1: *mut Image, + arg2: *const MagickPixelPacket, + arg3: Quantum) -> MagickBooleanType; + pub fn SetExceptionInfo(arg1: *mut ExceptionInfo, arg2: ExceptionType) + -> MagickBooleanType; + pub fn SetImageAttribute(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) + -> MagickBooleanType; + pub fn SyncCacheViewPixels(arg1: *mut CacheView) -> MagickBooleanType; + pub fn SyncImagePixels(arg1: *mut Image) -> MagickBooleanType; + pub fn TransparentImage(arg1: *mut Image, arg2: PixelPacket, + arg3: Quantum) -> MagickBooleanType; + pub fn AcquireOneMagickPixel(arg1: *const Image, arg2: ssize_t, + arg3: ssize_t, arg4: *mut ExceptionInfo) + -> MagickPixelPacket; + pub fn GetMonitorHandler() -> MonitorHandler; + pub fn SetMonitorHandler(arg1: MonitorHandler) -> MonitorHandler; + pub fn SizeBlob(image: *mut Image) -> MagickOffsetType; + pub fn InterpolatePixelColor(arg1: *const Image, arg2: *mut CacheView, + arg3: InterpolatePixelMethod, arg4: f64, + arg5: f64, arg6: *mut ExceptionInfo) + -> MagickPixelPacket; + pub fn ParseSizeGeometry(arg1: *const Image, arg2: *const ::libc::c_char, + arg3: *mut RectangleInfo) -> MagickStatusType; + pub fn AcquireOnePixel(arg1: *const Image, arg2: ssize_t, arg3: ssize_t, + arg4: *mut ExceptionInfo) -> PixelPacket; + pub fn AcquireOneVirtualPixel(arg1: *const Image, + arg2: VirtualPixelMethod, arg3: ssize_t, + arg4: ssize_t, arg5: *mut ExceptionInfo) + -> PixelPacket; + pub fn GetCacheView(arg1: *mut CacheView, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t) -> *mut PixelPacket; + pub fn GetCacheViewPixels(arg1: *mut CacheView, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t) + -> *mut PixelPacket; + pub fn GetImagePixels(arg1: *mut Image, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t) -> *mut PixelPacket; + pub fn GetOnePixel(arg1: *mut Image, arg2: ssize_t, arg3: ssize_t) + -> PixelPacket; + pub fn GetPixels(arg1: *const Image) -> *mut PixelPacket; + pub fn SetCacheViewPixels(arg1: *mut CacheView, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t) + -> *mut PixelPacket; + pub fn SetImagePixels(arg1: *mut Image, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t) -> *mut PixelPacket; + pub fn InversesRGBCompandor(arg1: MagickRealType) -> MagickRealType; + pub fn sRGBCompandor(arg1: MagickRealType) -> MagickRealType; + pub fn GetImageListSize(arg1: *const Image) -> size_t; + pub fn PopImagePixels(arg1: *mut Image, arg2: QuantumType, + arg3: *mut ::libc::c_uchar) -> size_t; + pub fn PushImagePixels(arg1: *mut Image, arg2: QuantumType, + arg3: *const ::libc::c_uchar) -> size_t; + pub fn FormatMagickString(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: *const ::libc::c_char, ...) -> ssize_t; + pub fn FormatMagickStringList(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: *const ::libc::c_char, arg4: va_list) + -> ssize_t; + pub fn GetImageListIndex(arg1: *const Image) -> ssize_t; + pub fn SetMagickRegistry(arg1: RegistryType, arg2: *const ::libc::c_void, + arg3: size_t, arg4: *mut ExceptionInfo) + -> ssize_t; + pub fn ChannelImage(arg1: *mut Image, arg2: ChannelType) + -> ::libc::c_uint; + pub fn ChannelThresholdImage(arg1: *mut Image, + arg2: *const ::libc::c_char) + -> ::libc::c_uint; + pub fn DispatchImage(arg1: *const Image, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t, + arg6: *const ::libc::c_char, arg7: StorageType, + arg8: *mut ::libc::c_void, arg9: *mut ExceptionInfo) + -> ::libc::c_uint; + pub fn FuzzyColorMatch(arg1: *const PixelPacket, arg2: *const PixelPacket, + arg3: f64) -> ::libc::c_uint; + pub fn GetNumberScenes(arg1: *const Image) -> ::libc::c_uint; + pub fn GetMagickGeometry(arg1: *const ::libc::c_char, arg2: *mut ssize_t, + arg3: *mut ssize_t, arg4: *mut size_t, + arg5: *mut size_t) -> ::libc::c_uint; + pub fn IsSubimage(arg1: *const ::libc::c_char, arg2: ::libc::c_uint) + -> ::libc::c_uint; + pub fn PushImageList(arg1: *mut *mut Image, arg2: *const Image, + arg3: *mut ExceptionInfo) -> ::libc::c_uint; + pub fn QuantizationError(arg1: *mut Image) -> ::libc::c_uint; + pub fn RandomChannelThresholdImage(arg1: *mut Image, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) + -> ::libc::c_uint; + pub fn SetImageList(arg1: *mut *mut Image, arg2: *const Image, + arg3: ssize_t, arg4: *mut ExceptionInfo) + -> ::libc::c_uint; + pub fn TransformColorspace(arg1: *mut Image, arg2: ColorspaceType) + -> ::libc::c_uint; + pub fn ThresholdImage(arg1: *mut Image, arg2: f64) -> ::libc::c_uint; + pub fn ThresholdImageChannel(arg1: *mut Image, + arg2: *const ::libc::c_char) + -> ::libc::c_uint; + pub fn UnshiftImageList(arg1: *mut *mut Image, arg2: *const Image, + arg3: *mut ExceptionInfo) -> ::libc::c_uint; + pub fn AcquireMemory(arg1: size_t) -> *mut ::libc::c_void; + pub fn AcquireSemaphoreInfo(arg1: *mut *mut SemaphoreInfo); + pub fn AllocateNextImage(arg1: *const ImageInfo, arg2: *mut Image); + pub fn CloneMemory(arg1: *mut ::libc::c_void, arg2: *const ::libc::c_void, + arg3: size_t) -> *mut ::libc::c_void; + pub fn ConstituteComponentTerminus(); + pub fn DestroyConstitute(); + pub fn DestroyImageAttributes(arg1: *mut Image); + pub fn DestroyImages(arg1: *mut Image); + pub fn DestroyMagick(); + pub fn DestroyMagickRegistry(); + pub fn GetConfigureBlob(arg1: *const ::libc::c_char, + arg2: *mut ::libc::c_char, arg3: *mut size_t, + arg4: *mut ExceptionInfo) -> *mut ::libc::c_void; + pub fn GetExceptionInfo(arg1: *mut ExceptionInfo); + pub fn GetMagickRegistry(arg1: ssize_t, arg2: *mut RegistryType, + arg3: *mut size_t, arg4: *mut ExceptionInfo) + -> *mut ::libc::c_void; + pub fn GetTokenToken(arg1: *const ::libc::c_char, + arg2: *mut *const ::libc::c_char, + arg3: *mut ::libc::c_char); + pub fn IdentityAffine(arg1: *mut AffineMatrix); + pub fn LiberateMemory(arg1: *mut *mut ::libc::c_void); + pub fn LiberateSemaphoreInfo(arg1: *mut *mut SemaphoreInfo); + pub fn FormatString(arg1: *mut ::libc::c_char, + arg2: *const ::libc::c_char, ...); + pub fn FormatStringList(arg1: *mut ::libc::c_char, + arg2: *const ::libc::c_char, arg3: va_list); + pub fn HSLTransform(arg1: f64, arg2: f64, arg3: f64, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum); + pub fn InitializeMagick(arg1: *const ::libc::c_char); + pub fn MagickIncarnate(arg1: *const ::libc::c_char); + pub fn ReacquireMemory(arg1: *mut *mut ::libc::c_void, arg2: size_t); + pub fn RelinquishSemaphoreInfo(arg1: *mut SemaphoreInfo); + pub fn ResetImageAttributeIterator(arg1: *const Image); + pub fn SetCacheThreshold(arg1: size_t); + pub fn SetImage(arg1: *mut Image, arg2: Quantum); + pub fn Strip(arg1: *mut ::libc::c_char); + pub fn TemporaryFilename(arg1: *mut ::libc::c_char); + pub fn TransformHSL(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn DisplayImages(arg1: *const ImageInfo, arg2: *mut Image) + -> MagickBooleanType; + pub fn RemoteDisplayCommand(arg1: *const ImageInfo, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AffineTransformImage(arg1: *const Image, arg2: *const AffineMatrix, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn DistortImage(arg1: *const Image, arg2: DistortImageMethod, + arg3: size_t, arg4: *const f64, + arg5: MagickBooleanType, + exception: *mut ExceptionInfo) -> *mut Image; + pub fn DistortResizeImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn RotateImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn SparseColorImage(arg1: *const Image, arg2: ChannelType, + arg3: SparseColorMethod, arg4: size_t, + arg5: *const f64, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn DistributePixelCacheServer(arg1: ::libc::c_int, + arg2: *mut ExceptionInfo); + pub fn AutoGammaImage(arg1: *mut Image) -> MagickBooleanType; + pub fn AutoGammaImageChannel(arg1: *mut Image, arg2: ChannelType) + -> MagickBooleanType; + pub fn AutoLevelImage(arg1: *mut Image) -> MagickBooleanType; + pub fn AutoLevelImageChannel(arg1: *mut Image, arg2: ChannelType) + -> MagickBooleanType; + pub fn BrightnessContrastImage(arg1: *mut Image, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn BrightnessContrastImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: f64, arg4: f64) + -> MagickBooleanType; + pub fn ClutImage(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn ClutImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const Image) -> MagickBooleanType; + pub fn ColorDecisionListImage(arg1: *mut Image, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn ContrastImage(arg1: *mut Image, arg2: MagickBooleanType) + -> MagickBooleanType; + pub fn ContrastStretchImage(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn ContrastStretchImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: f64, arg4: f64) + -> MagickBooleanType; + pub fn EqualizeImage(image: *mut Image) -> MagickBooleanType; + pub fn EqualizeImageChannel(image: *mut Image, arg1: ChannelType) + -> MagickBooleanType; + pub fn GammaImage(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn GammaImageChannel(arg1: *mut Image, arg2: ChannelType, arg3: f64) + -> MagickBooleanType; + pub fn GrayscaleImage(arg1: *mut Image, arg2: PixelIntensityMethod) + -> MagickBooleanType; + pub fn HaldClutImage(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn HaldClutImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const Image) -> MagickBooleanType; + pub fn LevelImage(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn LevelImageChannel(arg1: *mut Image, arg2: ChannelType, arg3: f64, + arg4: f64, arg5: f64) -> MagickBooleanType; + pub fn LevelizeImage(arg1: *mut Image, arg2: f64, arg3: f64, arg4: f64) + -> MagickBooleanType; + pub fn LevelizeImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: f64, arg4: f64, arg5: f64) + -> MagickBooleanType; + pub fn LevelColorsImage(arg1: *mut Image, arg2: *const MagickPixelPacket, + arg3: *const MagickPixelPacket, + arg4: MagickBooleanType) -> MagickBooleanType; + pub fn LevelColorsImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const MagickPixelPacket, + arg4: *const MagickPixelPacket, + arg5: MagickBooleanType) + -> MagickBooleanType; + pub fn LinearStretchImage(arg1: *mut Image, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn ModulateImage(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn NegateImage(arg1: *mut Image, arg2: MagickBooleanType) + -> MagickBooleanType; + pub fn NegateImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn NormalizeImage(arg1: *mut Image) -> MagickBooleanType; + pub fn NormalizeImageChannel(arg1: *mut Image, arg2: ChannelType) + -> MagickBooleanType; + pub fn SigmoidalContrastImage(arg1: *mut Image, arg2: MagickBooleanType, + arg3: *const ::libc::c_char) + -> MagickBooleanType; + pub fn SigmoidalContrastImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: MagickBooleanType, arg4: f64, + arg5: f64) -> MagickBooleanType; + pub fn EnhanceImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn GetImageChannelFeatures(arg1: *const Image, arg2: size_t, + arg3: *mut ExceptionInfo) + -> *mut ChannelFeatures; + pub fn CannyEdgeImage(arg1: *const Image, arg2: f64, arg3: f64, arg4: f64, + arg5: f64, arg6: *mut ExceptionInfo) -> *mut Image; + pub fn HoughLineImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: size_t, arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn MeanShiftImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: f64, arg5: *mut ExceptionInfo) -> *mut Image; + pub fn ComplexImages(arg1: *const Image, arg2: ComplexOperator, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ForwardFourierTransformImage(arg1: *const Image, + arg2: MagickBooleanType, + arg3: *mut ExceptionInfo) + -> *mut Image; + pub fn InverseFourierTransformImage(arg1: *const Image, + arg2: *const Image, + arg3: MagickBooleanType, + arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn GetRandomValue(arg1: *mut RandomInfo) -> f64; + pub fn GetPseudoRandomValue(arg1: *mut RandomInfo) -> f64; + pub fn RandomComponentGenesis() -> MagickBooleanType; + pub fn AcquireRandomInfo() -> *mut RandomInfo; + pub fn DestroyRandomInfo(arg1: *mut RandomInfo) -> *mut RandomInfo; + pub fn GetRandomKey(arg1: *mut RandomInfo, arg2: size_t) + -> *mut StringInfo; + pub fn GetRandomSecretKey(arg1: *const RandomInfo) -> ::libc::c_ulong; + pub fn RandomComponentTerminus(); + pub fn SeedPseudoRandomGenerator(arg1: ::libc::c_ulong); + pub fn SetRandomKey(arg1: *mut RandomInfo, arg2: size_t, + arg3: *mut ::libc::c_uchar); + pub fn SetRandomSecretKey(arg1: ::libc::c_ulong); + pub fn SetRandomTrueRandom(arg1: MagickBooleanType); + pub fn ExpandAffine(arg1: *const AffineMatrix) -> f64; + pub fn GenerateDifferentialNoise(arg1: *mut RandomInfo, arg2: Quantum, + arg3: NoiseType, arg4: MagickRealType) + -> f64; + pub fn GetOptimalKernelWidth(arg1: f64, arg2: f64) -> size_t; + pub fn GetOptimalKernelWidth1D(arg1: f64, arg2: f64) -> size_t; + pub fn GetOptimalKernelWidth2D(arg1: f64, arg2: f64) -> size_t; + pub fn ConvertHCLToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertHCLpToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertHSBToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertHSIToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertHSLToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertHSVToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertHWBToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertLCHabToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertLCHuvToRGB(arg1: f64, arg2: f64, arg3: f64, + arg4: *mut Quantum, arg5: *mut Quantum, + arg6: *mut Quantum); + pub fn ConvertRGBToHCL(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn ConvertRGBToHCLp(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn ConvertRGBToHSB(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn ConvertRGBToHSI(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn ConvertRGBToHSL(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn ConvertRGBToHSV(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn ConvertRGBToHWB(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn ConvertRGBToLCHab(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn ConvertRGBToLCHuv(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut f64, arg5: *mut f64, arg6: *mut f64); + pub fn GetImageHistogram(arg1: *const Image, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut ColorPacket; + pub fn UniqueImageColors(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn IdentifyPaletteImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn IsHistogramImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn IsPaletteImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn MinMaxStretchImage(arg1: *mut Image, arg2: ChannelType, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn GetNumberColors(arg1: *const Image, arg2: *mut FILE, + arg3: *mut ExceptionInfo) -> size_t; + pub fn IdentifyImage(arg1: *mut Image, arg2: *mut FILE, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn GetImageViewException(arg1: *const ImageView, + arg2: *mut ExceptionType) + -> *mut ::libc::c_char; + pub fn GetImageViewVirtualIndexes(arg1: *const ImageView) + -> *const IndexPacket; + pub fn GetImageViewVirtualPixels(arg1: *const ImageView) + -> *const PixelPacket; + pub fn GetImageViewImage(arg1: *const ImageView) -> *mut Image; + pub fn CloneImageView(arg1: *const ImageView) -> *mut ImageView; + pub fn DestroyImageView(arg1: *mut ImageView) -> *mut ImageView; + pub fn NewImageView(arg1: *mut Image) -> *mut ImageView; + pub fn NewImageViewRegion(arg1: *mut Image, arg2: ssize_t, arg3: ssize_t, + arg4: size_t, arg5: size_t) -> *mut ImageView; + pub fn GetImageViewAuthenticIndexes(arg1: *const ImageView) + -> *mut IndexPacket; + pub fn DuplexTransferImageViewIterator(arg1: *mut ImageView, + arg2: *mut ImageView, + arg3: *mut ImageView, + arg4: + DuplexTransferImageViewMethod, + arg5: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn GetImageViewIterator(arg1: *mut ImageView, + arg2: GetImageViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn IsImageView(arg1: *const ImageView) -> MagickBooleanType; + pub fn SetImageViewIterator(arg1: *mut ImageView, + arg2: SetImageViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn TransferImageViewIterator(arg1: *mut ImageView, + arg2: *mut ImageView, + arg3: TransferImageViewMethod, + arg4: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn UpdateImageViewIterator(arg1: *mut ImageView, + arg2: UpdateImageViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn GetImageViewAuthenticPixels(arg1: *const ImageView) + -> *mut PixelPacket; + pub fn GetImageViewExtent(arg1: *const ImageView) -> RectangleInfo; + pub fn SetImageViewDescription(arg1: *mut ImageView, + arg2: *const ::libc::c_char); + pub fn SetImageViewThreads(arg1: *mut ImageView, arg2: size_t); + pub fn CloneImageList(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn CloneImages(arg1: *const Image, arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn DestroyImageList(arg1: *mut Image) -> *mut Image; + pub fn DuplicateImages(arg1: *mut Image, arg2: size_t, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn GetFirstImageInList(arg1: *const Image) -> *mut Image; + pub fn GetImageFromList(arg1: *const Image, arg2: ssize_t) -> *mut Image; + pub fn GetLastImageInList(arg1: *const Image) -> *mut Image; + pub fn GetNextImageInList(arg1: *const Image) -> *mut Image; + pub fn GetPreviousImageInList(arg1: *const Image) -> *mut Image; + pub fn ImageListToArray(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut *mut Image; + pub fn NewImageList() -> *mut Image; + pub fn RemoveImageFromList(arg1: *mut *mut Image) -> *mut Image; + pub fn RemoveLastImageFromList(arg1: *mut *mut Image) -> *mut Image; + pub fn RemoveFirstImageFromList(arg1: *mut *mut Image) -> *mut Image; + pub fn SpliceImageIntoList(arg1: *mut *mut Image, arg2: size_t, + arg3: *const Image) -> *mut Image; + pub fn SplitImageList(arg1: *mut Image) -> *mut Image; + pub fn SyncNextImageInList(arg1: *const Image) -> *mut Image; + pub fn GetImageListLength(arg1: *const Image) -> size_t; + pub fn GetImageIndexInList(arg1: *const Image) -> ssize_t; + pub fn AppendImageToList(arg1: *mut *mut Image, arg2: *const Image); + pub fn DeleteImageFromList(arg1: *mut *mut Image); + pub fn DeleteImages(arg1: *mut *mut Image, arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo); + pub fn InsertImageInList(arg1: *mut *mut Image, arg2: *mut Image); + pub fn PrependImageToList(arg1: *mut *mut Image, arg2: *mut Image); + pub fn ReplaceImageInList(arg1: *mut *mut Image, arg2: *mut Image); + pub fn ReplaceImageInListReturnLast(arg1: *mut *mut Image, + arg2: *mut Image); + pub fn ReverseImageList(arg1: *mut *mut Image); + pub fn SyncImageList(arg1: *mut Image); + pub fn GetLogList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *mut ::libc::c_char; + pub fn GetLogName() -> *const ::libc::c_char; + pub fn SetLogName(arg1: *const ::libc::c_char) -> *const ::libc::c_char; + pub fn GetLogInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *const LogInfo; + pub fn SetLogEventMask(arg1: *const ::libc::c_char) -> LogEventType; + pub fn IsEventLogging() -> MagickBooleanType; + pub fn ListLogInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn LogComponentGenesis() -> MagickBooleanType; + pub fn LogMagickEvent(arg1: LogEventType, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, arg4: size_t, + arg5: *const ::libc::c_char, ...) + -> MagickBooleanType; + pub fn LogMagickEventList(arg1: LogEventType, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, arg4: size_t, + arg5: *const ::libc::c_char, arg6: va_list) + -> MagickBooleanType; + pub fn CloseMagickLog(); + pub fn LogComponentTerminus(); + pub fn SetLogFormat(arg1: *const ::libc::c_char); + pub fn SetLogMethod(arg1: MagickLogMethod); + pub fn GetMagicList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *mut ::libc::c_char; + pub fn GetMagicName(arg1: *const MagicInfo) -> *const ::libc::c_char; + pub fn ListMagicInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn MagicComponentGenesis() -> MagickBooleanType; + pub fn GetMagicInfo(arg1: *const ::libc::c_uchar, arg2: size_t, + arg3: *mut ExceptionInfo) -> *const MagicInfo; + pub fn GetMagicInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *const MagicInfo; + pub fn MagicComponentTerminus(); + pub fn GetMagickList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *mut ::libc::c_char; + pub fn GetMagickDescription(arg1: *const MagickInfo) + -> *const ::libc::c_char; + pub fn GetMagickMimeType(arg1: *const MagickInfo) + -> *const ::libc::c_char; + pub fn GetImageDecoder(arg1: *const MagickInfo) -> DecodeImageHandler; + pub fn GetImageEncoder(arg1: *const MagickInfo) -> EncodeImageHandler; + pub fn GetMagickPrecision() -> ::libc::c_int; + pub fn SetMagickPrecision(arg1: ::libc::c_int) -> ::libc::c_int; + pub fn GetImageMagick(arg1: *const ::libc::c_uchar, arg2: size_t, + arg3: *mut ::libc::c_char) -> MagickBooleanType; + pub fn GetMagickAdjoin(arg1: *const MagickInfo) -> MagickBooleanType; + pub fn GetMagickBlobSupport(arg1: *const MagickInfo) -> MagickBooleanType; + pub fn GetMagickEndianSupport(arg1: *const MagickInfo) + -> MagickBooleanType; + pub fn GetMagickRawSupport(arg1: *const MagickInfo) -> MagickBooleanType; + pub fn GetMagickSeekableStream(arg1: *const MagickInfo) + -> MagickBooleanType; + pub fn IsMagickCoreInstantiated() -> MagickBooleanType; + pub fn MagickComponentGenesis() -> MagickBooleanType; + pub fn UnregisterMagickInfo(arg1: *const ::libc::c_char) + -> MagickBooleanType; + pub fn GetMagickInfo(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) -> *const MagickInfo; + pub fn GetMagickInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *const MagickInfo; + pub fn RegisterMagickInfo(arg1: *mut MagickInfo) -> *mut MagickInfo; + pub fn SetMagickInfo(arg1: *const ::libc::c_char) -> *mut MagickInfo; + pub fn GetMagickThreadSupport(arg1: *const MagickInfo) + -> MagickStatusType; + pub fn MagickComponentTerminus(); + pub fn MagickCoreGenesis(arg1: *const ::libc::c_char, + arg2: MagickBooleanType); + pub fn MagickCoreTerminus(); + pub fn AcquireMagickMatrix(arg1: size_t, arg2: size_t) -> *mut *mut f64; + pub fn RelinquishMagickMatrix(arg1: *mut *mut f64, arg2: size_t) + -> *mut *mut f64; + pub fn MatrixToImage(arg1: *const MatrixInfo, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn GaussJordanElimination(arg1: *mut *mut f64, arg2: *mut *mut f64, + arg3: size_t, arg4: size_t) + -> MagickBooleanType; + pub fn GetMatrixElement(arg1: *const MatrixInfo, arg2: ssize_t, + arg3: ssize_t, arg4: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn NullMatrix(arg1: *mut MatrixInfo) -> MagickBooleanType; + pub fn SetMatrixElement(arg1: *const MatrixInfo, arg2: ssize_t, + arg3: ssize_t, arg4: *const ::libc::c_void) + -> MagickBooleanType; + pub fn AcquireMatrixInfo(arg1: size_t, arg2: size_t, arg3: size_t, + arg4: *mut ExceptionInfo) -> *mut MatrixInfo; + pub fn DestroyMatrixInfo(arg1: *mut MatrixInfo) -> *mut MatrixInfo; + pub fn GetMatrixColumns(arg1: *const MatrixInfo) -> size_t; + pub fn GetMatrixRows(arg1: *const MatrixInfo) -> size_t; + pub fn LeastSquaresAddTerms(arg1: *mut *mut f64, arg2: *mut *mut f64, + arg3: *const f64, arg4: *const f64, + arg5: size_t, arg6: size_t); + pub fn AcquireVirtualMemory(arg1: size_t, arg2: size_t) + -> *mut MemoryInfo; + pub fn RelinquishVirtualMemory(arg1: *mut MemoryInfo) -> *mut MemoryInfo; + pub fn AcquireAlignedMemory(arg1: size_t, arg2: size_t) + -> *mut ::libc::c_void; + pub fn AcquireMagickMemory(arg1: size_t) -> *mut ::libc::c_void; + pub fn AcquireQuantumMemory(arg1: size_t, arg2: size_t) + -> *mut ::libc::c_void; + pub fn CopyMagickMemory(arg1: *mut ::libc::c_void, + arg2: *const ::libc::c_void, arg3: size_t) + -> *mut ::libc::c_void; + pub fn DestroyMagickMemory(); + pub fn GetMagickMemoryMethods(arg1: *mut AcquireMemoryHandler, + arg2: *mut ResizeMemoryHandler, + arg3: *mut DestroyMemoryHandler); + pub fn GetVirtualMemoryBlob(arg1: *const MemoryInfo) + -> *mut ::libc::c_void; + pub fn RelinquishAlignedMemory(arg1: *mut ::libc::c_void) + -> *mut ::libc::c_void; + pub fn RelinquishMagickMemory(arg1: *mut ::libc::c_void) + -> *mut ::libc::c_void; + pub fn ResetMagickMemory(arg1: *mut ::libc::c_void, arg2: ::libc::c_int, + arg3: size_t) -> *mut ::libc::c_void; + pub fn ResizeMagickMemory(arg1: *mut ::libc::c_void, arg2: size_t) + -> *mut ::libc::c_void; + pub fn ResizeQuantumMemory(arg1: *mut ::libc::c_void, arg2: size_t, + arg3: size_t) -> *mut ::libc::c_void; + pub fn SetMagickMemoryMethods(arg1: AcquireMemoryHandler, + arg2: ResizeMemoryHandler, + arg3: DestroyMemoryHandler); + pub fn GetMagickHomeURL() -> *mut ::libc::c_char; + pub fn GetMagickCopyright() -> *const ::libc::c_char; + pub fn GetMagickDelegates() -> *const ::libc::c_char; + pub fn GetMagickFeatures() -> *const ::libc::c_char; + pub fn GetMagickLicense() -> *const ::libc::c_char; + pub fn GetMagickPackageName() -> *const ::libc::c_char; + pub fn GetMagickQuantumDepth(arg1: *mut size_t) -> *const ::libc::c_char; + pub fn GetMagickQuantumRange(arg1: *mut size_t) -> *const ::libc::c_char; + pub fn GetMagickReleaseDate() -> *const ::libc::c_char; + pub fn GetMagickVersion(arg1: *mut size_t) -> *const ::libc::c_char; + pub fn ListMagickVersion(arg1: *mut FILE); + pub fn GetModuleList(arg1: *const ::libc::c_char, arg2: MagickModuleType, + arg3: *mut size_t, arg4: *mut ExceptionInfo) + -> *mut *mut ::libc::c_char; + pub fn GetModuleInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *const ModuleInfo; + pub fn InvokeDynamicImageFilter(arg1: *const ::libc::c_char, + arg2: *mut *mut Image, + arg3: ::libc::c_int, + arg4: *mut *const ::libc::c_char, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ListModuleInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ModuleComponentGenesis() -> MagickBooleanType; + pub fn OpenModule(arg1: *const ::libc::c_char, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn OpenModules(arg1: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetModuleInfo(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) -> *mut ModuleInfo; + pub fn DestroyModuleList(); + pub fn ModuleComponentTerminus(); + pub fn RegisterStaticModules(); + pub fn UnregisterStaticModules(); + pub fn GetMimeList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *mut ::libc::c_char; + pub fn MagickToMime(arg1: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn GetMimeDescription(arg1: *const MimeInfo) -> *const ::libc::c_char; + pub fn GetMimeType(arg1: *const MimeInfo) -> *const ::libc::c_char; + pub fn ListMimeInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn MimeComponentGenesis() -> MagickBooleanType; + pub fn GetMimeInfo(arg1: *const ::libc::c_char, + arg2: *const ::libc::c_uchar, arg3: size_t, + arg4: *mut ExceptionInfo) -> *const MimeInfo; + pub fn GetMimeInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) -> *mut *const MimeInfo; + pub fn MimeComponentTerminus(); + pub fn MontageImages(arg1: *const Image, arg2: *const MontageInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn MontageImageList(arg1: *const ImageInfo, arg2: *const MontageInfo, + arg3: *const Image, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn CloneMontageInfo(arg1: *const ImageInfo, arg2: *const MontageInfo) + -> *mut MontageInfo; + pub fn DestroyMontageInfo(arg1: *mut MontageInfo) -> *mut MontageInfo; + pub fn GetMontageInfo(arg1: *const ImageInfo, arg2: *mut MontageInfo); + pub fn GetMagickOpenCLEnvParam(arg1: MagickCLEnv, + arg2: MagickOpenCLEnvParam, arg3: size_t, + arg4: *mut ::libc::c_void, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn InitImageMagickOpenCL(arg1: ImageMagickOpenCLMode, + arg2: *mut ::libc::c_void, + arg3: *mut ::libc::c_void, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn InitOpenCLEnv(arg1: MagickCLEnv, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn RelinquishMagickOpenCLEnv(arg1: MagickCLEnv) -> MagickBooleanType; + pub fn SetMagickOpenCLEnvParam(arg1: MagickCLEnv, + arg2: MagickOpenCLEnvParam, arg3: size_t, + arg4: *mut ::libc::c_void, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AcquireMagickOpenCLEnv() -> MagickCLEnv; + pub fn GetDefaultOpenCLEnv() -> MagickCLEnv; + pub fn SetDefaultOpenCLEnv(arg1: MagickCLEnv) -> MagickCLEnv; + pub fn GetCommandOptions(arg1: CommandOption) -> *mut *mut ::libc::c_char; + pub fn GetNextImageOption(arg1: *const ImageInfo) -> *mut ::libc::c_char; + pub fn RemoveImageOption(arg1: *mut ImageInfo, + arg2: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn CommandOptionToMnemonic(arg1: CommandOption, arg2: ssize_t) + -> *const ::libc::c_char; + pub fn GetImageOption(arg1: *const ImageInfo, arg2: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn CloneImageOptions(arg1: *mut ImageInfo, arg2: *const ImageInfo) + -> MagickBooleanType; + pub fn DefineImageOption(arg1: *mut ImageInfo, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DeleteImageOption(arg1: *mut ImageInfo, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn IsCommandOption(arg1: *const ::libc::c_char) -> MagickBooleanType; + pub fn IsOptionMember(arg1: *const ::libc::c_char, + arg2: *const ::libc::c_char) -> MagickBooleanType; + pub fn ListCommandOptions(arg1: *mut FILE, arg2: CommandOption, + arg3: *mut ExceptionInfo) -> MagickBooleanType; + pub fn SetImageOption(arg1: *mut ImageInfo, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) -> MagickBooleanType; + pub fn GetCommandOptionFlags(arg1: CommandOption, arg2: MagickBooleanType, + arg3: *const ::libc::c_char) -> ssize_t; + pub fn ParseChannelOption(arg1: *const ::libc::c_char) -> ssize_t; + pub fn ParseCommandOption(arg1: CommandOption, arg2: MagickBooleanType, + arg3: *const ::libc::c_char) -> ssize_t; + pub fn DestroyImageOptions(arg1: *mut ImageInfo); + pub fn ResetImageOptions(arg1: *const ImageInfo); + pub fn ResetImageOptionIterator(arg1: *const ImageInfo); + pub fn OilPaintImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn FloodfillPaintImage(arg1: *mut Image, arg2: ChannelType, + arg3: *const DrawInfo, + arg4: *const MagickPixelPacket, arg5: ssize_t, + arg6: ssize_t, arg7: MagickBooleanType) + -> MagickBooleanType; + pub fn GradientImage(arg1: *mut Image, arg2: GradientType, + arg3: SpreadMethod, arg4: *const PixelPacket, + arg5: *const PixelPacket) -> MagickBooleanType; + pub fn OpaquePaintImage(arg1: *mut Image, arg2: *const MagickPixelPacket, + arg3: *const MagickPixelPacket, + arg4: MagickBooleanType) -> MagickBooleanType; + pub fn OpaquePaintImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const MagickPixelPacket, + arg4: *const MagickPixelPacket, + arg5: MagickBooleanType) + -> MagickBooleanType; + pub fn TransparentPaintImage(arg1: *mut Image, + arg2: *const MagickPixelPacket, + arg3: Quantum, arg4: MagickBooleanType) + -> MagickBooleanType; + pub fn TransparentPaintImageChroma(arg1: *mut Image, + arg2: *const MagickPixelPacket, + arg3: *const MagickPixelPacket, + arg4: Quantum, arg5: MagickBooleanType) + -> MagickBooleanType; + pub fn GetPolicyValue(name: *const ::libc::c_char) -> *mut ::libc::c_char; + pub fn GetPolicyList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *mut ::libc::c_char; + pub fn GetPolicyInfoList(arg1: *const ::libc::c_char, arg2: *mut size_t, + arg3: *mut ExceptionInfo) + -> *mut *const PolicyInfo; + pub fn IsRightsAuthorized(arg1: PolicyDomain, arg2: PolicyRights, + arg3: *const ::libc::c_char) + -> MagickBooleanType; + pub fn ListPolicyInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn PolicyComponentGenesis() -> MagickBooleanType; + pub fn PolicyComponentTerminus(); + pub fn GetImageTotalInkDensity(image: *mut Image) -> f64; + pub fn GetNextImageProperty(arg1: *const Image) -> *mut ::libc::c_char; + pub fn InterpretImageProperties(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn RemoveImageProperty(arg1: *mut Image, arg2: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn GetImageProperty(arg1: *const Image, arg2: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn GetMagickProperty(arg1: *const ImageInfo, arg2: *mut Image, + arg3: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn CloneImageProperties(arg1: *mut Image, arg2: *const Image) + -> MagickBooleanType; + pub fn DefineImageProperty(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DeleteImageProperty(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn FormatImageProperty(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, ...) + -> MagickBooleanType; + pub fn SetImageProperty(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) -> MagickBooleanType; + pub fn DestroyImageProperties(arg1: *mut Image); + pub fn ResetImagePropertyIterator(arg1: *const Image); + pub fn AcquireUniqueFileResource(arg1: *mut ::libc::c_char) + -> ::libc::c_int; + pub fn AcquireMagickResource(arg1: ResourceType, arg2: MagickSizeType) + -> MagickBooleanType; + pub fn GetPathTemplate(arg1: *mut ::libc::c_char) -> MagickBooleanType; + pub fn ListMagickResourceInfo(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn RelinquishUniqueFileResource(arg1: *const ::libc::c_char) + -> MagickBooleanType; + pub fn ResourceComponentGenesis() -> MagickBooleanType; + pub fn SetMagickResourceLimit(arg1: ResourceType, arg2: MagickSizeType) + -> MagickBooleanType; + pub fn GetMagickResource(arg1: ResourceType) -> MagickSizeType; + pub fn GetMagickResourceLimit(arg1: ResourceType) -> MagickSizeType; + pub fn AsynchronousResourceComponentTerminus(); + pub fn RelinquishMagickResource(arg1: ResourceType, arg2: MagickSizeType); + pub fn ResourceComponentTerminus(); + pub fn GetImageDynamicThreshold(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut MagickPixelPacket, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn SegmentImage(arg1: *mut Image, arg2: ColorspaceType, + arg3: MagickBooleanType, arg4: f64, arg5: f64) + -> MagickBooleanType; + pub fn DeskewImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn IntegralRotateImage(arg1: *const Image, arg2: size_t, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ShearImage(arg1: *const Image, arg2: f64, arg3: f64, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ShearRotateImage(arg1: *const Image, arg2: f64, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn SignatureImage(arg1: *mut Image) -> MagickBooleanType; + pub fn AddValueToSplayTree(arg1: *mut SplayTreeInfo, + arg2: *const ::libc::c_void, + arg3: *const ::libc::c_void) + -> MagickBooleanType; + pub fn DeleteNodeByValueFromSplayTree(arg1: *mut SplayTreeInfo, + arg2: *const ::libc::c_void) + -> MagickBooleanType; + pub fn DeleteNodeFromSplayTree(arg1: *mut SplayTreeInfo, + arg2: *const ::libc::c_void) + -> MagickBooleanType; + pub fn GetNextKeyInSplayTree(arg1: *mut SplayTreeInfo) + -> *const ::libc::c_void; + pub fn GetNextValueInSplayTree(arg1: *mut SplayTreeInfo) + -> *const ::libc::c_void; + pub fn GetValueFromSplayTree(arg1: *mut SplayTreeInfo, + arg2: *const ::libc::c_void) + -> *const ::libc::c_void; + pub fn CompareSplayTreeString(arg1: *const ::libc::c_void, + arg2: *const ::libc::c_void) + -> ::libc::c_int; + pub fn CompareSplayTreeStringInfo(arg1: *const ::libc::c_void, + arg2: *const ::libc::c_void) + -> ::libc::c_int; + pub fn CloneSplayTree(arg1: *mut SplayTreeInfo, + arg2: + ::std::option::Option + *mut ::libc::c_void>, + arg3: + ::std::option::Option + *mut ::libc::c_void>) + -> *mut SplayTreeInfo; + pub fn DestroySplayTree(arg1: *mut SplayTreeInfo) -> *mut SplayTreeInfo; + pub fn NewSplayTree(arg1: + ::std::option::Option ::libc::c_int>, + arg2: + ::std::option::Option *mut ::libc::c_void>, + arg3: + ::std::option::Option *mut ::libc::c_void>) + -> *mut SplayTreeInfo; + pub fn GetNumberOfNodesInSplayTree(arg1: *const SplayTreeInfo) -> size_t; + pub fn RemoveNodeByValueFromSplayTree(arg1: *mut SplayTreeInfo, + arg2: *const ::libc::c_void) + -> *mut ::libc::c_void; + pub fn RemoveNodeFromSplayTree(arg1: *mut SplayTreeInfo, + arg2: *const ::libc::c_void) + -> *mut ::libc::c_void; + pub fn ResetSplayTree(arg1: *mut SplayTreeInfo); + pub fn ResetSplayTreeIterator(arg1: *mut SplayTreeInfo); + pub fn Tokenizer(arg1: *mut TokenInfo, arg2: ::libc::c_uint, + arg3: *mut ::libc::c_char, arg4: size_t, + arg5: *const ::libc::c_char, arg6: *const ::libc::c_char, + arg7: *const ::libc::c_char, arg8: *const ::libc::c_char, + arg9: ::libc::c_char, arg10: *mut ::libc::c_char, + arg11: *mut ::libc::c_int, arg12: *mut ::libc::c_char) + -> ::libc::c_int; + pub fn GlobExpression(arg1: *const ::libc::c_char, + arg2: *const ::libc::c_char, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn IsGlob(arg1: *const ::libc::c_char) -> MagickBooleanType; + pub fn IsMagickTrue(arg1: *const ::libc::c_char) -> MagickBooleanType; + pub fn AcquireTokenInfo() -> *mut TokenInfo; + pub fn DestroyTokenInfo(arg1: *mut TokenInfo) -> *mut TokenInfo; + pub fn GetNextToken(arg1: *const ::libc::c_char, + arg2: *mut *const ::libc::c_char, arg3: size_t, + arg4: *mut ::libc::c_char); + pub fn AutoOrientImage(arg1: *const Image, arg2: OrientationType, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ChopImage(arg1: *const Image, arg2: *const RectangleInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ConsolidateCMYKImages(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn CropImage(arg1: *const Image, arg2: *const RectangleInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn CropImageToTiles(arg1: *const Image, arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ExcerptImage(arg1: *const Image, arg2: *const RectangleInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ExtentImage(arg1: *const Image, arg2: *const RectangleInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn FlipImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn FlopImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn RollImage(arg1: *const Image, arg2: ssize_t, arg3: ssize_t, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ShaveImage(arg1: *const Image, arg2: *const RectangleInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn SpliceImage(arg1: *const Image, arg2: *const RectangleInfo, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn TransposeImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn TransverseImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn TrimImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn TransformImage(arg1: *mut *mut Image, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) -> MagickBooleanType; + pub fn TransformImages(arg1: *mut *mut Image, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) -> MagickBooleanType; + pub fn AdaptiveThresholdImage(arg1: *const Image, arg2: size_t, + arg3: size_t, arg4: ssize_t, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn DestroyThresholdMap(arg1: *mut ThresholdMap) -> *mut ThresholdMap; + pub fn GetThresholdMap(arg1: *const ::libc::c_char, + arg2: *mut ExceptionInfo) -> *mut ThresholdMap; + pub fn BilevelImage(arg1: *mut Image, arg2: f64) -> MagickBooleanType; + pub fn BilevelImageChannel(arg1: *mut Image, arg2: ChannelType, arg3: f64) + -> MagickBooleanType; + pub fn BlackThresholdImage(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn BlackThresholdImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ClampImage(arg1: *mut Image) -> MagickBooleanType; + pub fn ClampImageChannel(arg1: *mut Image, arg2: ChannelType) + -> MagickBooleanType; + pub fn ListThresholdMaps(arg1: *mut FILE, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn OrderedDitherImage(arg1: *mut Image) -> MagickBooleanType; + pub fn OrderedDitherImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn OrderedPosterizeImage(arg1: *mut Image, + arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn OrderedPosterizeImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn PerceptibleImage(arg1: *mut Image, arg2: f64) -> MagickBooleanType; + pub fn PerceptibleImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: f64) -> MagickBooleanType; + pub fn RandomThresholdImage(arg1: *mut Image, arg2: *const ::libc::c_char, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn RandomThresholdImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn WhiteThresholdImage(arg1: *mut Image, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn WhiteThresholdImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: *const ::libc::c_char, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn Base64Encode(arg1: *const ::libc::c_uchar, arg2: size_t, + arg3: *mut size_t) -> *mut ::libc::c_char; + pub fn GetPathComponents(arg1: *const ::libc::c_char, arg2: *mut size_t) + -> *mut *mut ::libc::c_char; + pub fn ListFiles(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char, + arg3: *mut size_t) -> *mut *mut ::libc::c_char; + pub fn AcquireUniqueFilename(arg1: *mut ::libc::c_char) + -> MagickBooleanType; + pub fn AcquireUniqueSymbolicLink(arg1: *const ::libc::c_char, + arg2: *mut ::libc::c_char) + -> MagickBooleanType; + pub fn ExpandFilenames(arg1: *mut ::libc::c_int, + arg2: *mut *mut *mut ::libc::c_char) + -> MagickBooleanType; + pub fn GetPathAttributes(arg1: *const ::libc::c_char, + arg2: *mut ::libc::c_void) -> MagickBooleanType; + pub fn GetExecutionPath(arg1: *mut ::libc::c_char, arg2: size_t) + -> MagickBooleanType; + pub fn IsPathAccessible(arg1: *const ::libc::c_char) -> MagickBooleanType; + pub fn MultilineCensus(arg1: *const ::libc::c_char) -> size_t; + pub fn GetMagickPageSize() -> ssize_t; + pub fn Base64Decode(arg1: *const ::libc::c_char, arg2: *mut size_t) + -> *mut ::libc::c_uchar; + pub fn AppendImageFormat(arg1: *const ::libc::c_char, + arg2: *mut ::libc::c_char); + pub fn ChopPathComponents(arg1: *mut ::libc::c_char, arg2: size_t); + pub fn ExpandFilename(arg1: *mut ::libc::c_char); + pub fn GetPathComponent(arg1: *const ::libc::c_char, arg2: PathType, + arg3: *mut ::libc::c_char); + pub fn MagickDelay(arg1: MagickSizeType); + pub fn ConnectedComponentsImage(arg1: *const Image, arg2: size_t, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn CanonicalXMLContent(arg1: *const ::libc::c_char, + arg2: MagickBooleanType) + -> *mut ::libc::c_char; + pub fn XMLTreeInfoToXML(arg1: *mut XMLTreeInfo) -> *mut ::libc::c_char; + pub fn GetXMLTreeAttribute(arg1: *mut XMLTreeInfo, + arg2: *const ::libc::c_char) + -> *const ::libc::c_char; + pub fn GetXMLTreeContent(arg1: *mut XMLTreeInfo) -> *const ::libc::c_char; + pub fn GetXMLTreeProcessingInstructions(arg1: *mut XMLTreeInfo, + arg2: *const ::libc::c_char) + -> *mut *const ::libc::c_char; + pub fn GetXMLTreeTag(arg1: *mut XMLTreeInfo) -> *const ::libc::c_char; + pub fn GetXMLTreeAttributes(arg1: *const XMLTreeInfo, + arg2: *mut SplayTreeInfo) + -> MagickBooleanType; + pub fn AddChildToXMLTree(arg1: *mut XMLTreeInfo, + arg2: *const ::libc::c_char, arg3: size_t) + -> *mut XMLTreeInfo; + pub fn AddPathToXMLTree(arg1: *mut XMLTreeInfo, + arg2: *const ::libc::c_char, arg3: size_t) + -> *mut XMLTreeInfo; + pub fn DestroyXMLTree(arg1: *mut XMLTreeInfo) -> *mut XMLTreeInfo; + pub fn GetNextXMLTreeTag(arg1: *mut XMLTreeInfo) -> *mut XMLTreeInfo; + pub fn GetXMLTreeChild(arg1: *mut XMLTreeInfo, + arg2: *const ::libc::c_char) -> *mut XMLTreeInfo; + pub fn GetXMLTreeOrdered(arg1: *mut XMLTreeInfo) -> *mut XMLTreeInfo; + pub fn GetXMLTreePath(arg1: *mut XMLTreeInfo, arg2: *const ::libc::c_char) + -> *mut XMLTreeInfo; + pub fn GetXMLTreeSibling(arg1: *mut XMLTreeInfo) -> *mut XMLTreeInfo; + pub fn InsertTagIntoXMLTree(arg1: *mut XMLTreeInfo, + arg2: *mut XMLTreeInfo, arg3: size_t) + -> *mut XMLTreeInfo; + pub fn NewXMLTree(arg1: *const ::libc::c_char, arg2: *mut ExceptionInfo) + -> *mut XMLTreeInfo; + pub fn NewXMLTreeTag(arg1: *const ::libc::c_char) -> *mut XMLTreeInfo; + pub fn ParseTagFromXMLTree(arg1: *mut XMLTreeInfo) -> *mut XMLTreeInfo; + pub fn PruneTagFromXMLTree(arg1: *mut XMLTreeInfo) -> *mut XMLTreeInfo; + pub fn SetXMLTreeAttribute(arg1: *mut XMLTreeInfo, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) + -> *mut XMLTreeInfo; + pub fn SetXMLTreeContent(arg1: *mut XMLTreeInfo, + arg2: *const ::libc::c_char) -> *mut XMLTreeInfo; + pub fn XImportImage(arg1: *const ImageInfo, arg2: *mut XImportInfo) + -> *mut Image; + pub fn XGetImportInfo(arg1: *mut XImportInfo); + pub fn AnimateImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn CompareImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn CompositeImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ConjureImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn ConvertImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn PixelGetColorAsNormalizedString(arg1: *const PixelWand) + -> *mut ::libc::c_char; + pub fn PixelGetColorAsString(arg1: *const PixelWand) + -> *mut ::libc::c_char; + pub fn PixelGetException(arg1: *const PixelWand, arg2: *mut ExceptionType) + -> *mut ::libc::c_char; + pub fn PixelGetAlpha(arg1: *const PixelWand) -> f64; + pub fn PixelGetBlack(arg1: *const PixelWand) -> f64; + pub fn PixelGetBlue(arg1: *const PixelWand) -> f64; + pub fn PixelGetCyan(arg1: *const PixelWand) -> f64; + pub fn PixelGetFuzz(arg1: *const PixelWand) -> f64; + pub fn PixelGetGreen(arg1: *const PixelWand) -> f64; + pub fn PixelGetMagenta(arg1: *const PixelWand) -> f64; + pub fn PixelGetOpacity(arg1: *const PixelWand) -> f64; + pub fn PixelGetRed(arg1: *const PixelWand) -> f64; + pub fn PixelGetYellow(arg1: *const PixelWand) -> f64; + pub fn PixelGetExceptionType(arg1: *const PixelWand) -> ExceptionType; + pub fn PixelGetIndex(arg1: *const PixelWand) -> IndexPacket; + pub fn IsPixelWand(arg1: *const PixelWand) -> MagickBooleanType; + pub fn IsPixelWandSimilar(arg1: *mut PixelWand, arg2: *mut PixelWand, + arg3: f64) -> MagickBooleanType; + pub fn PixelClearException(arg1: *mut PixelWand) -> MagickBooleanType; + pub fn PixelSetColor(arg1: *mut PixelWand, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn ClonePixelWand(arg1: *const PixelWand) -> *mut PixelWand; + pub fn ClonePixelWands(arg1: *mut *const PixelWand, arg2: size_t) + -> *mut *mut PixelWand; + pub fn DestroyPixelWand(arg1: *mut PixelWand) -> *mut PixelWand; + pub fn DestroyPixelWands(arg1: *mut *mut PixelWand, arg2: size_t) + -> *mut *mut PixelWand; + pub fn NewPixelWand() -> *mut PixelWand; + pub fn NewPixelWands(arg1: size_t) -> *mut *mut PixelWand; + pub fn PixelGetAlphaQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetBlackQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetBlueQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetCyanQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetGreenQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetMagentaQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetOpacityQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetRedQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetYellowQuantum(arg1: *const PixelWand) -> Quantum; + pub fn PixelGetColorCount(arg1: *const PixelWand) -> size_t; + pub fn ClearPixelWand(arg1: *mut PixelWand); + pub fn PixelGetHSL(arg1: *const PixelWand, arg2: *mut f64, arg3: *mut f64, + arg4: *mut f64); + pub fn PixelGetMagickColor(arg1: *const PixelWand, + arg2: *mut MagickPixelPacket); + pub fn PixelGetQuantumColor(arg1: *const PixelWand, + arg2: *mut PixelPacket); + pub fn PixelSetAlpha(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetAlphaQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn PixelSetBlack(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetBlackQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn PixelSetBlue(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetBlueQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn PixelSetColorFromWand(arg1: *mut PixelWand, + arg2: *const PixelWand); + pub fn PixelSetColorCount(arg1: *mut PixelWand, arg2: size_t); + pub fn PixelSetCyan(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetCyanQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn PixelSetFuzz(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetGreen(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetGreenQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn PixelSetHSL(arg1: *mut PixelWand, arg2: f64, arg3: f64, arg4: f64); + pub fn PixelSetIndex(arg1: *mut PixelWand, arg2: IndexPacket); + pub fn PixelSetMagenta(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetMagentaQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn PixelSetMagickColor(arg1: *mut PixelWand, + arg2: *const MagickPixelPacket); + pub fn PixelSetOpacity(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetOpacityQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn PixelSetQuantumColor(arg1: *mut PixelWand, + arg2: *const PixelPacket); + pub fn PixelSetRed(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetRedQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn PixelSetYellow(arg1: *mut PixelWand, arg2: f64); + pub fn PixelSetYellowQuantum(arg1: *mut PixelWand, arg2: Quantum); + pub fn DrawGetTextAlignment(arg1: *const DrawingWand) -> AlignType; + pub fn DrawGetClipPath(arg1: *const DrawingWand) -> *mut ::libc::c_char; + pub fn DrawGetDensity(arg1: *const DrawingWand) -> *mut ::libc::c_char; + pub fn DrawGetException(arg1: *const DrawingWand, + arg2: *mut ExceptionType) -> *mut ::libc::c_char; + pub fn DrawGetFont(arg1: *const DrawingWand) -> *mut ::libc::c_char; + pub fn DrawGetFontFamily(arg1: *const DrawingWand) -> *mut ::libc::c_char; + pub fn DrawGetTextEncoding(arg1: *const DrawingWand) + -> *mut ::libc::c_char; + pub fn DrawGetVectorGraphics(arg1: *mut DrawingWand) + -> *mut ::libc::c_char; + pub fn DrawGetClipUnits(arg1: *const DrawingWand) -> ClipPathUnits; + pub fn DrawGetTextDecoration(arg1: *const DrawingWand) -> DecorationType; + pub fn DrawGetTextDirection(arg1: *const DrawingWand) -> DirectionType; + pub fn DrawGetFillOpacity(arg1: *const DrawingWand) -> f64; + pub fn DrawGetFontSize(arg1: *const DrawingWand) -> f64; + pub fn DrawGetOpacity(arg1: *const DrawingWand) -> f64; + pub fn DrawGetStrokeDashArray(arg1: *const DrawingWand, arg2: *mut size_t) + -> *mut f64; + pub fn DrawGetStrokeDashOffset(arg1: *const DrawingWand) -> f64; + pub fn DrawGetStrokeOpacity(arg1: *const DrawingWand) -> f64; + pub fn DrawGetStrokeWidth(arg1: *const DrawingWand) -> f64; + pub fn DrawGetTextKerning(arg1: *mut DrawingWand) -> f64; + pub fn DrawGetTextInterlineSpacing(arg1: *mut DrawingWand) -> f64; + pub fn DrawGetTextInterwordSpacing(arg1: *mut DrawingWand) -> f64; + pub fn PeekDrawingWand(arg1: *const DrawingWand) -> *mut DrawInfo; + pub fn AcquireDrawingWand(arg1: *const DrawInfo, arg2: *mut Image) + -> *mut DrawingWand; + pub fn CloneDrawingWand(arg1: *const DrawingWand) -> *mut DrawingWand; + pub fn DestroyDrawingWand(arg1: *mut DrawingWand) -> *mut DrawingWand; + pub fn NewDrawingWand() -> *mut DrawingWand; + pub fn DrawGetExceptionType(arg1: *const DrawingWand) -> ExceptionType; + pub fn DrawGetClipRule(arg1: *const DrawingWand) -> FillRule; + pub fn DrawGetFillRule(arg1: *const DrawingWand) -> FillRule; + pub fn DrawGetGravity(arg1: *const DrawingWand) -> GravityType; + pub fn DrawGetStrokeLineCap(arg1: *const DrawingWand) -> LineCap; + pub fn DrawGetStrokeLineJoin(arg1: *const DrawingWand) -> LineJoin; + pub fn DrawClearException(arg1: *mut DrawingWand) -> MagickBooleanType; + pub fn DrawComposite(arg1: *mut DrawingWand, arg2: CompositeOperator, + arg3: f64, arg4: f64, arg5: f64, arg6: f64, + arg7: *mut MagickWand) -> MagickBooleanType; + pub fn DrawGetFontResolution(arg1: *const DrawingWand, arg2: *mut f64, + arg3: *mut f64) -> MagickBooleanType; + pub fn DrawGetStrokeAntialias(arg1: *const DrawingWand) + -> MagickBooleanType; + pub fn DrawGetTextAntialias(arg1: *const DrawingWand) + -> MagickBooleanType; + pub fn DrawPopPattern(arg1: *mut DrawingWand) -> MagickBooleanType; + pub fn DrawPushPattern(arg1: *mut DrawingWand, + arg2: *const ::libc::c_char, arg3: f64, arg4: f64, + arg5: f64, arg6: f64) -> MagickBooleanType; + pub fn DrawRender(arg1: *mut DrawingWand) -> MagickBooleanType; + pub fn DrawSetClipPath(arg1: *mut DrawingWand, + arg2: *const ::libc::c_char) -> MagickBooleanType; + pub fn DrawSetDensity(arg1: *mut DrawingWand, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DrawSetFillPatternURL(arg1: *mut DrawingWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DrawSetFont(arg1: *mut DrawingWand, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DrawSetFontFamily(arg1: *mut DrawingWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DrawSetFontResolution(arg1: *mut DrawingWand, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn DrawSetStrokeDashArray(arg1: *mut DrawingWand, arg2: size_t, + arg3: *const f64) -> MagickBooleanType; + pub fn DrawSetStrokePatternURL(arg1: *mut DrawingWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn DrawSetVectorGraphics(arg1: *mut DrawingWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn IsDrawingWand(arg1: *const DrawingWand) -> MagickBooleanType; + pub fn PopDrawingWand(arg1: *mut DrawingWand) -> MagickBooleanType; + pub fn PushDrawingWand(arg1: *mut DrawingWand) -> MagickBooleanType; + pub fn DrawGetFontStretch(arg1: *const DrawingWand) -> StretchType; + pub fn DrawGetFontStyle(arg1: *const DrawingWand) -> StyleType; + pub fn DrawGetFontWeight(arg1: *const DrawingWand) -> size_t; + pub fn DrawGetStrokeMiterLimit(arg1: *const DrawingWand) -> size_t; + pub fn ClearDrawingWand(arg1: *mut DrawingWand); + pub fn DrawAffine(arg1: *mut DrawingWand, arg2: *const AffineMatrix); + pub fn DrawAnnotation(arg1: *mut DrawingWand, arg2: f64, arg3: f64, + arg4: *const ::libc::c_uchar); + pub fn DrawArc(arg1: *mut DrawingWand, arg2: f64, arg3: f64, arg4: f64, + arg5: f64, arg6: f64, arg7: f64); + pub fn DrawBezier(arg1: *mut DrawingWand, arg2: size_t, + arg3: *const PointInfo); + pub fn DrawGetBorderColor(arg1: *const DrawingWand, arg2: *mut PixelWand); + pub fn DrawCircle(arg1: *mut DrawingWand, arg2: f64, arg3: f64, arg4: f64, + arg5: f64); + pub fn DrawColor(arg1: *mut DrawingWand, arg2: f64, arg3: f64, + arg4: PaintMethod); + pub fn DrawComment(arg1: *mut DrawingWand, arg2: *const ::libc::c_char); + pub fn DrawEllipse(arg1: *mut DrawingWand, arg2: f64, arg3: f64, + arg4: f64, arg5: f64, arg6: f64, arg7: f64); + pub fn DrawGetFillColor(arg1: *const DrawingWand, arg2: *mut PixelWand); + pub fn DrawGetStrokeColor(arg1: *const DrawingWand, arg2: *mut PixelWand); + pub fn DrawSetTextKerning(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSetTextInterlineSpacing(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSetTextInterwordSpacing(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawGetTextUnderColor(arg1: *const DrawingWand, + arg2: *mut PixelWand); + pub fn DrawLine(arg1: *mut DrawingWand, arg2: f64, arg3: f64, arg4: f64, + arg5: f64); + pub fn DrawMatte(arg1: *mut DrawingWand, arg2: f64, arg3: f64, + arg4: PaintMethod); + pub fn DrawPathClose(arg1: *mut DrawingWand); + pub fn DrawPathCurveToAbsolute(arg1: *mut DrawingWand, arg2: f64, + arg3: f64, arg4: f64, arg5: f64, arg6: f64, + arg7: f64); + pub fn DrawPathCurveToRelative(arg1: *mut DrawingWand, arg2: f64, + arg3: f64, arg4: f64, arg5: f64, arg6: f64, + arg7: f64); + pub fn DrawPathCurveToQuadraticBezierAbsolute(arg1: *mut DrawingWand, + arg2: f64, arg3: f64, + arg4: f64, arg5: f64); + pub fn DrawPathCurveToQuadraticBezierRelative(arg1: *mut DrawingWand, + arg2: f64, arg3: f64, + arg4: f64, arg5: f64); + pub fn DrawPathCurveToQuadraticBezierSmoothAbsolute(arg1: + *mut DrawingWand, + arg2: f64, arg3: f64); + pub fn DrawPathCurveToQuadraticBezierSmoothRelative(arg1: + *mut DrawingWand, + arg2: f64, arg3: f64); + pub fn DrawPathCurveToSmoothAbsolute(arg1: *mut DrawingWand, arg2: f64, + arg3: f64, arg4: f64, arg5: f64); + pub fn DrawPathCurveToSmoothRelative(arg1: *mut DrawingWand, arg2: f64, + arg3: f64, arg4: f64, arg5: f64); + pub fn DrawPathEllipticArcAbsolute(arg1: *mut DrawingWand, arg2: f64, + arg3: f64, arg4: f64, + arg5: MagickBooleanType, + arg6: MagickBooleanType, arg7: f64, + arg8: f64); + pub fn DrawPathEllipticArcRelative(arg1: *mut DrawingWand, arg2: f64, + arg3: f64, arg4: f64, + arg5: MagickBooleanType, + arg6: MagickBooleanType, arg7: f64, + arg8: f64); + pub fn DrawPathFinish(arg1: *mut DrawingWand); + pub fn DrawPathLineToAbsolute(arg1: *mut DrawingWand, arg2: f64, + arg3: f64); + pub fn DrawPathLineToRelative(arg1: *mut DrawingWand, arg2: f64, + arg3: f64); + pub fn DrawPathLineToHorizontalAbsolute(arg1: *mut DrawingWand, + arg2: f64); + pub fn DrawPathLineToHorizontalRelative(arg1: *mut DrawingWand, + arg2: f64); + pub fn DrawPathLineToVerticalAbsolute(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawPathLineToVerticalRelative(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawPathMoveToAbsolute(arg1: *mut DrawingWand, arg2: f64, + arg3: f64); + pub fn DrawPathMoveToRelative(arg1: *mut DrawingWand, arg2: f64, + arg3: f64); + pub fn DrawPathStart(arg1: *mut DrawingWand); + pub fn DrawPoint(arg1: *mut DrawingWand, arg2: f64, arg3: f64); + pub fn DrawPolygon(arg1: *mut DrawingWand, arg2: size_t, + arg3: *const PointInfo); + pub fn DrawPolyline(arg1: *mut DrawingWand, arg2: size_t, + arg3: *const PointInfo); + pub fn DrawPopClipPath(arg1: *mut DrawingWand); + pub fn DrawPopDefs(arg1: *mut DrawingWand); + pub fn DrawPushClipPath(arg1: *mut DrawingWand, + arg2: *const ::libc::c_char); + pub fn DrawPushDefs(arg1: *mut DrawingWand); + pub fn DrawRectangle(arg1: *mut DrawingWand, arg2: f64, arg3: f64, + arg4: f64, arg5: f64); + pub fn DrawResetVectorGraphics(arg1: *mut DrawingWand); + pub fn DrawRotate(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawRoundRectangle(arg1: *mut DrawingWand, arg2: f64, arg3: f64, + arg4: f64, arg5: f64, arg6: f64, arg7: f64); + pub fn DrawScale(arg1: *mut DrawingWand, arg2: f64, arg3: f64); + pub fn DrawSetBorderColor(arg1: *mut DrawingWand, arg2: *const PixelWand); + pub fn DrawSetClipRule(arg1: *mut DrawingWand, arg2: FillRule); + pub fn DrawSetClipUnits(arg1: *mut DrawingWand, arg2: ClipPathUnits); + pub fn DrawSetFillColor(arg1: *mut DrawingWand, arg2: *const PixelWand); + pub fn DrawSetFillOpacity(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSetFillRule(arg1: *mut DrawingWand, arg2: FillRule); + pub fn DrawSetFontSize(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSetFontStretch(arg1: *mut DrawingWand, arg2: StretchType); + pub fn DrawSetFontStyle(arg1: *mut DrawingWand, arg2: StyleType); + pub fn DrawSetFontWeight(arg1: *mut DrawingWand, arg2: size_t); + pub fn DrawSetGravity(arg1: *mut DrawingWand, arg2: GravityType); + pub fn DrawSetOpacity(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSetStrokeAntialias(arg1: *mut DrawingWand, + arg2: MagickBooleanType); + pub fn DrawSetStrokeColor(arg1: *mut DrawingWand, arg2: *const PixelWand); + pub fn DrawSetStrokeDashOffset(arg1: *mut DrawingWand, dashoffset: f64); + pub fn DrawSetStrokeLineCap(arg1: *mut DrawingWand, arg2: LineCap); + pub fn DrawSetStrokeLineJoin(arg1: *mut DrawingWand, arg2: LineJoin); + pub fn DrawSetStrokeMiterLimit(arg1: *mut DrawingWand, arg2: size_t); + pub fn DrawSetStrokeOpacity(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSetStrokeWidth(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSetTextAlignment(arg1: *mut DrawingWand, arg2: AlignType); + pub fn DrawSetTextAntialias(arg1: *mut DrawingWand, + arg2: MagickBooleanType); + pub fn DrawSetTextDecoration(arg1: *mut DrawingWand, + arg2: DecorationType); + pub fn DrawSetTextDirection(arg1: *mut DrawingWand, arg2: DirectionType); + pub fn DrawSetTextEncoding(arg1: *mut DrawingWand, + arg2: *const ::libc::c_char); + pub fn DrawSetTextUnderColor(arg1: *mut DrawingWand, + arg2: *const PixelWand); + pub fn DrawSetViewbox(arg1: *mut DrawingWand, arg2: ssize_t, + arg3: ssize_t, arg4: ssize_t, arg5: ssize_t); + pub fn DrawSkewX(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSkewY(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawTranslate(arg1: *mut DrawingWand, arg2: f64, arg3: f64); + pub fn PixelGetIteratorException(arg1: *const PixelIterator, + arg2: *mut ExceptionType) + -> *mut ::libc::c_char; + pub fn PixelGetIteratorExceptionType(arg1: *const PixelIterator) + -> ExceptionType; + pub fn IsPixelIterator(arg1: *const PixelIterator) -> MagickBooleanType; + pub fn PixelClearIteratorException(arg1: *mut PixelIterator) + -> MagickBooleanType; + pub fn PixelSetIteratorRow(arg1: *mut PixelIterator, arg2: ssize_t) + -> MagickBooleanType; + pub fn PixelSyncIterator(arg1: *mut PixelIterator) -> MagickBooleanType; + pub fn ClonePixelIterator(arg1: *const PixelIterator) + -> *mut PixelIterator; + pub fn DestroyPixelIterator(arg1: *mut PixelIterator) + -> *mut PixelIterator; + pub fn NewPixelIterator(arg1: *mut MagickWand) -> *mut PixelIterator; + pub fn NewPixelRegionIterator(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t) + -> *mut PixelIterator; + pub fn PixelGetCurrentIteratorRow(arg1: *mut PixelIterator, + arg2: *mut size_t) + -> *mut *mut PixelWand; + pub fn PixelGetNextIteratorRow(arg1: *mut PixelIterator, + arg2: *mut size_t) -> *mut *mut PixelWand; + pub fn PixelGetPreviousIteratorRow(arg1: *mut PixelIterator, + arg2: *mut size_t) + -> *mut *mut PixelWand; + pub fn PixelGetIteratorRow(arg1: *mut PixelIterator) -> ssize_t; + pub fn ClearPixelIterator(arg1: *mut PixelIterator); + pub fn PixelResetIterator(arg1: *mut PixelIterator); + pub fn PixelSetFirstIteratorRow(arg1: *mut PixelIterator); + pub fn PixelSetLastIteratorRow(arg1: *mut PixelIterator); + pub fn DrawAllocateWand(arg1: *const DrawInfo, arg2: *mut Image) + -> *mut DrawingWand; + pub fn GetPixelViewException(arg1: *const PixelView, + arg2: *mut ExceptionType) + -> *mut ::libc::c_char; + pub fn DrawGetFillAlpha(arg1: *const DrawingWand) -> f64; + pub fn DrawGetStrokeAlpha(arg1: *const DrawingWand) -> f64; + pub fn DrawPeekGraphicWand(arg1: *const DrawingWand) -> *mut DrawInfo; + pub fn MagickDescribeImage(arg1: *mut MagickWand) -> *mut ::libc::c_char; + pub fn MagickGetImageAttribute(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn PixelIteratorGetException(arg1: *const PixelIterator, + arg2: *mut ExceptionType) + -> *mut ::libc::c_char; + pub fn MagickGetImageIndex(arg1: *mut MagickWand) -> ssize_t; + pub fn DuplexTransferPixelViewIterator(arg1: *mut PixelView, + arg2: *mut PixelView, + arg3: *mut PixelView, + arg4: + DuplexTransferPixelViewMethod, + arg5: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn GetPixelViewIterator(arg1: *mut PixelView, + arg2: GetPixelViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn IsPixelView(arg1: *const PixelView) -> MagickBooleanType; + pub fn MagickClipPathImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn MagickColorFloodfillImage(arg1: *mut MagickWand, + arg2: *const PixelWand, arg3: f64, + arg4: *const PixelWand, arg5: ssize_t, + arg6: ssize_t) -> MagickBooleanType; + pub fn MagickGetImageChannelExtrema(arg1: *mut MagickWand, + arg2: ChannelType, arg3: *mut size_t, + arg4: *mut size_t) + -> MagickBooleanType; + pub fn MagickGetImageExtrema(arg1: *mut MagickWand, arg2: *mut size_t, + arg3: *mut size_t) -> MagickBooleanType; + pub fn MagickGetImageMatte(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickGetImagePixels(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t, + arg6: *const ::libc::c_char, + arg7: StorageType, arg8: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn MagickMapImage(arg1: *mut MagickWand, arg2: *const MagickWand, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn MagickMatteFloodfillImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64, arg4: *const PixelWand, + arg5: ssize_t, arg6: ssize_t) + -> MagickBooleanType; + pub fn MagickMedianFilterImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickModeImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickReduceNoiseImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickRemapImage(arg1: *mut MagickWand, arg2: *const MagickWand, + arg3: DitherMethod) -> MagickBooleanType; + pub fn MagickOpaqueImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: *const PixelWand, arg4: f64) + -> MagickBooleanType; + pub fn MagickPaintFloodfillImage(arg1: *mut MagickWand, arg2: ChannelType, + arg3: *const PixelWand, arg4: f64, + arg5: *const PixelWand, arg6: ssize_t, + arg7: ssize_t) -> MagickBooleanType; + pub fn MagickPaintOpaqueImage(arg1: *mut MagickWand, + arg2: *const PixelWand, + arg3: *const PixelWand, arg4: f64) + -> MagickBooleanType; + pub fn MagickPaintOpaqueImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *const PixelWand, + arg4: *const PixelWand, arg5: f64) + -> MagickBooleanType; + pub fn MagickPaintTransparentImage(arg1: *mut MagickWand, + arg2: *const PixelWand, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickRadialBlurImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickRadialBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64) + -> MagickBooleanType; + pub fn MagickRecolorImage(arg1: *mut MagickWand, arg2: size_t, + arg3: *const f64) -> MagickBooleanType; + pub fn MagickSetImageAttribute(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetImageIndex(arg1: *mut MagickWand, arg2: ssize_t) + -> MagickBooleanType; + pub fn MagickSetImageOption(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char, + arg4: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetImagePixels(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t, + arg6: *const ::libc::c_char, + arg7: StorageType, + arg8: *const ::libc::c_void) + -> MagickBooleanType; + pub fn MagickTransparentImage(arg1: *mut MagickWand, + arg2: *const PixelWand, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn SetPixelViewIterator(arg1: *mut PixelView, + arg2: SetPixelViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn TransferPixelViewIterator(arg1: *mut PixelView, + arg2: *mut PixelView, + arg3: TransferPixelViewMethod, + arg4: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn UpdatePixelViewIterator(arg1: *mut PixelView, + arg2: UpdatePixelViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn GetPixelViewWand(arg1: *const PixelView) -> *mut MagickWand; + pub fn MagickAverageImages(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickFlattenImages(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickMaximumImages(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickMinimumImages(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickMosaicImages(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickRegionOfInterestImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: ssize_t, + arg5: ssize_t) -> *mut MagickWand; + pub fn MagickGetImageSize(arg1: *mut MagickWand) -> MagickSizeType; + pub fn ClonePixelView(arg1: *const PixelView) -> *mut PixelView; + pub fn DestroyPixelView(arg1: *mut PixelView) -> *mut PixelView; + pub fn NewPixelView(arg1: *mut MagickWand) -> *mut PixelView; + pub fn NewPixelViewRegion(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t) + -> *mut PixelView; + pub fn GetPixelViewPixels(arg1: *const PixelView) -> *mut *mut PixelWand; + pub fn PixelGetNextRow(arg1: *mut PixelIterator) -> *mut *mut PixelWand; + pub fn GetPixelViewHeight(arg1: *const PixelView) -> size_t; + pub fn GetPixelViewWidth(arg1: *const PixelView) -> size_t; + pub fn GetPixelViewX(arg1: *const PixelView) -> ssize_t; + pub fn GetPixelViewY(arg1: *const PixelView) -> ssize_t; + pub fn MagickWriteImageBlob(arg1: *mut MagickWand, arg2: *mut size_t) + -> *mut ::libc::c_uchar; + pub fn DrawPopGraphicContext(arg1: *mut DrawingWand); + pub fn DrawPushGraphicContext(arg1: *mut DrawingWand); + pub fn DrawSetFillAlpha(arg1: *mut DrawingWand, arg2: f64); + pub fn DrawSetStrokeAlpha(arg1: *mut DrawingWand, arg2: f64); + pub fn DisplayImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn IdentifyImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn ImportImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn MagickGetFilename(arg1: *const MagickWand) -> *mut ::libc::c_char; + pub fn MagickGetFormat(arg1: *mut MagickWand) -> *mut ::libc::c_char; + pub fn MagickGetFont(arg1: *mut MagickWand) -> *mut ::libc::c_char; + pub fn MagickGetHomeURL() -> *mut ::libc::c_char; + pub fn MagickGetImageArtifact(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn MagickGetImageArtifacts(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *mut size_t) + -> *mut *mut ::libc::c_char; + pub fn MagickGetImageProfiles(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *mut size_t) + -> *mut *mut ::libc::c_char; + pub fn MagickGetImageProperty(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn MagickGetImageProperties(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *mut size_t) + -> *mut *mut ::libc::c_char; + pub fn MagickGetOption(arg1: *mut MagickWand, arg2: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn MagickGetOptions(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, arg3: *mut size_t) + -> *mut *mut ::libc::c_char; + pub fn MagickQueryConfigureOption(arg1: *const ::libc::c_char) + -> *mut ::libc::c_char; + pub fn MagickQueryConfigureOptions(arg1: *const ::libc::c_char, + arg2: *mut size_t) + -> *mut *mut ::libc::c_char; + pub fn MagickQueryFonts(arg1: *const ::libc::c_char, arg2: *mut size_t) + -> *mut *mut ::libc::c_char; + pub fn MagickQueryFormats(arg1: *const ::libc::c_char, arg2: *mut size_t) + -> *mut *mut ::libc::c_char; + pub fn MagickGetColorspace(arg1: *mut MagickWand) -> ColorspaceType; + pub fn MagickGetCompression(arg1: *mut MagickWand) -> CompressionType; + pub fn MagickGetCopyright() -> *const ::libc::c_char; + pub fn MagickGetPackageName() -> *const ::libc::c_char; + pub fn MagickGetQuantumDepth(arg1: *mut size_t) -> *const ::libc::c_char; + pub fn MagickGetQuantumRange(arg1: *mut size_t) -> *const ::libc::c_char; + pub fn MagickGetReleaseDate() -> *const ::libc::c_char; + pub fn MagickGetVersion(arg1: *mut size_t) -> *const ::libc::c_char; + pub fn MagickGetPointsize(arg1: *mut MagickWand) -> f64; + pub fn MagickGetSamplingFactors(arg1: *mut MagickWand, arg2: *mut size_t) + -> *mut f64; + pub fn MagickQueryFontMetrics(arg1: *mut MagickWand, + arg2: *const DrawingWand, + arg3: *const ::libc::c_char) -> *mut f64; + pub fn MagickQueryMultilineFontMetrics(arg1: *mut MagickWand, + arg2: *const DrawingWand, + arg3: *const ::libc::c_char) + -> *mut f64; + pub fn MagickGetGravity(arg1: *mut MagickWand) -> GravityType; + pub fn MagickGetType(arg1: *mut MagickWand) -> ImageType; + pub fn MagickGetInterlaceScheme(arg1: *mut MagickWand) -> InterlaceType; + pub fn MagickGetInterpolateMethod(arg1: *mut MagickWand) + -> InterpolatePixelMethod; + pub fn MagickGetOrientation(arg1: *mut MagickWand) -> OrientationType; + pub fn MagickDeleteImageArtifact(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickDeleteImageProperty(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickDeleteOption(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickGetAntialias(arg1: *const MagickWand) -> MagickBooleanType; + pub fn MagickGetPage(arg1: *const MagickWand, arg2: *mut size_t, + arg3: *mut size_t, arg4: *mut ssize_t, + arg5: *mut ssize_t) -> MagickBooleanType; + pub fn MagickGetResolution(arg1: *const MagickWand, arg2: *mut f64, + arg3: *mut f64) -> MagickBooleanType; + pub fn MagickGetSize(arg1: *const MagickWand, arg2: *mut size_t, + arg3: *mut size_t) -> MagickBooleanType; + pub fn MagickGetSizeOffset(arg1: *const MagickWand, arg2: *mut ssize_t) + -> MagickBooleanType; + pub fn MagickProfileImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_void, arg4: size_t) + -> MagickBooleanType; + pub fn MagickSetAntialias(arg1: *mut MagickWand, arg2: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickSetBackgroundColor(arg1: *mut MagickWand, + arg2: *const PixelWand) + -> MagickBooleanType; + pub fn MagickSetColorspace(arg1: *mut MagickWand, arg2: ColorspaceType) + -> MagickBooleanType; + pub fn MagickSetCompression(arg1: *mut MagickWand, arg2: CompressionType) + -> MagickBooleanType; + pub fn MagickSetCompressionQuality(arg1: *mut MagickWand, arg2: size_t) + -> MagickBooleanType; + pub fn MagickSetDepth(arg1: *mut MagickWand, arg2: size_t) + -> MagickBooleanType; + pub fn MagickSetExtract(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) -> MagickBooleanType; + pub fn MagickSetFilename(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetFormat(arg1: *mut MagickWand, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetFont(arg1: *mut MagickWand, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetGravity(arg1: *mut MagickWand, arg2: GravityType) + -> MagickBooleanType; + pub fn MagickSetImageArtifact(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetImageProfile(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_void, arg4: size_t) + -> MagickBooleanType; + pub fn MagickSetImageProperty(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetInterlaceScheme(arg1: *mut MagickWand, + arg2: InterlaceType) -> MagickBooleanType; + pub fn MagickSetInterpolateMethod(arg1: *mut MagickWand, + arg2: InterpolatePixelMethod) + -> MagickBooleanType; + pub fn MagickSetOption(arg1: *mut MagickWand, arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) -> MagickBooleanType; + pub fn MagickSetOrientation(arg1: *mut MagickWand, arg2: OrientationType) + -> MagickBooleanType; + pub fn MagickSetPage(arg1: *mut MagickWand, arg2: size_t, arg3: size_t, + arg4: ssize_t, arg5: ssize_t) -> MagickBooleanType; + pub fn MagickSetPassphrase(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetPointsize(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickSetResolution(arg1: *mut MagickWand, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn MagickSetResourceLimit(type_: ResourceType, limit: MagickSizeType) + -> MagickBooleanType; + pub fn MagickSetSamplingFactors(arg1: *mut MagickWand, arg2: size_t, + arg3: *const f64) -> MagickBooleanType; + pub fn MagickSetSize(arg1: *mut MagickWand, arg2: size_t, arg3: size_t) + -> MagickBooleanType; + pub fn MagickSetSizeOffset(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: ssize_t) + -> MagickBooleanType; + pub fn MagickSetType(arg1: *mut MagickWand, arg2: ImageType) + -> MagickBooleanType; + pub fn MagickSetProgressMonitor(arg1: *mut MagickWand, + arg2: MagickProgressMonitor, + arg3: *mut ::libc::c_void) + -> MagickProgressMonitor; + pub fn MagickGetResource(arg1: ResourceType) -> MagickSizeType; + pub fn MagickGetResourceLimit(arg1: ResourceType) -> MagickSizeType; + pub fn MagickGetBackgroundColor(arg1: *mut MagickWand) -> *mut PixelWand; + pub fn MagickGetOrientationType(arg1: *mut MagickWand) -> OrientationType; + pub fn MagickGetCompressionQuality(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageProfile(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *mut size_t) -> *mut ::libc::c_uchar; + pub fn MagickRemoveImageProfile(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *mut size_t) + -> *mut ::libc::c_uchar; + pub fn MagickGetImageChannelFeatures(arg1: *mut MagickWand, arg2: size_t) + -> *mut ChannelFeatures; + pub fn MagickGetImageChannelStatistics(arg1: *mut MagickWand) + -> *mut ChannelStatistics; + pub fn MagickGetImageFilename(arg1: *mut MagickWand) + -> *mut ::libc::c_char; + pub fn MagickGetImageFormat(arg1: *mut MagickWand) -> *mut ::libc::c_char; + pub fn MagickGetImageSignature(arg1: *mut MagickWand) + -> *mut ::libc::c_char; + pub fn MagickIdentifyImage(arg1: *mut MagickWand) -> *mut ::libc::c_char; + pub fn MagickGetImageColorspace(arg1: *mut MagickWand) -> ColorspaceType; + pub fn MagickGetImageCompose(arg1: *mut MagickWand) -> CompositeOperator; + pub fn MagickGetImageCompression(arg1: *mut MagickWand) + -> CompressionType; + pub fn MagickGetImageDispose(arg1: *mut MagickWand) -> DisposeType; + pub fn MagickGetImageChannelDistortions(arg1: *mut MagickWand, + arg2: *const MagickWand, + arg3: MetricType) -> *mut f64; + pub fn MagickGetImageFuzz(arg1: *mut MagickWand) -> f64; + pub fn MagickGetImageGamma(arg1: *mut MagickWand) -> f64; + pub fn MagickGetImageTotalInkDensity(arg1: *mut MagickWand) -> f64; + pub fn MagickGetImageEndian(arg1: *mut MagickWand) -> EndianType; + pub fn MagickGetImageGravity(arg1: *mut MagickWand) -> GravityType; + pub fn MagickDestroyImage(arg1: *mut Image) -> *mut Image; + pub fn GetImageFromMagickWand(arg1: *const MagickWand) -> *mut Image; + pub fn MagickGetImageType(arg1: *mut MagickWand) -> ImageType; + pub fn MagickGetImageInterlaceScheme(arg1: *mut MagickWand) + -> InterlaceType; + pub fn MagickGetImageInterpolateMethod(arg1: *mut MagickWand) + -> InterpolatePixelMethod; + pub fn MagickAdaptiveBlurImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickAdaptiveBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickAdaptiveResizeImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t) -> MagickBooleanType; + pub fn MagickAdaptiveSharpenImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickAdaptiveSharpenImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickAdaptiveThresholdImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: ssize_t) + -> MagickBooleanType; + pub fn MagickAddImage(arg1: *mut MagickWand, arg2: *const MagickWand) + -> MagickBooleanType; + pub fn MagickAddNoiseImage(arg1: *mut MagickWand, arg2: NoiseType) + -> MagickBooleanType; + pub fn MagickAddNoiseImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: NoiseType) + -> MagickBooleanType; + pub fn MagickAffineTransformImage(arg1: *mut MagickWand, + arg2: *const DrawingWand) + -> MagickBooleanType; + pub fn MagickAnnotateImage(arg1: *mut MagickWand, + arg2: *const DrawingWand, arg3: f64, arg4: f64, + arg5: f64, arg6: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickAnimateImages(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickAutoGammaImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickAutoGammaImageChannel(arg1: *mut MagickWand, + arg2: ChannelType) + -> MagickBooleanType; + pub fn MagickAutoLevelImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickAutoLevelImageChannel(arg1: *mut MagickWand, + arg2: ChannelType) + -> MagickBooleanType; + pub fn MagickAutoOrientImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickBlackThresholdImage(arg1: *mut MagickWand, + arg2: *const PixelWand) + -> MagickBooleanType; + pub fn MagickBlueShiftImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickBlurImage(arg1: *mut MagickWand, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn MagickBlurImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: f64, arg4: f64) -> MagickBooleanType; + pub fn MagickBorderImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: size_t, arg4: size_t) -> MagickBooleanType; + pub fn MagickBrightnessContrastImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickBrightnessContrastImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64) + -> MagickBooleanType; + pub fn MagickCharcoalImage(arg1: *mut MagickWand, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn MagickChopImage(arg1: *mut MagickWand, arg2: size_t, arg3: size_t, + arg4: ssize_t, arg5: ssize_t) -> MagickBooleanType; + pub fn MagickClampImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickClampImageChannel(arg1: *mut MagickWand, arg2: ChannelType) + -> MagickBooleanType; + pub fn MagickClipImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickClipImagePath(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn MagickClutImage(arg1: *mut MagickWand, arg2: *const MagickWand) + -> MagickBooleanType; + pub fn MagickClutImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: *const MagickWand) + -> MagickBooleanType; + pub fn MagickColorDecisionListImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickColorizeImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: *const PixelWand) -> MagickBooleanType; + pub fn MagickColorMatrixImage(arg1: *mut MagickWand, + arg2: *const KernelInfo) + -> MagickBooleanType; + pub fn MagickCommentImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickCompositeImage(arg1: *mut MagickWand, + arg2: *const MagickWand, + arg3: CompositeOperator, arg4: ssize_t, + arg5: ssize_t) -> MagickBooleanType; + pub fn MagickCompositeImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *const MagickWand, + arg4: CompositeOperator, arg5: ssize_t, + arg6: ssize_t) -> MagickBooleanType; + pub fn MagickCompositeImageGravity(arg1: *mut MagickWand, + arg2: *const MagickWand, + arg3: CompositeOperator, + arg4: GravityType) + -> MagickBooleanType; + pub fn MagickCompositeLayers(arg1: *mut MagickWand, + arg2: *const MagickWand, + arg3: CompositeOperator, arg4: ssize_t, + arg5: ssize_t) -> MagickBooleanType; + pub fn MagickConstituteImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: *const ::libc::c_char, + arg5: StorageType, + arg6: *const ::libc::c_void) + -> MagickBooleanType; + pub fn MagickContrastImage(arg1: *mut MagickWand, arg2: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickContrastStretchImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickContrastStretchImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickConvolveImage(arg1: *mut MagickWand, arg2: size_t, + arg3: *const f64) -> MagickBooleanType; + pub fn MagickConvolveImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: size_t, + arg4: *const f64) -> MagickBooleanType; + pub fn MagickCropImage(arg1: *mut MagickWand, arg2: size_t, arg3: size_t, + arg4: ssize_t, arg5: ssize_t) -> MagickBooleanType; + pub fn MagickCycleColormapImage(arg1: *mut MagickWand, arg2: ssize_t) + -> MagickBooleanType; + pub fn MagickDecipherImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickDeskewImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickDespeckleImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickDisplayImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickDisplayImages(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickDistortImage(arg1: *mut MagickWand, arg2: DistortImageMethod, + arg3: size_t, arg4: *const f64, + arg5: MagickBooleanType) -> MagickBooleanType; + pub fn MagickDrawImage(arg1: *mut MagickWand, arg2: *const DrawingWand) + -> MagickBooleanType; + pub fn MagickEdgeImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickEmbossImage(arg1: *mut MagickWand, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn MagickEncipherImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickEnhanceImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickEqualizeImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickEqualizeImageChannel(arg1: *mut MagickWand, + arg2: ChannelType) -> MagickBooleanType; + pub fn MagickEvaluateImage(arg1: *mut MagickWand, + arg2: MagickEvaluateOperator, arg3: f64) + -> MagickBooleanType; + pub fn MagickEvaluateImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: MagickEvaluateOperator, arg4: f64) + -> MagickBooleanType; + pub fn MagickExportImagePixels(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t, + arg6: *const ::libc::c_char, + arg7: StorageType, + arg8: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn MagickExtentImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: ssize_t, arg5: ssize_t) + -> MagickBooleanType; + pub fn MagickFilterImage(arg1: *mut MagickWand, arg2: *const KernelInfo) + -> MagickBooleanType; + pub fn MagickFilterImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: *const KernelInfo) + -> MagickBooleanType; + pub fn MagickFlipImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickFloodfillPaintImage(arg1: *mut MagickWand, arg2: ChannelType, + arg3: *const PixelWand, arg4: f64, + arg5: *const PixelWand, arg6: ssize_t, + arg7: ssize_t, arg8: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickFlopImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickForwardFourierTransformImage(arg1: *mut MagickWand, + arg2: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickFrameImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: size_t, arg4: size_t, arg5: ssize_t, + arg6: ssize_t) -> MagickBooleanType; + pub fn MagickFunctionImage(arg1: *mut MagickWand, arg2: MagickFunction, + arg3: size_t, arg4: *const f64) + -> MagickBooleanType; + pub fn MagickFunctionImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: MagickFunction, + arg4: size_t, arg5: *const f64) + -> MagickBooleanType; + pub fn MagickGammaImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickGammaImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: f64) -> MagickBooleanType; + pub fn MagickGaussianBlurImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickGaussianBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickGetImageAlphaChannel(arg1: *mut MagickWand) + -> MagickBooleanType; + pub fn MagickGetImageBackgroundColor(arg1: *mut MagickWand, + arg2: *mut PixelWand) + -> MagickBooleanType; + pub fn MagickGetImageBluePrimary(arg1: *mut MagickWand, arg2: *mut f64, + arg3: *mut f64) -> MagickBooleanType; + pub fn MagickGetImageBorderColor(arg1: *mut MagickWand, + arg2: *mut PixelWand) + -> MagickBooleanType; + pub fn MagickGetImageChannelDistortion(arg1: *mut MagickWand, + arg2: *const MagickWand, + arg3: ChannelType, + arg4: MetricType, arg5: *mut f64) + -> MagickBooleanType; + pub fn MagickGetImageChannelKurtosis(arg1: *mut MagickWand, + arg2: ChannelType, arg3: *mut f64, + arg4: *mut f64) -> MagickBooleanType; + pub fn MagickGetImageChannelMean(arg1: *mut MagickWand, arg2: ChannelType, + arg3: *mut f64, arg4: *mut f64) + -> MagickBooleanType; + pub fn MagickGetImageChannelRange(arg1: *mut MagickWand, + arg2: ChannelType, arg3: *mut f64, + arg4: *mut f64) -> MagickBooleanType; + pub fn MagickGetImageColormapColor(arg1: *mut MagickWand, arg2: size_t, + arg3: *mut PixelWand) + -> MagickBooleanType; + pub fn MagickGetImageDistortion(arg1: *mut MagickWand, + arg2: *const MagickWand, arg3: MetricType, + arg4: *mut f64) -> MagickBooleanType; + pub fn MagickGetImageGreenPrimary(arg1: *mut MagickWand, arg2: *mut f64, + arg3: *mut f64) -> MagickBooleanType; + pub fn MagickGetImageMatteColor(arg1: *mut MagickWand, + arg2: *mut PixelWand) + -> MagickBooleanType; + pub fn MagickGetImageLength(arg1: *mut MagickWand, + arg2: *mut MagickSizeType) + -> MagickBooleanType; + pub fn MagickGetImagePage(arg1: *mut MagickWand, arg2: *mut size_t, + arg3: *mut size_t, arg4: *mut ssize_t, + arg5: *mut ssize_t) -> MagickBooleanType; + pub fn MagickGetImagePixelColor(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t, arg4: *mut PixelWand) + -> MagickBooleanType; + pub fn MagickGetImageRange(arg1: *mut MagickWand, arg2: *mut f64, + arg3: *mut f64) -> MagickBooleanType; + pub fn MagickGetImageRedPrimary(arg1: *mut MagickWand, arg2: *mut f64, + arg3: *mut f64) -> MagickBooleanType; + pub fn MagickGetImageResolution(arg1: *mut MagickWand, arg2: *mut f64, + arg3: *mut f64) -> MagickBooleanType; + pub fn MagickGetImageWhitePoint(arg1: *mut MagickWand, arg2: *mut f64, + arg3: *mut f64) -> MagickBooleanType; + pub fn MagickHaldClutImage(arg1: *mut MagickWand, arg2: *const MagickWand) + -> MagickBooleanType; + pub fn MagickHaldClutImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *const MagickWand) + -> MagickBooleanType; + pub fn MagickHasNextImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickHasPreviousImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickImplodeImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickImportImagePixels(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t, + arg6: *const ::libc::c_char, + arg7: StorageType, + arg8: *const ::libc::c_void) + -> MagickBooleanType; + pub fn MagickInverseFourierTransformImage(arg1: *mut MagickWand, + arg2: *mut MagickWand, + arg3: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickLabelImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) -> MagickBooleanType; + pub fn MagickLevelImage(arg1: *mut MagickWand, arg2: f64, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickLevelImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: f64, arg4: f64, arg5: f64) + -> MagickBooleanType; + pub fn MagickLinearStretchImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickLiquidRescaleImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: f64, arg5: f64) + -> MagickBooleanType; + pub fn MagickLocalContrastImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickMagnifyImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickMinifyImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickModulateImage(arg1: *mut MagickWand, arg2: f64, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickMorphologyImage(arg1: *mut MagickWand, + arg2: MorphologyMethod, arg3: ssize_t, + arg4: *mut KernelInfo) -> MagickBooleanType; + pub fn MagickMorphologyImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: MorphologyMethod, arg4: ssize_t, + arg5: *mut KernelInfo) + -> MagickBooleanType; + pub fn MagickMotionBlurImage(arg1: *mut MagickWand, arg2: f64, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickMotionBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64, arg5: f64) + -> MagickBooleanType; + pub fn MagickNegateImage(arg1: *mut MagickWand, arg2: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickNegateImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickNewImage(arg1: *mut MagickWand, arg2: size_t, arg3: size_t, + arg4: *const PixelWand) -> MagickBooleanType; + pub fn MagickNextImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickNormalizeImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickNormalizeImageChannel(arg1: *mut MagickWand, + arg2: ChannelType) + -> MagickBooleanType; + pub fn MagickOilPaintImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickOpaquePaintImage(arg1: *mut MagickWand, + arg2: *const PixelWand, + arg3: *const PixelWand, arg4: f64, + arg5: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickOpaquePaintImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *const PixelWand, + arg4: *const PixelWand, arg5: f64, + arg6: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickOrderedPosterizeImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickOrderedPosterizeImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickOptimizeImageTransparency(arg1: *mut MagickWand) + -> MagickBooleanType; + pub fn MagickTransparentPaintImage(arg1: *mut MagickWand, + arg2: *const PixelWand, arg3: f64, + arg4: f64, invert: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickPingImage(arg1: *mut MagickWand, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickPingImageBlob(arg1: *mut MagickWand, + arg2: *const ::libc::c_void, arg3: size_t) + -> MagickBooleanType; + pub fn MagickPingImageFile(arg1: *mut MagickWand, arg2: *mut FILE) + -> MagickBooleanType; + pub fn MagickPolaroidImage(arg1: *mut MagickWand, + arg2: *const DrawingWand, arg3: f64) + -> MagickBooleanType; + pub fn MagickPosterizeImage(arg1: *mut MagickWand, arg2: size_t, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn MagickPreviousImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickQuantizeImage(arg1: *mut MagickWand, arg2: size_t, + arg3: ColorspaceType, arg4: size_t, + arg5: MagickBooleanType, + arg6: MagickBooleanType) -> MagickBooleanType; + pub fn MagickQuantizeImages(arg1: *mut MagickWand, arg2: size_t, + arg3: ColorspaceType, arg4: size_t, + arg5: MagickBooleanType, + arg6: MagickBooleanType) -> MagickBooleanType; + pub fn MagickRaiseImage(arg1: *mut MagickWand, arg2: size_t, arg3: size_t, + arg4: ssize_t, arg5: ssize_t, + arg6: MagickBooleanType) -> MagickBooleanType; + pub fn MagickRandomThresholdImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickRandomThresholdImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickReadImage(arg1: *mut MagickWand, arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickReadImageBlob(arg1: *mut MagickWand, + arg2: *const ::libc::c_void, arg3: size_t) + -> MagickBooleanType; + pub fn MagickReadImageFile(arg1: *mut MagickWand, arg2: *mut FILE) + -> MagickBooleanType; + pub fn MagickRemoveImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickResampleImage(arg1: *mut MagickWand, arg2: f64, arg3: f64, + arg4: FilterTypes, arg5: f64) + -> MagickBooleanType; + pub fn MagickResetImagePage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickResizeImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: FilterTypes, arg5: f64) + -> MagickBooleanType; + pub fn MagickRollImage(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t) -> MagickBooleanType; + pub fn MagickRotateImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: f64) -> MagickBooleanType; + pub fn MagickRotationalBlurImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickRotationalBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64) + -> MagickBooleanType; + pub fn MagickSampleImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t) -> MagickBooleanType; + pub fn MagickScaleImage(arg1: *mut MagickWand, arg2: size_t, arg3: size_t) + -> MagickBooleanType; + pub fn MagickSegmentImage(arg1: *mut MagickWand, arg2: ColorspaceType, + arg3: MagickBooleanType, arg4: f64, arg5: f64) + -> MagickBooleanType; + pub fn MagickSelectiveBlurImage(arg1: *mut MagickWand, arg2: f64, + arg3: f64, arg4: f64) + -> MagickBooleanType; + pub fn MagickSelectiveBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64, arg5: f64) + -> MagickBooleanType; + pub fn MagickSeparateImageChannel(arg1: *mut MagickWand, + arg2: ChannelType) -> MagickBooleanType; + pub fn MagickSepiaToneImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickSetImage(arg1: *mut MagickWand, arg2: *const MagickWand) + -> MagickBooleanType; + pub fn MagickSetImageAlphaChannel(arg1: *mut MagickWand, + arg2: AlphaChannelType) + -> MagickBooleanType; + pub fn MagickSetImageBackgroundColor(arg1: *mut MagickWand, + arg2: *const PixelWand) + -> MagickBooleanType; + pub fn MagickSetImageBias(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickSetImageBluePrimary(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickSetImageBorderColor(arg1: *mut MagickWand, + arg2: *const PixelWand) + -> MagickBooleanType; + pub fn MagickSetImageChannelDepth(arg1: *mut MagickWand, + arg2: ChannelType, arg3: size_t) + -> MagickBooleanType; + pub fn MagickSetImageClipMask(arg1: *mut MagickWand, + arg2: *const MagickWand) + -> MagickBooleanType; + pub fn MagickSetImageColor(arg1: *mut MagickWand, arg2: *const PixelWand) + -> MagickBooleanType; + pub fn MagickSetImageColormapColor(arg1: *mut MagickWand, arg2: size_t, + arg3: *const PixelWand) + -> MagickBooleanType; + pub fn MagickSetImageColorspace(arg1: *mut MagickWand, + arg2: ColorspaceType) + -> MagickBooleanType; + pub fn MagickSetImageCompose(arg1: *mut MagickWand, + arg2: CompositeOperator) + -> MagickBooleanType; + pub fn MagickSetImageCompression(arg1: *mut MagickWand, + arg2: CompressionType) + -> MagickBooleanType; + pub fn MagickSetImageDelay(arg1: *mut MagickWand, arg2: size_t) + -> MagickBooleanType; + pub fn MagickSetImageDepth(arg1: *mut MagickWand, arg2: size_t) + -> MagickBooleanType; + pub fn MagickSetImageDispose(arg1: *mut MagickWand, arg2: DisposeType) + -> MagickBooleanType; + pub fn MagickSetImageCompressionQuality(arg1: *mut MagickWand, + arg2: size_t) + -> MagickBooleanType; + pub fn MagickSetImageEndian(arg1: *mut MagickWand, arg2: EndianType) + -> MagickBooleanType; + pub fn MagickSetImageExtent(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t) -> MagickBooleanType; + pub fn MagickSetImageFilename(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetImageFormat(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) + -> MagickBooleanType; + pub fn MagickSetImageFuzz(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickSetImageGamma(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickSetImageGravity(arg1: *mut MagickWand, arg2: GravityType) + -> MagickBooleanType; + pub fn MagickSetImageGreenPrimary(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickSetImageInterlaceScheme(arg1: *mut MagickWand, + arg2: InterlaceType) + -> MagickBooleanType; + pub fn MagickSetImageInterpolateMethod(arg1: *mut MagickWand, + arg2: InterpolatePixelMethod) + -> MagickBooleanType; + pub fn MagickSetImageIterations(arg1: *mut MagickWand, arg2: size_t) + -> MagickBooleanType; + pub fn MagickSetImageMatte(arg1: *mut MagickWand, arg2: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickSetImageMatteColor(arg1: *mut MagickWand, + arg2: *const PixelWand) + -> MagickBooleanType; + pub fn MagickSetImageOpacity(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickSetImageOrientation(arg1: *mut MagickWand, + arg2: OrientationType) + -> MagickBooleanType; + pub fn MagickSetImagePage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: ssize_t, arg5: ssize_t) + -> MagickBooleanType; + pub fn MagickSetImageRedPrimary(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickSetImageRenderingIntent(arg1: *mut MagickWand, + arg2: RenderingIntent) + -> MagickBooleanType; + pub fn MagickSetImageResolution(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickSetImageScene(arg1: *mut MagickWand, arg2: size_t) + -> MagickBooleanType; + pub fn MagickSetImageTicksPerSecond(arg1: *mut MagickWand, arg2: ssize_t) + -> MagickBooleanType; + pub fn MagickSetImageType(arg1: *mut MagickWand, arg2: ImageType) + -> MagickBooleanType; + pub fn MagickSetImageUnits(arg1: *mut MagickWand, arg2: ResolutionType) + -> MagickBooleanType; + pub fn MagickSetImageWhitePoint(arg1: *mut MagickWand, arg2: f64, + arg3: f64) -> MagickBooleanType; + pub fn MagickShadeImage(arg1: *mut MagickWand, arg2: MagickBooleanType, + arg3: f64, arg4: f64) -> MagickBooleanType; + pub fn MagickShadowImage(arg1: *mut MagickWand, arg2: f64, arg3: f64, + arg4: ssize_t, arg5: ssize_t) + -> MagickBooleanType; + pub fn MagickSharpenImage(arg1: *mut MagickWand, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn MagickSharpenImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: f64, arg4: f64) + -> MagickBooleanType; + pub fn MagickShaveImage(arg1: *mut MagickWand, arg2: size_t, arg3: size_t) + -> MagickBooleanType; + pub fn MagickShearImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: f64, arg4: f64) -> MagickBooleanType; + pub fn MagickSigmoidalContrastImage(arg1: *mut MagickWand, + arg2: MagickBooleanType, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickSigmoidalContrastImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: MagickBooleanType, + arg4: f64, arg5: f64) + -> MagickBooleanType; + pub fn MagickSketchImage(arg1: *mut MagickWand, arg2: f64, arg3: f64, + arg4: f64) -> MagickBooleanType; + pub fn MagickSolarizeImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickSolarizeImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64) + -> MagickBooleanType; + pub fn MagickSparseColorImage(arg1: *mut MagickWand, arg2: ChannelType, + arg3: SparseColorMethod, arg4: size_t, + arg5: *const f64) -> MagickBooleanType; + pub fn MagickSpliceImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: ssize_t, arg5: ssize_t) + -> MagickBooleanType; + pub fn MagickSpreadImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickStatisticImage(arg1: *mut MagickWand, arg2: StatisticType, + arg3: size_t, arg4: size_t) + -> MagickBooleanType; + pub fn MagickStatisticImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: StatisticType, + arg4: size_t, arg5: size_t) + -> MagickBooleanType; + pub fn MagickStripImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickSwirlImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickTintImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: *const PixelWand) -> MagickBooleanType; + pub fn MagickTransformImageColorspace(arg1: *mut MagickWand, + arg2: ColorspaceType) + -> MagickBooleanType; + pub fn MagickTransposeImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickTransverseImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickThresholdImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickThresholdImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64) + -> MagickBooleanType; + pub fn MagickThumbnailImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t) -> MagickBooleanType; + pub fn MagickTrimImage(arg1: *mut MagickWand, arg2: f64) + -> MagickBooleanType; + pub fn MagickUniqueImageColors(arg1: *mut MagickWand) + -> MagickBooleanType; + pub fn MagickUnsharpMaskImage(arg1: *mut MagickWand, arg2: f64, arg3: f64, + arg4: f64, arg5: f64) -> MagickBooleanType; + pub fn MagickUnsharpMaskImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: f64, + arg4: f64, arg5: f64, arg6: f64) + -> MagickBooleanType; + pub fn MagickVignetteImage(arg1: *mut MagickWand, arg2: f64, arg3: f64, + arg4: ssize_t, arg5: ssize_t) + -> MagickBooleanType; + pub fn MagickWaveImage(arg1: *mut MagickWand, arg2: f64, arg3: f64) + -> MagickBooleanType; + pub fn MagickWhiteThresholdImage(arg1: *mut MagickWand, + arg2: *const PixelWand) + -> MagickBooleanType; + pub fn MagickWriteImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char) -> MagickBooleanType; + pub fn MagickWriteImageFile(arg1: *mut MagickWand, arg2: *mut FILE) + -> MagickBooleanType; + pub fn MagickWriteImages(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: MagickBooleanType) -> MagickBooleanType; + pub fn MagickWriteImagesFile(arg1: *mut MagickWand, arg2: *mut FILE) + -> MagickBooleanType; + pub fn MagickSetImageProgressMonitor(arg1: *mut MagickWand, + arg2: MagickProgressMonitor, + arg3: *mut ::libc::c_void) + -> MagickProgressMonitor; + pub fn MagickAppendImages(arg1: *mut MagickWand, arg2: MagickBooleanType) + -> *mut MagickWand; + pub fn MagickCoalesceImages(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickCombineImages(arg1: *mut MagickWand, arg2: ChannelType) + -> *mut MagickWand; + pub fn MagickCompareImageChannels(arg1: *mut MagickWand, + arg2: *const MagickWand, + arg3: ChannelType, arg4: MetricType, + arg5: *mut f64) -> *mut MagickWand; + pub fn MagickCompareImages(arg1: *mut MagickWand, arg2: *const MagickWand, + arg3: MetricType, arg4: *mut f64) + -> *mut MagickWand; + pub fn MagickCompareImageLayers(arg1: *mut MagickWand, + arg2: ImageLayerMethod) + -> *mut MagickWand; + pub fn MagickDeconstructImages(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickEvaluateImages(arg1: *mut MagickWand, + arg2: MagickEvaluateOperator) + -> *mut MagickWand; + pub fn MagickFxImage(arg1: *mut MagickWand, arg2: *const ::libc::c_char) + -> *mut MagickWand; + pub fn MagickFxImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: *const ::libc::c_char) + -> *mut MagickWand; + pub fn MagickGetImage(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickGetImageClipMask(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn MagickGetImageRegion(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: ssize_t, arg5: ssize_t) + -> *mut MagickWand; + pub fn MagickMergeImageLayers(arg1: *mut MagickWand, + arg2: ImageLayerMethod) -> *mut MagickWand; + pub fn MagickMorphImages(arg1: *mut MagickWand, arg2: size_t) + -> *mut MagickWand; + pub fn MagickMontageImage(arg1: *mut MagickWand, arg2: *const DrawingWand, + arg3: *const ::libc::c_char, + arg4: *const ::libc::c_char, arg5: MontageMode, + arg6: *const ::libc::c_char) -> *mut MagickWand; + pub fn MagickOptimizeImageLayers(arg1: *mut MagickWand) + -> *mut MagickWand; + pub fn MagickPreviewImages(wand: *mut MagickWand, arg1: PreviewType) + -> *mut MagickWand; + pub fn MagickSimilarityImage(arg1: *mut MagickWand, + arg2: *const MagickWand, + arg3: *mut RectangleInfo, arg4: *mut f64) + -> *mut MagickWand; + pub fn MagickSmushImages(arg1: *mut MagickWand, arg2: MagickBooleanType, + arg3: ssize_t) -> *mut MagickWand; + pub fn MagickSteganoImage(arg1: *mut MagickWand, arg2: *const MagickWand, + arg3: ssize_t) -> *mut MagickWand; + pub fn MagickStereoImage(arg1: *mut MagickWand, arg2: *const MagickWand) + -> *mut MagickWand; + pub fn MagickTextureImage(arg1: *mut MagickWand, arg2: *const MagickWand) + -> *mut MagickWand; + pub fn MagickTransformImage(arg1: *mut MagickWand, + arg2: *const ::libc::c_char, + arg3: *const ::libc::c_char) + -> *mut MagickWand; + pub fn MagickGetImageOrientation(arg1: *mut MagickWand) + -> OrientationType; + pub fn MagickGetImageHistogram(arg1: *mut MagickWand, arg2: *mut size_t) + -> *mut *mut PixelWand; + pub fn MagickGetImageRenderingIntent(arg1: *mut MagickWand) + -> RenderingIntent; + pub fn MagickGetImageUnits(arg1: *mut MagickWand) -> ResolutionType; + pub fn MagickGetImageColors(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageCompressionQuality(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageDelay(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageChannelDepth(arg1: *mut MagickWand, + arg2: ChannelType) -> size_t; + pub fn MagickGetImageDepth(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageHeight(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageIterations(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageScene(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageTicksPerSecond(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageWidth(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetNumberImages(arg1: *mut MagickWand) -> size_t; + pub fn MagickGetImageBlob(arg1: *mut MagickWand, arg2: *mut size_t) + -> *mut ::libc::c_uchar; + pub fn MagickGetImagesBlob(arg1: *mut MagickWand, arg2: *mut size_t) + -> *mut ::libc::c_uchar; + pub fn MagickGetImageVirtualPixelMethod(arg1: *mut MagickWand) + -> VirtualPixelMethod; + pub fn MagickSetImageVirtualPixelMethod(arg1: *mut MagickWand, + arg2: VirtualPixelMethod) + -> VirtualPixelMethod; + pub fn MagickCommandGenesis(arg1: *mut ImageInfo, arg2: MagickCommand, + arg3: ::libc::c_int, + arg4: *mut *mut ::libc::c_char, + arg5: *mut *mut ::libc::c_char, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn MogrifyImage(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *const ::libc::c_char, + arg4: *mut *mut Image, arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn MogrifyImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn MogrifyImageInfo(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *const ::libc::c_char, + arg4: *mut ExceptionInfo) -> MagickBooleanType; + pub fn MogrifyImageList(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *const ::libc::c_char, + arg4: *mut *mut Image, arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn MogrifyImages(arg1: *mut ImageInfo, arg2: MagickBooleanType, + arg3: ::libc::c_int, + arg4: *mut *const ::libc::c_char, + arg5: *mut *mut Image, arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn MontageImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn StreamImageCommand(arg1: *mut ImageInfo, arg2: ::libc::c_int, + arg3: *mut *mut ::libc::c_char, + arg4: *mut *mut ::libc::c_char, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetWandViewException(arg1: *const WandView, + arg2: *mut ExceptionType) + -> *mut ::libc::c_char; + pub fn DuplexTransferWandViewIterator(arg1: *mut WandView, + arg2: *mut WandView, + arg3: *mut WandView, + arg4: DuplexTransferWandViewMethod, + arg5: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn GetWandViewIterator(arg1: *mut WandView, arg2: GetWandViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn IsWandView(arg1: *const WandView) -> MagickBooleanType; + pub fn SetWandViewIterator(arg1: *mut WandView, arg2: SetWandViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn TransferWandViewIterator(arg1: *mut WandView, arg2: *mut WandView, + arg3: TransferWandViewMethod, + arg4: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn UpdateWandViewIterator(arg1: *mut WandView, + arg2: UpdateWandViewMethod, + arg3: *mut ::libc::c_void) + -> MagickBooleanType; + pub fn GetWandViewWand(arg1: *const WandView) -> *mut MagickWand; + pub fn GetWandViewPixels(arg1: *const WandView) -> *mut *mut PixelWand; + pub fn GetWandViewExtent(arg1: *const WandView) -> RectangleInfo; + pub fn SetWandViewDescription(arg1: *mut WandView, + arg2: *const ::libc::c_char); + pub fn SetWandViewThreads(arg1: *mut WandView, arg2: size_t); + pub fn CloneWandView(arg1: *const WandView) -> *mut WandView; + pub fn DestroyWandView(arg1: *mut WandView) -> *mut WandView; + pub fn NewWandView(arg1: *mut MagickWand) -> *mut WandView; + pub fn NewWandViewExtent(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t, arg4: size_t, arg5: size_t) + -> *mut WandView; + pub fn MagickGetException(arg1: *const MagickWand, + arg2: *mut ExceptionType) + -> *mut ::libc::c_char; + pub fn MagickGetExceptionType(arg1: *const MagickWand) -> ExceptionType; + pub fn IsMagickWand(arg1: *const MagickWand) -> MagickBooleanType; + pub fn IsMagickWandInstantiated() -> MagickBooleanType; + pub fn MagickClearException(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickSetIteratorIndex(arg1: *mut MagickWand, arg2: ssize_t) + -> MagickBooleanType; + pub fn CloneMagickWand(arg1: *const MagickWand) -> *mut MagickWand; + pub fn DestroyMagickWand(arg1: *mut MagickWand) -> *mut MagickWand; + pub fn NewMagickWand() -> *mut MagickWand; + pub fn NewMagickWandFromImage(arg1: *const Image) -> *mut MagickWand; + pub fn MagickGetIteratorIndex(arg1: *mut MagickWand) -> ssize_t; + pub fn ClearMagickWand(arg1: *mut MagickWand); + pub fn MagickWandGenesis(); + pub fn MagickWandTerminus(); + pub fn MagickRelinquishMemory(arg1: *mut ::libc::c_void) + -> *mut ::libc::c_void; + pub fn MagickResetIterator(arg1: *mut MagickWand); + pub fn MagickSetFirstIterator(arg1: *mut MagickWand); + pub fn MagickSetLastIterator(arg1: *mut MagickWand); +} diff --git a/build.rs b/build.rs index d017685..95d90e4 100644 --- a/build.rs +++ b/build.rs @@ -15,7 +15,7 @@ */ use std::env; -use std::fs::File; +use std::fs::{copy, File}; use std::io::prelude::*; use std::path::{Path, PathBuf}; use std::process::Command; @@ -23,6 +23,99 @@ use std::process::Command; static HEADER: &'static str = "#include \n"; static LIBPATH: &'static str = "/Library/Developer/CommandLineTools/usr/lib"; +fn run_bindgen(out_dir: String, bindings_path_str: &str) { + // Install rust-bindgen so we can generate the bindings. While the + // bindgen crate is nice, it does not appear to support setting + // environment variables like DYLD_LIBRARY_PATH. + let home_dir = env::home_dir().expect("home directory"); + let mut cargo_bin = PathBuf::from(home_dir); + cargo_bin.push(".cargo"); + cargo_bin.push("bin"); + cargo_bin.push("bindgen"); + println!("BINDGEN_PATH={:?}", cargo_bin); + if !cargo_bin.exists() { + Command::new("cargo") + .arg("install") + .arg("bindgen") + .status().expect("cargo install bindgen"); + } + + // Check that MagickWand is installed before proceeding. + if !Command::new("pkg-config") + .arg("--exists") + .arg("MagickWand") + .status().unwrap().success() { + panic!("MagickWand library must be installed") + } + + // Get the compiler flags for the MagickWand library. + let mw_cflags_output = Command::new("pkg-config") + .arg("--cflags") + .arg("MagickWand") + .output().expect("pkg-config --cflags MagickWand"); + let mw_cflags = std::str::from_utf8(&mw_cflags_output.stdout).unwrap().trim(); + let mw_cflags_arr: Vec<&str> = mw_cflags.split_whitespace().collect(); + println!("CFLAGS={:?}", mw_cflags_arr); + + // Extract the library name for use with the --link option below. + // This just happens to be the first argument from the output of + // pkg-config when given the --libs-only-l option. We lop off the + // leading "-l" since we only need the name (e.g. "MagickWand-6"). + let mw_ldflags_output = Command::new("pkg-config") + .arg("--libs-only-l") + .arg("MagickWand") + .output().expect("pkg-config --libs-only-l MagickWand"); + let mw_ldflags = std::str::from_utf8(&mw_ldflags_output.stdout).unwrap().trim(); + let mw_ldflags_arr: Vec<&str> = mw_ldflags.split_whitespace().collect(); + let link_arg = &mw_ldflags_arr[0][2..]; + + let gen_h_path = out_dir.clone() + "/gen.h"; + // Create the header file that rust-bindgen needs as input. + let mut gen_h = File::create(&gen_h_path).expect("could not create file"); + gen_h.write_all(HEADER.as_bytes()).expect("could not write header file"); + + // Combine all of that in the invocation of rust-bindgen. + let mut cmd = &mut Command::new(cargo_bin); + if cfg!(target_os = "macos") { + // Mac requires that the xcode tools are installed so that + // rustc can find the clang.dylib file. See also issue + // https://github.com/crabtw/rust-bindgen/issues/89 + let lib_path = Path::new(LIBPATH); + if !lib_path.exists() { + panic!("missing {}, run xcode-select --install", LIBPATH); + } + cmd.env("DYLD_LIBRARY_PATH", LIBPATH); + } + let mut output_arg = String::from("--output"); + output_arg.push('='); + output_arg.push_str(&bindings_path_str); + cmd.arg("--builtins") + // For the time being, avoid switching to proper Rust enums, as + // that would change quite a bit of the existing code. We can + // change that at a later time, and then remove this option. + .arg("--no-rust-enums") + // There are a few places where our code is still using `libc::` + // types, rather than the new default `std::os::raw` types. We + // can switch at a later time and then remove this option. + .arg("--ctypes-prefix=libc") + // Inform bindgen of the library to which we are linking, + // otherwise it may compile but the tests will fail to link + // properly. The -L and -l arguments provided by pkg-config + // apparently go unused with (newer versions of?) clang. + .arg(format!("--link={}", link_arg)) + .arg(output_arg) + .arg(&gen_h_path) + .arg("--"); + if cfg!(target_os = "macos") { + // Work around issue #361 in rust-bindgen for the time being. + cmd.arg("-U__BLOCKS__"); + } + cmd.args(&mw_cflags_arr[..]); + println!("BINDING_GENERATION={:?}", cmd); + cmd.status().expect("rust-bindgen invocation"); + std::fs::remove_file(&gen_h_path).expect("could not remove header file"); +} + fn main() { // // If the MagickWand bindings are missing, generate them using @@ -31,97 +124,16 @@ fn main() { let out_dir = ::std::env::var("OUT_DIR").unwrap(); let bindings_path_str = out_dir.clone() + "/bindings.rs"; if !Path::new(&bindings_path_str).exists() { - // Install rust-bindgen so we can generate the bindings. While the - // bindgen crate is nice, it does not appear to support setting - // environment variables like DYLD_LIBRARY_PATH. - let home_dir = env::home_dir().expect("home directory"); - let mut cargo_bin = PathBuf::from(home_dir); - cargo_bin.push(".cargo"); - cargo_bin.push("bin"); - cargo_bin.push("bindgen"); - println!("BINDGEN_PATH={:?}", cargo_bin); - if !cargo_bin.exists() { - Command::new("cargo") - .arg("install") - .arg("bindgen") - .status().expect("cargo install bindgen"); + // Either generate the bindings.rs or copy an already generated + // version for FreeBSD. See rust-bindgen issue #385 for details. We + // also need to hack the library path to `cargo test` can find the + // MagickWand libraries. + if cfg!(target_os = "freebsd") { + copy("bindings.rs", &bindings_path_str).expect("cp bindings.rs to out_dir"); + println!("cargo:rustc-link-search=native=/usr/local/lib"); + } else { + run_bindgen(out_dir, &bindings_path_str); } - - // Check that MagickWand is installed before proceeding. - if !Command::new("pkg-config") - .arg("--exists") - .arg("MagickWand") - .status().unwrap().success() { - panic!("MagickWand library must be installed") - } - - // Get the compiler flags for the MagickWand library. - let mw_cflags_output = Command::new("pkg-config") - .arg("--cflags") - .arg("MagickWand") - .output().expect("pkg-config --cflags MagickWand"); - let mw_cflags = std::str::from_utf8(&mw_cflags_output.stdout).unwrap().trim(); - let mw_cflags_arr: Vec<&str> = mw_cflags.split_whitespace().collect(); - println!("CFLAGS={:?}", mw_cflags_arr); - - // Extract the library name for use with the --link option below. - // This just happens to be the first argument from the output of - // pkg-config when given the --libs-only-l option. We lop off the - // leading "-l" since we only need the name (e.g. "MagickWand-6"). - let mw_ldflags_output = Command::new("pkg-config") - .arg("--libs-only-l") - .arg("MagickWand") - .output().expect("pkg-config --libs-only-l MagickWand"); - let mw_ldflags = std::str::from_utf8(&mw_ldflags_output.stdout).unwrap().trim(); - let mw_ldflags_arr: Vec<&str> = mw_ldflags.split_whitespace().collect(); - let link_arg = &mw_ldflags_arr[0][2..]; - - let gen_h_path = out_dir.clone() + "/gen.h"; - // Create the header file that rust-bindgen needs as input. - let mut gen_h = File::create(&gen_h_path).expect("could not create file"); - gen_h.write_all(HEADER.as_bytes()).expect("could not write header file"); - - // Combine all of that in the invocation of rust-bindgen. - let mut cmd = &mut Command::new(cargo_bin); - if cfg!(target_os = "macos") { - // Mac requires that the xcode tools are installed so that - // rustc can find the clang.dylib file. See also issue - // https://github.com/crabtw/rust-bindgen/issues/89 - let lib_path = Path::new(LIBPATH); - if !lib_path.exists() { - panic!("missing {}, run xcode-select --install", LIBPATH); - } - cmd.env("DYLD_LIBRARY_PATH", LIBPATH); - } - let mut output_arg = String::from("--output"); - output_arg.push('='); - output_arg.push_str(&bindings_path_str); - cmd.arg("--builtins") - // For the time being, avoid switching to proper Rust enums, as - // that would change quite a bit of the existing code. We can - // change that at a later time, and then remove this option. - .arg("--no-rust-enums") - // There are a few places where our code is still using `libc::` - // types, rather than the new default `std::os::raw` types. We - // can switch at a later time and then remove this option. - .arg("--ctypes-prefix=libc") - // Inform bindgen of the library to which we are linking, - // otherwise it may compile but the tests will fail to link - // properly. The -L and -l arguments provided by pkg-config - // apparently go unused with (newer versions of?) clang. - .arg(format!("--link={}", link_arg)) - .arg(output_arg) - .arg(&gen_h_path) - .arg("--"); - if cfg!(target_os = "macos") { - // Work around issue #361 in rust-bindgen for the time being. - cmd.arg("-U__BLOCKS__"); - } - cmd.args(&mw_cflags_arr[..]); - println!("BINDING_GENERATION={:?}", cmd); - cmd.status().expect("rust-bindgen invocation"); - std::fs::remove_file(&gen_h_path).expect("could not remove header file"); - // Work around the include! issue in rustc (as described in the // rust-bindgen README file) by wrapping the generated code in a // `pub mod` declaration; see issue #359 in rust-bindgen.