commit ed91ab75d08f18ff051fdb898646ecdc5e3c946e Author: Nathan Fiedler Date: Sat Jun 6 21:30:42 2015 -0700 Initial generated bindings and basic API diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a9d37c5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +target +Cargo.lock diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..986d066 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "magick-rust" +version = "0.1.0" +authors = ["Nathan Fiedler "] + +[dependencies] +libc = "0.1.8" diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e06d208 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ +Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/README.md b/README.md new file mode 100644 index 0000000..db3bc8b --- /dev/null +++ b/README.md @@ -0,0 +1,35 @@ +# magick-rust + +A "safe" Rust interface to the [ImageMagick](http://www.imagemagick.org/) system, in particular, the MagickWand library. The *safe* is in scarequotes because honestly nearly everything is little more than calls into a C library with `unsafe` wrapped around it. + +## TODO + +1. ~~Use rust-bindgen to generate Rust bindings.~~ +1. ~~Add a license and copyright headers~~ +1. Develop Rustic wrappers to the MagickWand library. + * Old Rust bindings: https://github.com/influenza/wand-of-rust + * Wand API: http://www.imagemagick.org/script/magick-wand.php +1. Write unit tests +1. Test it on lots of images in batches to stress test it; should not crash + +## Building the Bindings + +To build the ImageMagick bindings, we use [rust-bindgen](https://github.com/crabtw/rust-bindgen), which reads the C header files and produces a suitable wrapper in Rust. + +This example is using the [Homebrew](http://brew.sh) installed version of ImageMagick, and the LLVM compiler suite provided in the Command Line Tools from Apple. The only real difference for Mac OS X is the `DYLD_LIBRARY_PATH` that is needed to work around [issue #89](https://github.com/crabtw/rust-bindgen/issues/89) in rust-bindgen. Otherwise, the same basic steps should work on any Rust-supported system. + +``` +$ git clone https://github.com/crabtw/rust-bindgen.git +$ cd rust-bindgen +$ cargo build +$ echo '#include ' > ~/gen.h +$ DYLD_LIBRARY_PATH=/Library/Developer/CommandLineTools/usr/lib \ + ./target/debug/bindgen \ + `MagickWand-config --cflags` \ + -builtins \ + -o ~/bindings.rs \ + `MagickWand-config --ldflags` \ + ~/gen.h +``` + +Then copy the `~/bindings.rs` file into the `src` directory of this project, and rebuild everything. Hopefully it still works. diff --git a/src/bindings.rs b/src/bindings.rs new file mode 100644 index 0000000..e43e7b2 --- /dev/null +++ b/src/bindings.rs @@ -0,0 +1,8698 @@ +/* automatically generated by rust-bindgen */ + +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 Union_Unnamed1 { + pub _bindgen_data_: [u64; 16usize], +} +impl Union_Unnamed1 { + 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 Union_Unnamed1 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Union_Unnamed1 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type __mbstate_t = Union_Unnamed1; +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)] +pub struct Struct___darwin_pthread_handler_rec { + pub __routine: ::std::option::Option ()>, + pub __arg: *mut ::libc::c_void, + pub __next: *mut Struct___darwin_pthread_handler_rec, +} +impl ::std::clone::Clone for Struct___darwin_pthread_handler_rec { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_pthread_handler_rec { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_attr_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 56usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_attr_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_attr_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_cond_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 40usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_cond_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_cond_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_condattr_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 8usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_condattr_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_condattr_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_mutex_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 56usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_mutex_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_mutex_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_mutexattr_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 8usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_mutexattr_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_mutexattr_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_once_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 8usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_once_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_once_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_rwlock_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 192usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_rwlock_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_rwlock_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_rwlockattr_t { + pub __sig: ::libc::c_long, + pub __opaque: [::libc::c_char; 16usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_rwlockattr_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_rwlockattr_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct__opaque_pthread_t { + pub __sig: ::libc::c_long, + pub __cleanup_stack: *mut Struct___darwin_pthread_handler_rec, + pub __opaque: [::libc::c_char; 8176usize], +} +impl ::std::clone::Clone for Struct__opaque_pthread_t { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__opaque_pthread_t { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type __darwin_pthread_attr_t = Struct__opaque_pthread_attr_t; +pub type __darwin_pthread_cond_t = Struct__opaque_pthread_cond_t; +pub type __darwin_pthread_condattr_t = Struct__opaque_pthread_condattr_t; +pub type __darwin_pthread_key_t = ::libc::c_ulong; +pub type __darwin_pthread_mutex_t = Struct__opaque_pthread_mutex_t; +pub type __darwin_pthread_mutexattr_t = Struct__opaque_pthread_mutexattr_t; +pub type __darwin_pthread_once_t = Struct__opaque_pthread_once_t; +pub type __darwin_pthread_rwlock_t = Struct__opaque_pthread_rwlock_t; +pub type __darwin_pthread_rwlockattr_t = Struct__opaque_pthread_rwlockattr_t; +pub type __darwin_pthread_t = *mut Struct__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 = __darwin_size_t; +pub type fpos_t = __darwin_off_t; +#[repr(C)] +#[derive(Copy)] +pub struct Struct___sbuf { + pub _base: *mut ::libc::c_uchar, + pub _size: ::libc::c_int, +} +impl ::std::clone::Clone for Struct___sbuf { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___sbuf { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub enum Struct___sFILEX { } +#[repr(C)] +#[derive(Copy)] +pub struct 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: Struct___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: Struct___sbuf, + pub _extra: *mut Struct___sFILEX, + pub _ur: ::libc::c_int, + pub _ubuf: [::libc::c_uchar; 3usize], + pub _nbuf: [::libc::c_uchar; 1usize], + pub _lb: Struct___sbuf, + pub _blksize: ::libc::c_int, + pub _offset: fpos_t, +} +impl ::std::clone::Clone for Struct___sFILE { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___sFILE { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type FILE = Struct___sFILE; +pub type off_t = __darwin_off_t; +pub type ssize_t = __darwin_ssize_t; +pub type __gnuc_va_list = __builtin_va_list; +pub type Enum_Unnamed2 = ::libc::c_uint; +pub const P_ALL: ::libc::c_uint = 0; +pub const P_PID: ::libc::c_uint = 1; +pub const P_PGID: ::libc::c_uint = 2; +pub type idtype_t = Enum_Unnamed2; +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)] +pub struct 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::clone::Clone for Struct___darwin_i386_thread_state { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_i386_thread_state { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_fp_control { + pub _bindgen_bitfield_1_: ::libc::c_ushort, +} +impl ::std::clone::Clone for Struct___darwin_fp_control { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_fp_control { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type __darwin_fp_control_t = Struct___darwin_fp_control; +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_fp_status { + pub _bindgen_bitfield_1_: ::libc::c_ushort, +} +impl ::std::clone::Clone for Struct___darwin_fp_status { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_fp_status { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type __darwin_fp_status_t = Struct___darwin_fp_status; +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_mmst_reg { + pub __mmst_reg: [::libc::c_char; 10usize], + pub __mmst_rsrv: [::libc::c_char; 6usize], +} +impl ::std::clone::Clone for Struct___darwin_mmst_reg { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_mmst_reg { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_xmm_reg { + pub __xmm_reg: [::libc::c_char; 16usize], +} +impl ::std::clone::Clone for Struct___darwin_xmm_reg { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_xmm_reg { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_i386_float_state { + pub __fpu_reserved: [::libc::c_int; 2usize], + pub __fpu_fcw: Struct___darwin_fp_control, + pub __fpu_fsw: Struct___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: Struct___darwin_mmst_reg, + pub __fpu_stmm1: Struct___darwin_mmst_reg, + pub __fpu_stmm2: Struct___darwin_mmst_reg, + pub __fpu_stmm3: Struct___darwin_mmst_reg, + pub __fpu_stmm4: Struct___darwin_mmst_reg, + pub __fpu_stmm5: Struct___darwin_mmst_reg, + pub __fpu_stmm6: Struct___darwin_mmst_reg, + pub __fpu_stmm7: Struct___darwin_mmst_reg, + pub __fpu_xmm0: Struct___darwin_xmm_reg, + pub __fpu_xmm1: Struct___darwin_xmm_reg, + pub __fpu_xmm2: Struct___darwin_xmm_reg, + pub __fpu_xmm3: Struct___darwin_xmm_reg, + pub __fpu_xmm4: Struct___darwin_xmm_reg, + pub __fpu_xmm5: Struct___darwin_xmm_reg, + pub __fpu_xmm6: Struct___darwin_xmm_reg, + pub __fpu_xmm7: Struct___darwin_xmm_reg, + pub __fpu_rsrv4: [::libc::c_char; 224usize], + pub __fpu_reserved1: ::libc::c_int, +} +impl ::std::clone::Clone for Struct___darwin_i386_float_state { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_i386_float_state { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_i386_avx_state { + pub __fpu_reserved: [::libc::c_int; 2usize], + pub __fpu_fcw: Struct___darwin_fp_control, + pub __fpu_fsw: Struct___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: Struct___darwin_mmst_reg, + pub __fpu_stmm1: Struct___darwin_mmst_reg, + pub __fpu_stmm2: Struct___darwin_mmst_reg, + pub __fpu_stmm3: Struct___darwin_mmst_reg, + pub __fpu_stmm4: Struct___darwin_mmst_reg, + pub __fpu_stmm5: Struct___darwin_mmst_reg, + pub __fpu_stmm6: Struct___darwin_mmst_reg, + pub __fpu_stmm7: Struct___darwin_mmst_reg, + pub __fpu_xmm0: Struct___darwin_xmm_reg, + pub __fpu_xmm1: Struct___darwin_xmm_reg, + pub __fpu_xmm2: Struct___darwin_xmm_reg, + pub __fpu_xmm3: Struct___darwin_xmm_reg, + pub __fpu_xmm4: Struct___darwin_xmm_reg, + pub __fpu_xmm5: Struct___darwin_xmm_reg, + pub __fpu_xmm6: Struct___darwin_xmm_reg, + pub __fpu_xmm7: Struct___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: Struct___darwin_xmm_reg, + pub __fpu_ymmh1: Struct___darwin_xmm_reg, + pub __fpu_ymmh2: Struct___darwin_xmm_reg, + pub __fpu_ymmh3: Struct___darwin_xmm_reg, + pub __fpu_ymmh4: Struct___darwin_xmm_reg, + pub __fpu_ymmh5: Struct___darwin_xmm_reg, + pub __fpu_ymmh6: Struct___darwin_xmm_reg, + pub __fpu_ymmh7: Struct___darwin_xmm_reg, +} +impl ::std::clone::Clone for Struct___darwin_i386_avx_state { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_i386_avx_state { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_i386_exception_state { + pub __trapno: __uint16_t, + pub __cpu: __uint16_t, + pub __err: __uint32_t, + pub __faultvaddr: __uint32_t, +} +impl ::std::clone::Clone for Struct___darwin_i386_exception_state { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_i386_exception_state { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct___darwin_x86_debug_state32 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_x86_debug_state32 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct___darwin_x86_thread_state64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_x86_thread_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_x86_float_state64 { + pub __fpu_reserved: [::libc::c_int; 2usize], + pub __fpu_fcw: Struct___darwin_fp_control, + pub __fpu_fsw: Struct___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: Struct___darwin_mmst_reg, + pub __fpu_stmm1: Struct___darwin_mmst_reg, + pub __fpu_stmm2: Struct___darwin_mmst_reg, + pub __fpu_stmm3: Struct___darwin_mmst_reg, + pub __fpu_stmm4: Struct___darwin_mmst_reg, + pub __fpu_stmm5: Struct___darwin_mmst_reg, + pub __fpu_stmm6: Struct___darwin_mmst_reg, + pub __fpu_stmm7: Struct___darwin_mmst_reg, + pub __fpu_xmm0: Struct___darwin_xmm_reg, + pub __fpu_xmm1: Struct___darwin_xmm_reg, + pub __fpu_xmm2: Struct___darwin_xmm_reg, + pub __fpu_xmm3: Struct___darwin_xmm_reg, + pub __fpu_xmm4: Struct___darwin_xmm_reg, + pub __fpu_xmm5: Struct___darwin_xmm_reg, + pub __fpu_xmm6: Struct___darwin_xmm_reg, + pub __fpu_xmm7: Struct___darwin_xmm_reg, + pub __fpu_xmm8: Struct___darwin_xmm_reg, + pub __fpu_xmm9: Struct___darwin_xmm_reg, + pub __fpu_xmm10: Struct___darwin_xmm_reg, + pub __fpu_xmm11: Struct___darwin_xmm_reg, + pub __fpu_xmm12: Struct___darwin_xmm_reg, + pub __fpu_xmm13: Struct___darwin_xmm_reg, + pub __fpu_xmm14: Struct___darwin_xmm_reg, + pub __fpu_xmm15: Struct___darwin_xmm_reg, + pub __fpu_rsrv4: [::libc::c_char; 96usize], + pub __fpu_reserved1: ::libc::c_int, +} +impl ::std::clone::Clone for Struct___darwin_x86_float_state64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_x86_float_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_x86_avx_state64 { + pub __fpu_reserved: [::libc::c_int; 2usize], + pub __fpu_fcw: Struct___darwin_fp_control, + pub __fpu_fsw: Struct___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: Struct___darwin_mmst_reg, + pub __fpu_stmm1: Struct___darwin_mmst_reg, + pub __fpu_stmm2: Struct___darwin_mmst_reg, + pub __fpu_stmm3: Struct___darwin_mmst_reg, + pub __fpu_stmm4: Struct___darwin_mmst_reg, + pub __fpu_stmm5: Struct___darwin_mmst_reg, + pub __fpu_stmm6: Struct___darwin_mmst_reg, + pub __fpu_stmm7: Struct___darwin_mmst_reg, + pub __fpu_xmm0: Struct___darwin_xmm_reg, + pub __fpu_xmm1: Struct___darwin_xmm_reg, + pub __fpu_xmm2: Struct___darwin_xmm_reg, + pub __fpu_xmm3: Struct___darwin_xmm_reg, + pub __fpu_xmm4: Struct___darwin_xmm_reg, + pub __fpu_xmm5: Struct___darwin_xmm_reg, + pub __fpu_xmm6: Struct___darwin_xmm_reg, + pub __fpu_xmm7: Struct___darwin_xmm_reg, + pub __fpu_xmm8: Struct___darwin_xmm_reg, + pub __fpu_xmm9: Struct___darwin_xmm_reg, + pub __fpu_xmm10: Struct___darwin_xmm_reg, + pub __fpu_xmm11: Struct___darwin_xmm_reg, + pub __fpu_xmm12: Struct___darwin_xmm_reg, + pub __fpu_xmm13: Struct___darwin_xmm_reg, + pub __fpu_xmm14: Struct___darwin_xmm_reg, + pub __fpu_xmm15: Struct___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: Struct___darwin_xmm_reg, + pub __fpu_ymmh1: Struct___darwin_xmm_reg, + pub __fpu_ymmh2: Struct___darwin_xmm_reg, + pub __fpu_ymmh3: Struct___darwin_xmm_reg, + pub __fpu_ymmh4: Struct___darwin_xmm_reg, + pub __fpu_ymmh5: Struct___darwin_xmm_reg, + pub __fpu_ymmh6: Struct___darwin_xmm_reg, + pub __fpu_ymmh7: Struct___darwin_xmm_reg, + pub __fpu_ymmh8: Struct___darwin_xmm_reg, + pub __fpu_ymmh9: Struct___darwin_xmm_reg, + pub __fpu_ymmh10: Struct___darwin_xmm_reg, + pub __fpu_ymmh11: Struct___darwin_xmm_reg, + pub __fpu_ymmh12: Struct___darwin_xmm_reg, + pub __fpu_ymmh13: Struct___darwin_xmm_reg, + pub __fpu_ymmh14: Struct___darwin_xmm_reg, + pub __fpu_ymmh15: Struct___darwin_xmm_reg, +} +impl ::std::clone::Clone for Struct___darwin_x86_avx_state64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_x86_avx_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_x86_exception_state64 { + pub __trapno: __uint16_t, + pub __cpu: __uint16_t, + pub __err: __uint32_t, + pub __faultvaddr: __uint64_t, +} +impl ::std::clone::Clone for Struct___darwin_x86_exception_state64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_x86_exception_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct___darwin_x86_debug_state64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_x86_debug_state64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_mcontext32 { + pub __es: Struct___darwin_i386_exception_state, + pub __ss: Struct___darwin_i386_thread_state, + pub __fs: Struct___darwin_i386_float_state, +} +impl ::std::clone::Clone for Struct___darwin_mcontext32 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_mcontext32 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_mcontext_avx32 { + pub __es: Struct___darwin_i386_exception_state, + pub __ss: Struct___darwin_i386_thread_state, + pub __fs: Struct___darwin_i386_avx_state, +} +impl ::std::clone::Clone for Struct___darwin_mcontext_avx32 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_mcontext_avx32 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_mcontext64 { + pub __es: Struct___darwin_x86_exception_state64, + pub __ss: Struct___darwin_x86_thread_state64, + pub __fs: Struct___darwin_x86_float_state64, +} +impl ::std::clone::Clone for Struct___darwin_mcontext64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_mcontext64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_mcontext_avx64 { + pub __es: Struct___darwin_x86_exception_state64, + pub __ss: Struct___darwin_x86_thread_state64, + pub __fs: Struct___darwin_x86_avx_state64, +} +impl ::std::clone::Clone for Struct___darwin_mcontext_avx64 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_mcontext_avx64 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type mcontext_t = *mut Struct___darwin_mcontext64; +pub type pthread_attr_t = __darwin_pthread_attr_t; +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_sigaltstack { + pub ss_sp: *mut ::libc::c_void, + pub ss_size: __darwin_size_t, + pub ss_flags: ::libc::c_int, +} +impl ::std::clone::Clone for Struct___darwin_sigaltstack { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_sigaltstack { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type stack_t = Struct___darwin_sigaltstack; +#[repr(C)] +#[derive(Copy)] +pub struct Struct___darwin_ucontext { + pub uc_onstack: ::libc::c_int, + pub uc_sigmask: __darwin_sigset_t, + pub uc_stack: Struct___darwin_sigaltstack, + pub uc_link: *mut Struct___darwin_ucontext, + pub uc_mcsize: __darwin_size_t, + pub uc_mcontext: *mut Struct___darwin_mcontext64, +} +impl ::std::clone::Clone for Struct___darwin_ucontext { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___darwin_ucontext { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ucontext_t = Struct___darwin_ucontext; +pub type sigset_t = __darwin_sigset_t; +pub type uid_t = __darwin_uid_t; +#[repr(C)] +#[derive(Copy)] +pub struct Union_sigval { + pub _bindgen_data_: [u64; 1usize], +} +impl Union_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::clone::Clone for Union_sigval { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Union_sigval { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct_sigevent { + pub sigev_notify: ::libc::c_int, + pub sigev_signo: ::libc::c_int, + pub sigev_value: Union_sigval, + pub sigev_notify_function: ::std::option::Option ()>, + pub sigev_notify_attributes: *mut pthread_attr_t, +} +impl ::std::clone::Clone for Struct_sigevent { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_sigevent { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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: Union_sigval, + pub si_band: ::libc::c_long, + pub __pad: [::libc::c_ulong; 7usize], +} +impl ::std::clone::Clone for Struct___siginfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___siginfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type siginfo_t = Struct___siginfo; +#[repr(C)] +#[derive(Copy)] +pub struct Union___sigaction_u { + pub _bindgen_data_: [u64; 1usize], +} +impl Union___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::clone::Clone for Union___sigaction_u { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Union___sigaction_u { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___sigaction { + pub __sigaction_u: Union___sigaction_u, + pub sa_tramp: ::std::option::Option ()>, + pub sa_mask: sigset_t, + pub sa_flags: ::libc::c_int, +} +impl ::std::clone::Clone for Struct___sigaction { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___sigaction { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct_sigaction { + pub __sigaction_u: Union___sigaction_u, + pub sa_mask: sigset_t, + pub sa_flags: ::libc::c_int, +} +impl ::std::clone::Clone for Struct_sigaction { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_sigaction { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type sig_t = + ::std::option::Option ()>; +#[repr(C)] +#[derive(Copy)] +pub struct Struct_sigvec { + pub sv_handler: ::std::option::Option ()>, + pub sv_mask: ::libc::c_int, + pub sv_flags: ::libc::c_int, +} +impl ::std::clone::Clone for Struct_sigvec { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_sigvec { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct_sigstack { + pub ss_sp: *mut ::libc::c_char, + pub ss_onstack: ::libc::c_int, +} +impl ::std::clone::Clone for Struct_sigstack { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_sigstack { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type int8_t = ::libc::c_char; +pub type int16_t = ::libc::c_short; +pub type int32_t = ::libc::c_int; +pub type int64_t = ::libc::c_longlong; +pub type uint8_t = ::libc::c_uchar; +pub type uint16_t = ::libc::c_ushort; +pub type uint32_t = ::libc::c_uint; +pub type uint64_t = ::libc::c_ulonglong; +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 = __darwin_intptr_t; +pub type uintptr_t = ::libc::c_ulong; +pub type intmax_t = ::libc::c_long; +pub type uintmax_t = ::libc::c_ulong; +#[repr(C)] +#[derive(Copy)] +pub struct Struct_timeval { + pub tv_sec: __darwin_time_t, + pub tv_usec: __darwin_suseconds_t, +} +impl ::std::clone::Clone for Struct_timeval { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_timeval { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type rlim_t = __uint64_t; +#[repr(C)] +#[derive(Copy)] +pub struct Struct_rusage { + pub ru_utime: Struct_timeval, + pub ru_stime: Struct_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::clone::Clone for Struct_rusage { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_rusage { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type rusage_info_t = *mut ::libc::c_void; +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct_rusage_info_v0 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_rusage_info_v0 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct_rusage_info_v1 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_rusage_info_v1 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct_rusage_info_v2 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_rusage_info_v2 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct_rusage_info_v3 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_rusage_info_v3 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type rusage_info_current = Struct_rusage_info_v3; +#[repr(C)] +#[derive(Copy)] +pub struct Struct_rlimit { + pub rlim_cur: rlim_t, + pub rlim_max: rlim_t, +} +impl ::std::clone::Clone for Struct_rlimit { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_rlimit { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct_proc_rlimit_control_wakeupmon { + pub wm_flags: uint32_t, + pub wm_rate: int32_t, +} +impl ::std::clone::Clone for Struct_proc_rlimit_control_wakeupmon { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_proc_rlimit_control_wakeupmon { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Union_wait { + pub _bindgen_data_: [u32; 1usize], +} +impl Union_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_Unnamed3 { + 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_Unnamed4 { + let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); + ::std::mem::transmute(raw.offset(0)) + } +} +impl ::std::clone::Clone for Union_wait { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Union_wait { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct_Unnamed3 { + pub _bindgen_bitfield_1_: ::libc::c_uint, +} +impl ::std::clone::Clone for Struct_Unnamed3 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_Unnamed3 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct_Unnamed4 { + pub _bindgen_bitfield_1_: ::libc::c_uint, +} +impl ::std::clone::Clone for Struct_Unnamed4 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_Unnamed4 { + 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)] +pub struct Struct_Unnamed5 { + pub quot: ::libc::c_int, + pub rem: ::libc::c_int, +} +impl ::std::clone::Clone for Struct_Unnamed5 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_Unnamed5 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type div_t = Struct_Unnamed5; +#[repr(C)] +#[derive(Copy)] +pub struct Struct_Unnamed6 { + pub quot: ::libc::c_long, + pub rem: ::libc::c_long, +} +impl ::std::clone::Clone for Struct_Unnamed6 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_Unnamed6 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ldiv_t = Struct_Unnamed6; +#[repr(C)] +#[derive(Copy)] +pub struct Struct_Unnamed7 { + pub quot: ::libc::c_longlong, + pub rem: ::libc::c_longlong, +} +impl ::std::clone::Clone for Struct_Unnamed7 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_Unnamed7 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type lldiv_t = Struct_Unnamed7; +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 = ::libc::c_float; +pub type double_t = ::libc::c_double; +#[repr(C)] +#[derive(Copy)] +pub struct Struct___float2 { + pub __sinval: ::libc::c_float, + pub __cosval: ::libc::c_float, +} +impl ::std::clone::Clone for Struct___float2 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___float2 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct___double2 { + pub __sinval: ::libc::c_double, + pub __cosval: ::libc::c_double, +} +impl ::std::clone::Clone for Struct___double2 { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___double2 { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct Struct_exception { + pub _type: ::libc::c_int, + pub name: *mut ::libc::c_char, + pub arg1: ::libc::c_double, + pub arg2: ::libc::c_double, + pub retval: ::libc::c_double, +} +impl ::std::clone::Clone for Struct_exception { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_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)] +pub struct Struct_fd_set { + pub fds_bits: [__int32_t; 32usize], +} +impl ::std::clone::Clone for Struct_fd_set { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_fd_set { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type fd_set = Struct_fd_set; +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)] +pub struct Struct_timespec { + pub tv_sec: __darwin_time_t, + pub tv_nsec: ::libc::c_long, +} +impl ::std::clone::Clone for Struct_timespec { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_timespec { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct_tm { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_tm { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub enum Struct__MagickWand { } +pub type MagickWand = Struct__MagickWand; +pub type MagickRealType = ::libc::c_float; +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 Enum_Unnamed8 = ::libc::c_uint; +pub const UndefinedChannel: ::libc::c_uint = 0; +pub const RedChannel: ::libc::c_uint = 1; +pub const GrayChannel: ::libc::c_uint = 1; +pub const CyanChannel: ::libc::c_uint = 1; +pub const GreenChannel: ::libc::c_uint = 2; +pub const MagentaChannel: ::libc::c_uint = 2; +pub const BlueChannel: ::libc::c_uint = 4; +pub const YellowChannel: ::libc::c_uint = 4; +pub const AlphaChannel: ::libc::c_uint = 8; +pub const OpacityChannel: ::libc::c_uint = 8; +pub const MatteChannel: ::libc::c_uint = 8; +pub const BlackChannel: ::libc::c_uint = 32; +pub const IndexChannel: ::libc::c_uint = 32; +pub const CompositeChannels: ::libc::c_uint = 47; +pub const AllChannels: ::libc::c_uint = 134217727; +pub const TrueAlphaChannel: ::libc::c_uint = 64; +pub const RGBChannels: ::libc::c_uint = 128; +pub const GrayChannels: ::libc::c_uint = 128; +pub const SyncChannels: ::libc::c_uint = 256; +pub const DefaultChannels: ::libc::c_uint = 134217719; +pub type ChannelType = Enum_Unnamed8; +pub type Enum_Unnamed9 = ::libc::c_uint; +pub const UndefinedClass: ::libc::c_uint = 0; +pub const DirectClass: ::libc::c_uint = 1; +pub const PseudoClass: ::libc::c_uint = 2; +pub type ClassType = Enum_Unnamed9; +pub type Enum_Unnamed10 = ::libc::c_uint; +pub const MagickFalse: ::libc::c_uint = 0; +pub const MagickTrue: ::libc::c_uint = 1; +pub type MagickBooleanType = Enum_Unnamed10; +pub enum Struct__BlobInfo { } +pub type BlobInfo = Struct__BlobInfo; +pub type ExceptionInfo = Struct__ExceptionInfo; +pub type Image = Struct__Image; +pub type ImageInfo = Struct__ImageInfo; +pub type Enum_Unnamed11 = ::libc::c_uint; +pub const NoValue: ::libc::c_uint = 0; +pub const XValue: ::libc::c_uint = 1; +pub const XiValue: ::libc::c_uint = 1; +pub const YValue: ::libc::c_uint = 2; +pub const PsiValue: ::libc::c_uint = 2; +pub const WidthValue: ::libc::c_uint = 4; +pub const RhoValue: ::libc::c_uint = 4; +pub const HeightValue: ::libc::c_uint = 8; +pub const SigmaValue: ::libc::c_uint = 8; +pub const ChiValue: ::libc::c_uint = 16; +pub const XiNegative: ::libc::c_uint = 32; +pub const XNegative: ::libc::c_uint = 32; +pub const PsiNegative: ::libc::c_uint = 64; +pub const YNegative: ::libc::c_uint = 64; +pub const ChiNegative: ::libc::c_uint = 128; +pub const PercentValue: ::libc::c_uint = 4096; +pub const AspectValue: ::libc::c_uint = 8192; +pub const NormalizeValue: ::libc::c_uint = 8192; +pub const LessValue: ::libc::c_uint = 16384; +pub const GreaterValue: ::libc::c_uint = 32768; +pub const MinimumValue: ::libc::c_uint = 65536; +pub const CorrelateNormalizeValue: ::libc::c_uint = 65536; +pub const AreaValue: ::libc::c_uint = 131072; +pub const DecimalValue: ::libc::c_uint = 262144; +pub const SeparatorValue: ::libc::c_uint = 524288; +pub const AllValues: ::libc::c_uint = 2147483647; +pub type GeometryFlags = Enum_Unnamed11; +pub type Enum_Unnamed12 = ::libc::c_uint; +pub const UndefinedGravity: ::libc::c_uint = 0; +pub const ForgetGravity: ::libc::c_uint = 0; +pub const NorthWestGravity: ::libc::c_uint = 1; +pub const NorthGravity: ::libc::c_uint = 2; +pub const NorthEastGravity: ::libc::c_uint = 3; +pub const WestGravity: ::libc::c_uint = 4; +pub const CenterGravity: ::libc::c_uint = 5; +pub const EastGravity: ::libc::c_uint = 6; +pub const SouthWestGravity: ::libc::c_uint = 7; +pub const SouthGravity: ::libc::c_uint = 8; +pub const SouthEastGravity: ::libc::c_uint = 9; +pub const StaticGravity: ::libc::c_uint = 10; +pub type GravityType = Enum_Unnamed12; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__AffineMatrix { + pub sx: ::libc::c_double, + pub rx: ::libc::c_double, + pub ry: ::libc::c_double, + pub sy: ::libc::c_double, + pub tx: ::libc::c_double, + pub ty: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__AffineMatrix { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__AffineMatrix { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type AffineMatrix = Struct__AffineMatrix; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__GeometryInfo { + pub rho: ::libc::c_double, + pub sigma: ::libc::c_double, + pub xi: ::libc::c_double, + pub psi: ::libc::c_double, + pub chi: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__GeometryInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__GeometryInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type GeometryInfo = Struct__GeometryInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__OffsetInfo { + pub x: ssize_t, + pub y: ssize_t, +} +impl ::std::clone::Clone for Struct__OffsetInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__OffsetInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type OffsetInfo = Struct__OffsetInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__RectangleInfo { + pub width: size_t, + pub height: size_t, + pub x: ssize_t, + pub y: ssize_t, +} +impl ::std::clone::Clone for Struct__RectangleInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__RectangleInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type RectangleInfo = Struct__RectangleInfo; +pub type Enum_Unnamed13 = ::libc::c_uint; +pub const UndefinedColorspace: ::libc::c_uint = 0; +pub const RGBColorspace: ::libc::c_uint = 1; +pub const GRAYColorspace: ::libc::c_uint = 2; +pub const TransparentColorspace: ::libc::c_uint = 3; +pub const OHTAColorspace: ::libc::c_uint = 4; +pub const LabColorspace: ::libc::c_uint = 5; +pub const XYZColorspace: ::libc::c_uint = 6; +pub const YCbCrColorspace: ::libc::c_uint = 7; +pub const YCCColorspace: ::libc::c_uint = 8; +pub const YIQColorspace: ::libc::c_uint = 9; +pub const YPbPrColorspace: ::libc::c_uint = 10; +pub const YUVColorspace: ::libc::c_uint = 11; +pub const CMYKColorspace: ::libc::c_uint = 12; +pub const sRGBColorspace: ::libc::c_uint = 13; +pub const HSBColorspace: ::libc::c_uint = 14; +pub const HSLColorspace: ::libc::c_uint = 15; +pub const HWBColorspace: ::libc::c_uint = 16; +pub const Rec601LumaColorspace: ::libc::c_uint = 17; +pub const Rec601YCbCrColorspace: ::libc::c_uint = 18; +pub const Rec709LumaColorspace: ::libc::c_uint = 19; +pub const Rec709YCbCrColorspace: ::libc::c_uint = 20; +pub const LogColorspace: ::libc::c_uint = 21; +pub const CMYColorspace: ::libc::c_uint = 22; +pub const LuvColorspace: ::libc::c_uint = 23; +pub const HCLColorspace: ::libc::c_uint = 24; +pub const LCHColorspace: ::libc::c_uint = 25; +pub const LMSColorspace: ::libc::c_uint = 26; +pub const LCHabColorspace: ::libc::c_uint = 27; +pub const LCHuvColorspace: ::libc::c_uint = 28; +pub const scRGBColorspace: ::libc::c_uint = 29; +pub const HSIColorspace: ::libc::c_uint = 30; +pub const HSVColorspace: ::libc::c_uint = 31; +pub const HCLpColorspace: ::libc::c_uint = 32; +pub const YDbDrColorspace: ::libc::c_uint = 33; +pub const xyYColorspace: ::libc::c_uint = 34; +pub type ColorspaceType = Enum_Unnamed13; +pub type Enum_Unnamed14 = ::libc::c_uint; +pub const UndefinedPixel: ::libc::c_uint = 0; +pub const CharPixel: ::libc::c_uint = 1; +pub const DoublePixel: ::libc::c_uint = 2; +pub const FloatPixel: ::libc::c_uint = 3; +pub const IntegerPixel: ::libc::c_uint = 4; +pub const LongPixel: ::libc::c_uint = 5; +pub const QuantumPixel: ::libc::c_uint = 6; +pub const ShortPixel: ::libc::c_uint = 7; +pub type StorageType = Enum_Unnamed14; +pub type Enum_Unnamed15 = ::libc::c_uint; +pub const UndefinedInterpolatePixel: ::libc::c_uint = 0; +pub const AverageInterpolatePixel: ::libc::c_uint = 1; +pub const BicubicInterpolatePixel: ::libc::c_uint = 2; +pub const BilinearInterpolatePixel: ::libc::c_uint = 3; +pub const FilterInterpolatePixel: ::libc::c_uint = 4; +pub const IntegerInterpolatePixel: ::libc::c_uint = 5; +pub const MeshInterpolatePixel: ::libc::c_uint = 6; +pub const NearestNeighborInterpolatePixel: ::libc::c_uint = 7; +pub const SplineInterpolatePixel: ::libc::c_uint = 8; +pub const Average9InterpolatePixel: ::libc::c_uint = 9; +pub const Average16InterpolatePixel: ::libc::c_uint = 10; +pub const BlendInterpolatePixel: ::libc::c_uint = 11; +pub const BackgroundInterpolatePixel: ::libc::c_uint = 12; +pub const CatromInterpolatePixel: ::libc::c_uint = 13; +pub type InterpolatePixelMethod = Enum_Unnamed15; +pub type Enum_Unnamed16 = ::libc::c_uint; +pub const PixelRed: ::libc::c_uint = 0; +pub const PixelCyan: ::libc::c_uint = 0; +pub const PixelGray: ::libc::c_uint = 0; +pub const PixelY: ::libc::c_uint = 0; +pub const PixelGreen: ::libc::c_uint = 1; +pub const PixelMagenta: ::libc::c_uint = 1; +pub const PixelCb: ::libc::c_uint = 1; +pub const PixelBlue: ::libc::c_uint = 2; +pub const PixelYellow: ::libc::c_uint = 2; +pub const PixelCr: ::libc::c_uint = 2; +pub const PixelAlpha: ::libc::c_uint = 3; +pub const PixelBlack: ::libc::c_uint = 4; +pub const PixelIndex: ::libc::c_uint = 4; +pub const MaskPixelComponent: ::libc::c_uint = 5; +pub type PixelComponent = Enum_Unnamed16; +pub type Enum_Unnamed17 = ::libc::c_uint; +pub const UndefinedPixelIntensityMethod: ::libc::c_uint = 0; +pub const AveragePixelIntensityMethod: ::libc::c_uint = 1; +pub const BrightnessPixelIntensityMethod: ::libc::c_uint = 2; +pub const LightnessPixelIntensityMethod: ::libc::c_uint = 3; +pub const Rec601LumaPixelIntensityMethod: ::libc::c_uint = 4; +pub const Rec601LuminancePixelIntensityMethod: ::libc::c_uint = 5; +pub const Rec709LumaPixelIntensityMethod: ::libc::c_uint = 6; +pub const Rec709LuminancePixelIntensityMethod: ::libc::c_uint = 7; +pub const RMSPixelIntensityMethod: ::libc::c_uint = 8; +pub const MSPixelIntensityMethod: ::libc::c_uint = 9; +pub type PixelIntensityMethod = Enum_Unnamed17; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__DoublePixelPacket { + pub red: ::libc::c_double, + pub green: ::libc::c_double, + pub blue: ::libc::c_double, + pub opacity: ::libc::c_double, + pub index: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__DoublePixelPacket { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__DoublePixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type DoublePixelPacket = Struct__DoublePixelPacket; +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct__LongPixelPacket { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__LongPixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type LongPixelPacket = Struct__LongPixelPacket; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__MagickPixelPacket { + pub storage_class: ClassType, + pub colorspace: ColorspaceType, + pub matte: MagickBooleanType, + pub fuzz: ::libc::c_double, + pub depth: size_t, + pub red: MagickRealType, + pub green: MagickRealType, + pub blue: MagickRealType, + pub opacity: MagickRealType, + pub index: MagickRealType, +} +impl ::std::clone::Clone for Struct__MagickPixelPacket { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__MagickPixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type MagickPixelPacket = Struct__MagickPixelPacket; +pub type IndexPacket = Quantum; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__PixelPacket { + pub blue: Quantum, + pub green: Quantum, + pub red: Quantum, + pub opacity: Quantum, +} +impl ::std::clone::Clone for Struct__PixelPacket { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__PixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PixelPacket = Struct__PixelPacket; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__QuantumPixelPacket { + pub red: Quantum, + pub green: Quantum, + pub blue: Quantum, + pub opacity: Quantum, + pub index: Quantum, +} +impl ::std::clone::Clone for Struct__QuantumPixelPacket { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__QuantumPixelPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type QuantumPixelPacket = Struct__QuantumPixelPacket; +pub enum Struct__CacheView { } +pub type CacheView_ = Struct__CacheView; +pub enum Struct_SemaphoreInfo { } +pub type SemaphoreInfo = Struct_SemaphoreInfo; +pub type Enum_Unnamed18 = ::libc::c_uint; +pub const UndefinedException: ::libc::c_uint = 0; +pub const WarningException: ::libc::c_uint = 300; +pub const ResourceLimitWarning: ::libc::c_uint = 300; +pub const TypeWarning: ::libc::c_uint = 305; +pub const OptionWarning: ::libc::c_uint = 310; +pub const DelegateWarning: ::libc::c_uint = 315; +pub const MissingDelegateWarning: ::libc::c_uint = 320; +pub const CorruptImageWarning: ::libc::c_uint = 325; +pub const FileOpenWarning: ::libc::c_uint = 330; +pub const BlobWarning: ::libc::c_uint = 335; +pub const StreamWarning: ::libc::c_uint = 340; +pub const CacheWarning: ::libc::c_uint = 345; +pub const CoderWarning: ::libc::c_uint = 350; +pub const FilterWarning: ::libc::c_uint = 352; +pub const ModuleWarning: ::libc::c_uint = 355; +pub const DrawWarning: ::libc::c_uint = 360; +pub const ImageWarning: ::libc::c_uint = 365; +pub const WandWarning: ::libc::c_uint = 370; +pub const RandomWarning: ::libc::c_uint = 375; +pub const XServerWarning: ::libc::c_uint = 380; +pub const MonitorWarning: ::libc::c_uint = 385; +pub const RegistryWarning: ::libc::c_uint = 390; +pub const ConfigureWarning: ::libc::c_uint = 395; +pub const PolicyWarning: ::libc::c_uint = 399; +pub const ErrorException: ::libc::c_uint = 400; +pub const ResourceLimitError: ::libc::c_uint = 400; +pub const TypeError: ::libc::c_uint = 405; +pub const OptionError: ::libc::c_uint = 410; +pub const DelegateError: ::libc::c_uint = 415; +pub const MissingDelegateError: ::libc::c_uint = 420; +pub const CorruptImageError: ::libc::c_uint = 425; +pub const FileOpenError: ::libc::c_uint = 430; +pub const BlobError: ::libc::c_uint = 435; +pub const StreamError: ::libc::c_uint = 440; +pub const CacheError: ::libc::c_uint = 445; +pub const CoderError: ::libc::c_uint = 450; +pub const FilterError: ::libc::c_uint = 452; +pub const ModuleError: ::libc::c_uint = 455; +pub const DrawError: ::libc::c_uint = 460; +pub const ImageError: ::libc::c_uint = 465; +pub const WandError: ::libc::c_uint = 470; +pub const RandomError: ::libc::c_uint = 475; +pub const XServerError: ::libc::c_uint = 480; +pub const MonitorError: ::libc::c_uint = 485; +pub const RegistryError: ::libc::c_uint = 490; +pub const ConfigureError: ::libc::c_uint = 495; +pub const PolicyError: ::libc::c_uint = 499; +pub const FatalErrorException: ::libc::c_uint = 700; +pub const ResourceLimitFatalError: ::libc::c_uint = 700; +pub const TypeFatalError: ::libc::c_uint = 705; +pub const OptionFatalError: ::libc::c_uint = 710; +pub const DelegateFatalError: ::libc::c_uint = 715; +pub const MissingDelegateFatalError: ::libc::c_uint = 720; +pub const CorruptImageFatalError: ::libc::c_uint = 725; +pub const FileOpenFatalError: ::libc::c_uint = 730; +pub const BlobFatalError: ::libc::c_uint = 735; +pub const StreamFatalError: ::libc::c_uint = 740; +pub const CacheFatalError: ::libc::c_uint = 745; +pub const CoderFatalError: ::libc::c_uint = 750; +pub const FilterFatalError: ::libc::c_uint = 752; +pub const ModuleFatalError: ::libc::c_uint = 755; +pub const DrawFatalError: ::libc::c_uint = 760; +pub const ImageFatalError: ::libc::c_uint = 765; +pub const WandFatalError: ::libc::c_uint = 770; +pub const RandomFatalError: ::libc::c_uint = 775; +pub const XServerFatalError: ::libc::c_uint = 780; +pub const MonitorFatalError: ::libc::c_uint = 785; +pub const RegistryFatalError: ::libc::c_uint = 790; +pub const ConfigureFatalError: ::libc::c_uint = 795; +pub const PolicyFatalError: ::libc::c_uint = 799; +pub type ExceptionType = Enum_Unnamed18; +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct__ExceptionInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__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 Enum_Unnamed19 = ::libc::c_uint; +pub const UndefinedCompliance: ::libc::c_uint = 0; +pub const NoCompliance: ::libc::c_uint = 0; +pub const SVGCompliance: ::libc::c_uint = 1; +pub const X11Compliance: ::libc::c_uint = 2; +pub const XPMCompliance: ::libc::c_uint = 4; +pub const AllCompliance: ::libc::c_uint = 2147483647; +pub type ComplianceType = Enum_Unnamed19; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__ColorInfo, + pub next: *mut Struct__ColorInfo, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__ColorInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ColorInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ColorInfo = Struct__ColorInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ErrorInfo { + pub mean_error_per_pixel: ::libc::c_double, + pub normalized_mean_error: ::libc::c_double, + pub normalized_maximum_error: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__ErrorInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ErrorInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ErrorInfo = Struct__ErrorInfo; +pub type Enum_Unnamed20 = ::libc::c_uint; +pub const UndefinedAlphaChannel: ::libc::c_uint = 0; +pub const ActivateAlphaChannel: ::libc::c_uint = 1; +pub const BackgroundAlphaChannel: ::libc::c_uint = 2; +pub const CopyAlphaChannel: ::libc::c_uint = 3; +pub const DeactivateAlphaChannel: ::libc::c_uint = 4; +pub const ExtractAlphaChannel: ::libc::c_uint = 5; +pub const OpaqueAlphaChannel: ::libc::c_uint = 6; +pub const ResetAlphaChannel: ::libc::c_uint = 7; +pub const SetAlphaChannel: ::libc::c_uint = 8; +pub const ShapeAlphaChannel: ::libc::c_uint = 9; +pub const TransparentAlphaChannel: ::libc::c_uint = 10; +pub const FlattenAlphaChannel: ::libc::c_uint = 11; +pub const RemoveAlphaChannel: ::libc::c_uint = 12; +pub const AssociateAlphaChannel: ::libc::c_uint = 13; +pub const DisassociateAlphaChannel: ::libc::c_uint = 14; +pub type AlphaChannelType = Enum_Unnamed20; +pub type Enum_Unnamed21 = ::libc::c_uint; +pub const UndefinedType: ::libc::c_uint = 0; +pub const BilevelType: ::libc::c_uint = 1; +pub const GrayscaleType: ::libc::c_uint = 2; +pub const GrayscaleMatteType: ::libc::c_uint = 3; +pub const PaletteType: ::libc::c_uint = 4; +pub const PaletteMatteType: ::libc::c_uint = 5; +pub const TrueColorType: ::libc::c_uint = 6; +pub const TrueColorMatteType: ::libc::c_uint = 7; +pub const ColorSeparationType: ::libc::c_uint = 8; +pub const ColorSeparationMatteType: ::libc::c_uint = 9; +pub const OptimizeType: ::libc::c_uint = 10; +pub const PaletteBilevelMatteType: ::libc::c_uint = 11; +pub type ImageType = Enum_Unnamed21; +pub type Enum_Unnamed22 = ::libc::c_uint; +pub const UndefinedInterlace: ::libc::c_uint = 0; +pub const NoInterlace: ::libc::c_uint = 1; +pub const LineInterlace: ::libc::c_uint = 2; +pub const PlaneInterlace: ::libc::c_uint = 3; +pub const PartitionInterlace: ::libc::c_uint = 4; +pub const GIFInterlace: ::libc::c_uint = 5; +pub const JPEGInterlace: ::libc::c_uint = 6; +pub const PNGInterlace: ::libc::c_uint = 7; +pub type InterlaceType = Enum_Unnamed22; +pub type Enum_Unnamed23 = ::libc::c_uint; +pub const UndefinedOrientation: ::libc::c_uint = 0; +pub const TopLeftOrientation: ::libc::c_uint = 1; +pub const TopRightOrientation: ::libc::c_uint = 2; +pub const BottomRightOrientation: ::libc::c_uint = 3; +pub const BottomLeftOrientation: ::libc::c_uint = 4; +pub const LeftTopOrientation: ::libc::c_uint = 5; +pub const RightTopOrientation: ::libc::c_uint = 6; +pub const RightBottomOrientation: ::libc::c_uint = 7; +pub const LeftBottomOrientation: ::libc::c_uint = 8; +pub type OrientationType = Enum_Unnamed23; +pub type Enum_Unnamed24 = ::libc::c_uint; +pub const UndefinedResolution: ::libc::c_uint = 0; +pub const PixelsPerInchResolution: ::libc::c_uint = 1; +pub const PixelsPerCentimeterResolution: ::libc::c_uint = 2; +pub type ResolutionType = Enum_Unnamed24; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__PrimaryInfo { + pub x: ::libc::c_double, + pub y: ::libc::c_double, + pub z: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__PrimaryInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__PrimaryInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PrimaryInfo = Struct__PrimaryInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__SegmentInfo { + pub x1: ::libc::c_double, + pub y1: ::libc::c_double, + pub x2: ::libc::c_double, + pub y2: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__SegmentInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__SegmentInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type SegmentInfo = Struct__SegmentInfo; +pub type Enum_Unnamed25 = ::libc::c_uint; +pub const UndefinedTransmitType: ::libc::c_uint = 0; +pub const FileTransmitType: ::libc::c_uint = 1; +pub const BlobTransmitType: ::libc::c_uint = 2; +pub const StreamTransmitType: ::libc::c_uint = 3; +pub const ImageTransmitType: ::libc::c_uint = 4; +pub type TransmitType = Enum_Unnamed25; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ChromaticityInfo { + pub red_primary: PrimaryInfo, + pub green_primary: PrimaryInfo, + pub blue_primary: PrimaryInfo, + pub white_point: PrimaryInfo, +} +impl ::std::clone::Clone for Struct__ChromaticityInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ChromaticityInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChromaticityInfo = Struct__ChromaticityInfo; +pub type StreamHandler = + ::std::option::Option size_t>; +pub type Enum_Unnamed26 = ::libc::c_uint; +pub const ReadMode: ::libc::c_uint = 0; +pub const WriteMode: ::libc::c_uint = 1; +pub const IOMode: ::libc::c_uint = 2; +pub type MapMode = Enum_Unnamed26; +pub type Enum_Unnamed27 = ::libc::c_uint; +pub const UndefinedVirtualPixelMethod: ::libc::c_uint = 0; +pub const BackgroundVirtualPixelMethod: ::libc::c_uint = 1; +pub const ConstantVirtualPixelMethod: ::libc::c_uint = 2; +pub const DitherVirtualPixelMethod: ::libc::c_uint = 3; +pub const EdgeVirtualPixelMethod: ::libc::c_uint = 4; +pub const MirrorVirtualPixelMethod: ::libc::c_uint = 5; +pub const RandomVirtualPixelMethod: ::libc::c_uint = 6; +pub const TileVirtualPixelMethod: ::libc::c_uint = 7; +pub const TransparentVirtualPixelMethod: ::libc::c_uint = 8; +pub const MaskVirtualPixelMethod: ::libc::c_uint = 9; +pub const BlackVirtualPixelMethod: ::libc::c_uint = 10; +pub const GrayVirtualPixelMethod: ::libc::c_uint = 11; +pub const WhiteVirtualPixelMethod: ::libc::c_uint = 12; +pub const HorizontalTileVirtualPixelMethod: ::libc::c_uint = 13; +pub const VerticalTileVirtualPixelMethod: ::libc::c_uint = 14; +pub const HorizontalTileEdgeVirtualPixelMethod: ::libc::c_uint = 15; +pub const VerticalTileEdgeVirtualPixelMethod: ::libc::c_uint = 16; +pub const CheckerTileVirtualPixelMethod: ::libc::c_uint = 17; +pub type VirtualPixelMethod = Enum_Unnamed27; +pub type CacheView = Struct__CacheView; +pub type Enum_Unnamed28 = ::libc::c_uint; +pub const UndefinedCompositeOp: ::libc::c_uint = 0; +pub const NoCompositeOp: ::libc::c_uint = 1; +pub const ModulusAddCompositeOp: ::libc::c_uint = 2; +pub const AtopCompositeOp: ::libc::c_uint = 3; +pub const BlendCompositeOp: ::libc::c_uint = 4; +pub const BumpmapCompositeOp: ::libc::c_uint = 5; +pub const ChangeMaskCompositeOp: ::libc::c_uint = 6; +pub const ClearCompositeOp: ::libc::c_uint = 7; +pub const ColorBurnCompositeOp: ::libc::c_uint = 8; +pub const ColorDodgeCompositeOp: ::libc::c_uint = 9; +pub const ColorizeCompositeOp: ::libc::c_uint = 10; +pub const CopyBlackCompositeOp: ::libc::c_uint = 11; +pub const CopyBlueCompositeOp: ::libc::c_uint = 12; +pub const CopyCompositeOp: ::libc::c_uint = 13; +pub const CopyCyanCompositeOp: ::libc::c_uint = 14; +pub const CopyGreenCompositeOp: ::libc::c_uint = 15; +pub const CopyMagentaCompositeOp: ::libc::c_uint = 16; +pub const CopyOpacityCompositeOp: ::libc::c_uint = 17; +pub const CopyRedCompositeOp: ::libc::c_uint = 18; +pub const CopyYellowCompositeOp: ::libc::c_uint = 19; +pub const DarkenCompositeOp: ::libc::c_uint = 20; +pub const DstAtopCompositeOp: ::libc::c_uint = 21; +pub const DstCompositeOp: ::libc::c_uint = 22; +pub const DstInCompositeOp: ::libc::c_uint = 23; +pub const DstOutCompositeOp: ::libc::c_uint = 24; +pub const DstOverCompositeOp: ::libc::c_uint = 25; +pub const DifferenceCompositeOp: ::libc::c_uint = 26; +pub const DisplaceCompositeOp: ::libc::c_uint = 27; +pub const DissolveCompositeOp: ::libc::c_uint = 28; +pub const ExclusionCompositeOp: ::libc::c_uint = 29; +pub const HardLightCompositeOp: ::libc::c_uint = 30; +pub const HueCompositeOp: ::libc::c_uint = 31; +pub const InCompositeOp: ::libc::c_uint = 32; +pub const LightenCompositeOp: ::libc::c_uint = 33; +pub const LinearLightCompositeOp: ::libc::c_uint = 34; +pub const LuminizeCompositeOp: ::libc::c_uint = 35; +pub const MinusDstCompositeOp: ::libc::c_uint = 36; +pub const ModulateCompositeOp: ::libc::c_uint = 37; +pub const MultiplyCompositeOp: ::libc::c_uint = 38; +pub const OutCompositeOp: ::libc::c_uint = 39; +pub const OverCompositeOp: ::libc::c_uint = 40; +pub const OverlayCompositeOp: ::libc::c_uint = 41; +pub const PlusCompositeOp: ::libc::c_uint = 42; +pub const ReplaceCompositeOp: ::libc::c_uint = 43; +pub const SaturateCompositeOp: ::libc::c_uint = 44; +pub const ScreenCompositeOp: ::libc::c_uint = 45; +pub const SoftLightCompositeOp: ::libc::c_uint = 46; +pub const SrcAtopCompositeOp: ::libc::c_uint = 47; +pub const SrcCompositeOp: ::libc::c_uint = 48; +pub const SrcInCompositeOp: ::libc::c_uint = 49; +pub const SrcOutCompositeOp: ::libc::c_uint = 50; +pub const SrcOverCompositeOp: ::libc::c_uint = 51; +pub const ModulusSubtractCompositeOp: ::libc::c_uint = 52; +pub const ThresholdCompositeOp: ::libc::c_uint = 53; +pub const XorCompositeOp: ::libc::c_uint = 54; +pub const DivideDstCompositeOp: ::libc::c_uint = 55; +pub const DistortCompositeOp: ::libc::c_uint = 56; +pub const BlurCompositeOp: ::libc::c_uint = 57; +pub const PegtopLightCompositeOp: ::libc::c_uint = 58; +pub const VividLightCompositeOp: ::libc::c_uint = 59; +pub const PinLightCompositeOp: ::libc::c_uint = 60; +pub const LinearDodgeCompositeOp: ::libc::c_uint = 61; +pub const LinearBurnCompositeOp: ::libc::c_uint = 62; +pub const MathematicsCompositeOp: ::libc::c_uint = 63; +pub const DivideSrcCompositeOp: ::libc::c_uint = 64; +pub const MinusSrcCompositeOp: ::libc::c_uint = 65; +pub const DarkenIntensityCompositeOp: ::libc::c_uint = 66; +pub const LightenIntensityCompositeOp: ::libc::c_uint = 67; +pub const HardMixCompositeOp: ::libc::c_uint = 68; +pub type CompositeOperator = Enum_Unnamed28; +pub type Enum_Unnamed29 = ::libc::c_uint; +pub const UndefinedCompression: ::libc::c_uint = 0; +pub const NoCompression: ::libc::c_uint = 1; +pub const BZipCompression: ::libc::c_uint = 2; +pub const DXT1Compression: ::libc::c_uint = 3; +pub const DXT3Compression: ::libc::c_uint = 4; +pub const DXT5Compression: ::libc::c_uint = 5; +pub const FaxCompression: ::libc::c_uint = 6; +pub const Group4Compression: ::libc::c_uint = 7; +pub const JPEGCompression: ::libc::c_uint = 8; +pub const JPEG2000Compression: ::libc::c_uint = 9; +pub const LosslessJPEGCompression: ::libc::c_uint = 10; +pub const LZWCompression: ::libc::c_uint = 11; +pub const RLECompression: ::libc::c_uint = 12; +pub const ZipCompression: ::libc::c_uint = 13; +pub const ZipSCompression: ::libc::c_uint = 14; +pub const PizCompression: ::libc::c_uint = 15; +pub const Pxr24Compression: ::libc::c_uint = 16; +pub const B44Compression: ::libc::c_uint = 17; +pub const B44ACompression: ::libc::c_uint = 18; +pub const LZMACompression: ::libc::c_uint = 19; +pub const JBIG1Compression: ::libc::c_uint = 20; +pub const JBIG2Compression: ::libc::c_uint = 21; +pub type CompressionType = Enum_Unnamed29; +pub enum Struct__Ascii85Info { } +pub type Ascii85Info = Struct__Ascii85Info; +pub type Enum_Unnamed30 = ::libc::c_uint; +pub const UndefinedKernel: ::libc::c_uint = 0; +pub const UnityKernel: ::libc::c_uint = 1; +pub const GaussianKernel: ::libc::c_uint = 2; +pub const DoGKernel: ::libc::c_uint = 3; +pub const LoGKernel: ::libc::c_uint = 4; +pub const BlurKernel: ::libc::c_uint = 5; +pub const CometKernel: ::libc::c_uint = 6; +pub const LaplacianKernel: ::libc::c_uint = 7; +pub const SobelKernel: ::libc::c_uint = 8; +pub const FreiChenKernel: ::libc::c_uint = 9; +pub const RobertsKernel: ::libc::c_uint = 10; +pub const PrewittKernel: ::libc::c_uint = 11; +pub const CompassKernel: ::libc::c_uint = 12; +pub const KirschKernel: ::libc::c_uint = 13; +pub const DiamondKernel: ::libc::c_uint = 14; +pub const SquareKernel: ::libc::c_uint = 15; +pub const RectangleKernel: ::libc::c_uint = 16; +pub const OctagonKernel: ::libc::c_uint = 17; +pub const DiskKernel: ::libc::c_uint = 18; +pub const PlusKernel: ::libc::c_uint = 19; +pub const CrossKernel: ::libc::c_uint = 20; +pub const RingKernel: ::libc::c_uint = 21; +pub const PeaksKernel: ::libc::c_uint = 22; +pub const EdgesKernel: ::libc::c_uint = 23; +pub const CornersKernel: ::libc::c_uint = 24; +pub const DiagonalsKernel: ::libc::c_uint = 25; +pub const LineEndsKernel: ::libc::c_uint = 26; +pub const LineJunctionsKernel: ::libc::c_uint = 27; +pub const RidgesKernel: ::libc::c_uint = 28; +pub const ConvexHullKernel: ::libc::c_uint = 29; +pub const ThinSEKernel: ::libc::c_uint = 30; +pub const SkeletonKernel: ::libc::c_uint = 31; +pub const ChebyshevKernel: ::libc::c_uint = 32; +pub const ManhattanKernel: ::libc::c_uint = 33; +pub const OctagonalKernel: ::libc::c_uint = 34; +pub const EuclideanKernel: ::libc::c_uint = 35; +pub const UserDefinedKernel: ::libc::c_uint = 36; +pub const BinomialKernel: ::libc::c_uint = 37; +pub type KernelInfoType = Enum_Unnamed30; +pub type Enum_Unnamed31 = ::libc::c_uint; +pub const UndefinedMorphology: ::libc::c_uint = 0; +pub const ConvolveMorphology: ::libc::c_uint = 1; +pub const CorrelateMorphology: ::libc::c_uint = 2; +pub const ErodeMorphology: ::libc::c_uint = 3; +pub const DilateMorphology: ::libc::c_uint = 4; +pub const ErodeIntensityMorphology: ::libc::c_uint = 5; +pub const DilateIntensityMorphology: ::libc::c_uint = 6; +pub const DistanceMorphology: ::libc::c_uint = 7; +pub const OpenMorphology: ::libc::c_uint = 8; +pub const CloseMorphology: ::libc::c_uint = 9; +pub const OpenIntensityMorphology: ::libc::c_uint = 10; +pub const CloseIntensityMorphology: ::libc::c_uint = 11; +pub const SmoothMorphology: ::libc::c_uint = 12; +pub const EdgeInMorphology: ::libc::c_uint = 13; +pub const EdgeOutMorphology: ::libc::c_uint = 14; +pub const EdgeMorphology: ::libc::c_uint = 15; +pub const TopHatMorphology: ::libc::c_uint = 16; +pub const BottomHatMorphology: ::libc::c_uint = 17; +pub const HitAndMissMorphology: ::libc::c_uint = 18; +pub const ThinningMorphology: ::libc::c_uint = 19; +pub const ThickenMorphology: ::libc::c_uint = 20; +pub const VoronoiMorphology: ::libc::c_uint = 21; +pub const IterativeDistanceMorphology: ::libc::c_uint = 22; +pub type MorphologyMethod = Enum_Unnamed31; +#[repr(C)] +#[derive(Copy)] +pub struct Struct_KernelInfo { + pub _type: KernelInfoType, + pub width: size_t, + pub height: size_t, + pub x: ssize_t, + pub y: ssize_t, + pub values: *mut ::libc::c_double, + pub minimum: ::libc::c_double, + pub maximum: ::libc::c_double, + pub negative_range: ::libc::c_double, + pub positive_range: ::libc::c_double, + pub angle: ::libc::c_double, + pub next: *mut Struct_KernelInfo, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct_KernelInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct_KernelInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type KernelInfo = Struct_KernelInfo; +pub type Enum_Unnamed32 = ::libc::c_uint; +pub const UndefinedPreview: ::libc::c_uint = 0; +pub const RotatePreview: ::libc::c_uint = 1; +pub const ShearPreview: ::libc::c_uint = 2; +pub const RollPreview: ::libc::c_uint = 3; +pub const HuePreview: ::libc::c_uint = 4; +pub const SaturationPreview: ::libc::c_uint = 5; +pub const BrightnessPreview: ::libc::c_uint = 6; +pub const GammaPreview: ::libc::c_uint = 7; +pub const SpiffPreview: ::libc::c_uint = 8; +pub const DullPreview: ::libc::c_uint = 9; +pub const GrayscalePreview: ::libc::c_uint = 10; +pub const QuantizePreview: ::libc::c_uint = 11; +pub const DespecklePreview: ::libc::c_uint = 12; +pub const ReduceNoisePreview: ::libc::c_uint = 13; +pub const AddNoisePreview: ::libc::c_uint = 14; +pub const SharpenPreview: ::libc::c_uint = 15; +pub const BlurPreview: ::libc::c_uint = 16; +pub const ThresholdPreview: ::libc::c_uint = 17; +pub const EdgeDetectPreview: ::libc::c_uint = 18; +pub const SpreadPreview: ::libc::c_uint = 19; +pub const SolarizePreview: ::libc::c_uint = 20; +pub const ShadePreview: ::libc::c_uint = 21; +pub const RaisePreview: ::libc::c_uint = 22; +pub const SegmentPreview: ::libc::c_uint = 23; +pub const SwirlPreview: ::libc::c_uint = 24; +pub const ImplodePreview: ::libc::c_uint = 25; +pub const WavePreview: ::libc::c_uint = 26; +pub const OilPaintPreview: ::libc::c_uint = 27; +pub const CharcoalDrawingPreview: ::libc::c_uint = 28; +pub const JPEGPreview: ::libc::c_uint = 29; +pub type PreviewType = Enum_Unnamed32; +pub type Enum_Unnamed33 = ::libc::c_uint; +pub const UnrecognizedDispose: ::libc::c_uint = 0; +pub const UndefinedDispose: ::libc::c_uint = 0; +pub const NoneDispose: ::libc::c_uint = 1; +pub const BackgroundDispose: ::libc::c_uint = 2; +pub const PreviousDispose: ::libc::c_uint = 3; +pub type DisposeType = Enum_Unnamed33; +pub type Enum_Unnamed34 = ::libc::c_uint; +pub const UndefinedLayer: ::libc::c_uint = 0; +pub const CoalesceLayer: ::libc::c_uint = 1; +pub const CompareAnyLayer: ::libc::c_uint = 2; +pub const CompareClearLayer: ::libc::c_uint = 3; +pub const CompareOverlayLayer: ::libc::c_uint = 4; +pub const DisposeLayer: ::libc::c_uint = 5; +pub const OptimizeLayer: ::libc::c_uint = 6; +pub const OptimizeImageLayer: ::libc::c_uint = 7; +pub const OptimizePlusLayer: ::libc::c_uint = 8; +pub const OptimizeTransLayer: ::libc::c_uint = 9; +pub const RemoveDupsLayer: ::libc::c_uint = 10; +pub const RemoveZeroLayer: ::libc::c_uint = 11; +pub const CompositeLayer: ::libc::c_uint = 12; +pub const MergeLayer: ::libc::c_uint = 13; +pub const FlattenLayer: ::libc::c_uint = 14; +pub const MosaicLayer: ::libc::c_uint = 15; +pub const TrimBoundsLayer: ::libc::c_uint = 16; +pub type ImageLayerMethod = Enum_Unnamed34; +pub enum Struct__HashmapInfo { } +pub type HashmapInfo = Struct__HashmapInfo; +pub enum Struct__LinkedListInfo { } +pub type LinkedListInfo = Struct__LinkedListInfo; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__LocaleInfo, + pub next: *mut Struct__LocaleInfo, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__LocaleInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__LocaleInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type LocaleInfo = Struct__LocaleInfo; +pub type MagickProgressMonitor = + ::std::option::Option MagickBooleanType>; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__StringInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__StringInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type StringInfo = Struct__StringInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ProfileInfo { + pub name: *mut ::libc::c_char, + pub length: size_t, + pub info: *mut ::libc::c_uchar, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__ProfileInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ProfileInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ProfileInfo = Struct__ProfileInfo; +pub type Enum_Unnamed35 = ::libc::c_uint; +pub const UndefinedIntent: ::libc::c_uint = 0; +pub const SaturationIntent: ::libc::c_uint = 1; +pub const PerceptualIntent: ::libc::c_uint = 2; +pub const AbsoluteIntent: ::libc::c_uint = 3; +pub const RelativeIntent: ::libc::c_uint = 4; +pub type RenderingIntent = Enum_Unnamed35; +pub type Enum_Unnamed36 = ::libc::c_uint; +pub const UndefinedEndian: ::libc::c_uint = 0; +pub const LSBEndian: ::libc::c_uint = 1; +pub const MSBEndian: ::libc::c_uint = 2; +pub type EndianType = Enum_Unnamed36; +pub type Enum_Unnamed37 = ::libc::c_uint; +pub const UndefinedQuantumAlpha: ::libc::c_uint = 0; +pub const AssociatedQuantumAlpha: ::libc::c_uint = 1; +pub const DisassociatedQuantumAlpha: ::libc::c_uint = 2; +pub type QuantumAlphaType = Enum_Unnamed37; +pub type Enum_Unnamed38 = ::libc::c_uint; +pub const UndefinedQuantumFormat: ::libc::c_uint = 0; +pub const FloatingPointQuantumFormat: ::libc::c_uint = 1; +pub const SignedQuantumFormat: ::libc::c_uint = 2; +pub const UnsignedQuantumFormat: ::libc::c_uint = 3; +pub type QuantumFormatType = Enum_Unnamed38; +pub type Enum_Unnamed39 = ::libc::c_uint; +pub const UndefinedQuantum: ::libc::c_uint = 0; +pub const AlphaQuantum: ::libc::c_uint = 1; +pub const BlackQuantum: ::libc::c_uint = 2; +pub const BlueQuantum: ::libc::c_uint = 3; +pub const CMYKAQuantum: ::libc::c_uint = 4; +pub const CMYKQuantum: ::libc::c_uint = 5; +pub const CyanQuantum: ::libc::c_uint = 6; +pub const GrayAlphaQuantum: ::libc::c_uint = 7; +pub const GrayQuantum: ::libc::c_uint = 8; +pub const GreenQuantum: ::libc::c_uint = 9; +pub const IndexAlphaQuantum: ::libc::c_uint = 10; +pub const IndexQuantum: ::libc::c_uint = 11; +pub const MagentaQuantum: ::libc::c_uint = 12; +pub const OpacityQuantum: ::libc::c_uint = 13; +pub const RedQuantum: ::libc::c_uint = 14; +pub const RGBAQuantum: ::libc::c_uint = 15; +pub const BGRAQuantum: ::libc::c_uint = 16; +pub const RGBOQuantum: ::libc::c_uint = 17; +pub const RGBQuantum: ::libc::c_uint = 18; +pub const YellowQuantum: ::libc::c_uint = 19; +pub const GrayPadQuantum: ::libc::c_uint = 20; +pub const RGBPadQuantum: ::libc::c_uint = 21; +pub const CbYCrYQuantum: ::libc::c_uint = 22; +pub const CbYCrQuantum: ::libc::c_uint = 23; +pub const CbYCrAQuantum: ::libc::c_uint = 24; +pub const CMYKOQuantum: ::libc::c_uint = 25; +pub const BGRQuantum: ::libc::c_uint = 26; +pub const BGROQuantum: ::libc::c_uint = 27; +pub type QuantumType = Enum_Unnamed39; +pub enum Struct__QuantumInfo { } +pub type QuantumInfo = Struct__QuantumInfo; +pub type Enum_Unnamed40 = ::libc::c_uint; +pub const UndefinedFilter: ::libc::c_uint = 0; +pub const PointFilter: ::libc::c_uint = 1; +pub const BoxFilter: ::libc::c_uint = 2; +pub const TriangleFilter: ::libc::c_uint = 3; +pub const HermiteFilter: ::libc::c_uint = 4; +pub const HanningFilter: ::libc::c_uint = 5; +pub const HammingFilter: ::libc::c_uint = 6; +pub const BlackmanFilter: ::libc::c_uint = 7; +pub const GaussianFilter: ::libc::c_uint = 8; +pub const QuadraticFilter: ::libc::c_uint = 9; +pub const CubicFilter: ::libc::c_uint = 10; +pub const CatromFilter: ::libc::c_uint = 11; +pub const MitchellFilter: ::libc::c_uint = 12; +pub const JincFilter: ::libc::c_uint = 13; +pub const SincFilter: ::libc::c_uint = 14; +pub const SincFastFilter: ::libc::c_uint = 15; +pub const KaiserFilter: ::libc::c_uint = 16; +pub const WelshFilter: ::libc::c_uint = 17; +pub const ParzenFilter: ::libc::c_uint = 18; +pub const BohmanFilter: ::libc::c_uint = 19; +pub const BartlettFilter: ::libc::c_uint = 20; +pub const LagrangeFilter: ::libc::c_uint = 21; +pub const LanczosFilter: ::libc::c_uint = 22; +pub const LanczosSharpFilter: ::libc::c_uint = 23; +pub const Lanczos2Filter: ::libc::c_uint = 24; +pub const Lanczos2SharpFilter: ::libc::c_uint = 25; +pub const RobidouxFilter: ::libc::c_uint = 26; +pub const RobidouxSharpFilter: ::libc::c_uint = 27; +pub const CosineFilter: ::libc::c_uint = 28; +pub const SplineFilter: ::libc::c_uint = 29; +pub const LanczosRadiusFilter: ::libc::c_uint = 30; +pub const SentinelFilter: ::libc::c_uint = 31; +pub type FilterTypes = Enum_Unnamed40; +pub enum Struct__ResampleFilter { } +pub type ResampleFilter = Struct__ResampleFilter; +pub enum Struct__ResizeFilter { } +pub type ResizeFilter = Struct__ResizeFilter; +pub type Enum_Unnamed41 = ::libc::c_uint; +pub const UndefinedTimerState: ::libc::c_uint = 0; +pub const StoppedTimerState: ::libc::c_uint = 1; +pub const RunningTimerState: ::libc::c_uint = 2; +pub type TimerState = Enum_Unnamed41; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__Timer { + pub start: ::libc::c_double, + pub stop: ::libc::c_double, + pub total: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__Timer { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__Timer { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type Timer = Struct__Timer; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__TimerInfo { + pub user: Timer, + pub elapsed: Timer, + pub state: TimerState, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__TimerInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__TimerInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type TimerInfo = Struct__TimerInfo; +#[repr(C)] +#[derive(Copy)] +pub struct 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: ::libc::c_double, + 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: ::libc::c_double, + pub y_resolution: ::libc::c_double, + pub page: RectangleInfo, + pub extract_info: RectangleInfo, + pub tile_info: RectangleInfo, + pub bias: ::libc::c_double, + pub blur: ::libc::c_double, + pub fuzz: ::libc::c_double, + pub filter: FilterTypes, + pub interlace: InterlaceType, + pub endian: EndianType, + pub gravity: GravityType, + pub compose: CompositeOperator, + pub dispose: DisposeType, + pub clip_mask: *mut Struct__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 Struct__Image, + pub list: *mut Struct__Image, + pub next: *mut Struct__Image, + pub interpolate: InterpolatePixelMethod, + pub black_point_compensation: MagickBooleanType, + pub transparent_color: PixelPacket, + pub mask: *mut Struct__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, +} +impl ::std::clone::Clone for Struct__Image { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__Image { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy)] +pub struct 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: ::libc::c_double, + pub fuzz: ::libc::c_double, + 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 Struct__ImageInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ImageInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type Enum_Unnamed42 = ::libc::c_uint; +pub const UndefinedStretch: ::libc::c_uint = 0; +pub const NormalStretch: ::libc::c_uint = 1; +pub const UltraCondensedStretch: ::libc::c_uint = 2; +pub const ExtraCondensedStretch: ::libc::c_uint = 3; +pub const CondensedStretch: ::libc::c_uint = 4; +pub const SemiCondensedStretch: ::libc::c_uint = 5; +pub const SemiExpandedStretch: ::libc::c_uint = 6; +pub const ExpandedStretch: ::libc::c_uint = 7; +pub const ExtraExpandedStretch: ::libc::c_uint = 8; +pub const UltraExpandedStretch: ::libc::c_uint = 9; +pub const AnyStretch: ::libc::c_uint = 10; +pub type StretchType = Enum_Unnamed42; +pub type Enum_Unnamed43 = ::libc::c_uint; +pub const UndefinedStyle: ::libc::c_uint = 0; +pub const NormalStyle: ::libc::c_uint = 1; +pub const ItalicStyle: ::libc::c_uint = 2; +pub const ObliqueStyle: ::libc::c_uint = 3; +pub const AnyStyle: ::libc::c_uint = 4; +pub type StyleType = Enum_Unnamed43; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__TypeInfo, + pub next: *mut Struct__TypeInfo, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__TypeInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__TypeInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type TypeInfo = Struct__TypeInfo; +pub type Enum_Unnamed44 = ::libc::c_uint; +pub const UndefinedAlign: ::libc::c_uint = 0; +pub const LeftAlign: ::libc::c_uint = 1; +pub const CenterAlign: ::libc::c_uint = 2; +pub const RightAlign: ::libc::c_uint = 3; +pub type AlignType = Enum_Unnamed44; +pub type Enum_Unnamed45 = ::libc::c_uint; +pub const UndefinedPathUnits: ::libc::c_uint = 0; +pub const UserSpace: ::libc::c_uint = 1; +pub const UserSpaceOnUse: ::libc::c_uint = 2; +pub const ObjectBoundingBox: ::libc::c_uint = 3; +pub type ClipPathUnits = Enum_Unnamed45; +pub type Enum_Unnamed46 = ::libc::c_uint; +pub const UndefinedDecoration: ::libc::c_uint = 0; +pub const NoDecoration: ::libc::c_uint = 1; +pub const UnderlineDecoration: ::libc::c_uint = 2; +pub const OverlineDecoration: ::libc::c_uint = 3; +pub const LineThroughDecoration: ::libc::c_uint = 4; +pub type DecorationType = Enum_Unnamed46; +pub type Enum_Unnamed47 = ::libc::c_uint; +pub const UndefinedDirection: ::libc::c_uint = 0; +pub const RightToLeftDirection: ::libc::c_uint = 1; +pub const LeftToRightDirection: ::libc::c_uint = 2; +pub type DirectionType = Enum_Unnamed47; +pub type Enum_Unnamed48 = ::libc::c_uint; +pub const UndefinedRule: ::libc::c_uint = 0; +pub const EvenOddRule: ::libc::c_uint = 1; +pub const NonZeroRule: ::libc::c_uint = 2; +pub type FillRule = Enum_Unnamed48; +pub type Enum_Unnamed49 = ::libc::c_uint; +pub const UndefinedGradient: ::libc::c_uint = 0; +pub const LinearGradient: ::libc::c_uint = 1; +pub const RadialGradient: ::libc::c_uint = 2; +pub type GradientType = Enum_Unnamed49; +pub type Enum_Unnamed50 = ::libc::c_uint; +pub const UndefinedCap: ::libc::c_uint = 0; +pub const ButtCap: ::libc::c_uint = 1; +pub const RoundCap: ::libc::c_uint = 2; +pub const SquareCap: ::libc::c_uint = 3; +pub type LineCap = Enum_Unnamed50; +pub type Enum_Unnamed51 = ::libc::c_uint; +pub const UndefinedJoin: ::libc::c_uint = 0; +pub const MiterJoin: ::libc::c_uint = 1; +pub const RoundJoin: ::libc::c_uint = 2; +pub const BevelJoin: ::libc::c_uint = 3; +pub type LineJoin = Enum_Unnamed51; +pub type Enum_Unnamed52 = ::libc::c_uint; +pub const UndefinedMethod: ::libc::c_uint = 0; +pub const PointMethod: ::libc::c_uint = 1; +pub const ReplaceMethod: ::libc::c_uint = 2; +pub const FloodfillMethod: ::libc::c_uint = 3; +pub const FillToBorderMethod: ::libc::c_uint = 4; +pub const ResetMethod: ::libc::c_uint = 5; +pub type PaintMethod = Enum_Unnamed52; +pub type Enum_Unnamed53 = ::libc::c_uint; +pub const UndefinedPrimitive: ::libc::c_uint = 0; +pub const PointPrimitive: ::libc::c_uint = 1; +pub const LinePrimitive: ::libc::c_uint = 2; +pub const RectanglePrimitive: ::libc::c_uint = 3; +pub const RoundRectanglePrimitive: ::libc::c_uint = 4; +pub const ArcPrimitive: ::libc::c_uint = 5; +pub const EllipsePrimitive: ::libc::c_uint = 6; +pub const CirclePrimitive: ::libc::c_uint = 7; +pub const PolylinePrimitive: ::libc::c_uint = 8; +pub const PolygonPrimitive: ::libc::c_uint = 9; +pub const BezierPrimitive: ::libc::c_uint = 10; +pub const ColorPrimitive: ::libc::c_uint = 11; +pub const MattePrimitive: ::libc::c_uint = 12; +pub const TextPrimitive: ::libc::c_uint = 13; +pub const ImagePrimitive: ::libc::c_uint = 14; +pub const PathPrimitive: ::libc::c_uint = 15; +pub type PrimitiveType = Enum_Unnamed53; +pub type Enum_Unnamed54 = ::libc::c_uint; +pub const UndefinedReference: ::libc::c_uint = 0; +pub const GradientReference: ::libc::c_uint = 1; +pub type ReferenceType = Enum_Unnamed54; +pub type Enum_Unnamed55 = ::libc::c_uint; +pub const UndefinedSpread: ::libc::c_uint = 0; +pub const PadSpread: ::libc::c_uint = 1; +pub const ReflectSpread: ::libc::c_uint = 2; +pub const RepeatSpread: ::libc::c_uint = 3; +pub type SpreadMethod = Enum_Unnamed55; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__PointInfo { + pub x: ::libc::c_double, + pub y: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__PointInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__PointInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PointInfo = Struct__PointInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__StopInfo { + pub color: MagickPixelPacket, + pub offset: MagickRealType, +} +impl ::std::clone::Clone for Struct__StopInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__StopInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type StopInfo = Struct__StopInfo; +#[repr(C)] +#[derive(Copy)] +pub struct 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, +} +impl ::std::clone::Clone for Struct__GradientInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__GradientInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type GradientInfo = Struct__GradientInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ElementReference { + pub id: *mut ::libc::c_char, + pub _type: ReferenceType, + pub gradient: GradientInfo, + pub signature: size_t, + pub previous: *mut Struct__ElementReference, + pub next: *mut Struct__ElementReference, +} +impl ::std::clone::Clone for Struct__ElementReference { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ElementReference { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ElementReference = Struct__ElementReference; +#[repr(C)] +#[derive(Copy)] +pub struct 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: ::libc::c_double, + 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: ::libc::c_double, + 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: ::libc::c_double, + 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 ::libc::c_double, + 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: ::libc::c_double, + pub interword_spacing: ::libc::c_double, + pub interline_spacing: ::libc::c_double, + pub direction: DirectionType, +} +impl ::std::clone::Clone for Struct__DrawInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__DrawInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type DrawInfo = Struct__DrawInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__PrimitiveInfo { + pub point: PointInfo, + pub coordinates: size_t, + pub primitive: PrimitiveType, + pub method: PaintMethod, + pub text: *mut ::libc::c_char, +} +impl ::std::clone::Clone for Struct__PrimitiveInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__PrimitiveInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type PrimitiveInfo = Struct__PrimitiveInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__TypeMetric { + pub pixels_per_em: PointInfo, + pub ascent: ::libc::c_double, + pub descent: ::libc::c_double, + pub width: ::libc::c_double, + pub height: ::libc::c_double, + pub max_advance: ::libc::c_double, + pub underline_position: ::libc::c_double, + pub underline_thickness: ::libc::c_double, + pub bounds: SegmentInfo, + pub origin: PointInfo, +} +impl ::std::clone::Clone for Struct__TypeMetric { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__TypeMetric { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type TypeMetric = Struct__TypeMetric; +pub type Enum_Unnamed56 = ::libc::c_uint; +pub const UndefinedNoise: ::libc::c_uint = 0; +pub const UniformNoise: ::libc::c_uint = 1; +pub const GaussianNoise: ::libc::c_uint = 2; +pub const MultiplicativeGaussianNoise: ::libc::c_uint = 3; +pub const ImpulseNoise: ::libc::c_uint = 4; +pub const LaplacianNoise: ::libc::c_uint = 5; +pub const PoissonNoise: ::libc::c_uint = 6; +pub const RandomNoise: ::libc::c_uint = 7; +pub type NoiseType = Enum_Unnamed56; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ChannelStatistics { + pub depth: size_t, + pub minima: ::libc::c_double, + pub maxima: ::libc::c_double, + pub sum: ::libc::c_double, + pub sum_squared: ::libc::c_double, + pub sum_cubed: ::libc::c_double, + pub sum_fourth_power: ::libc::c_double, + pub mean: ::libc::c_double, + pub variance: ::libc::c_double, + pub standard_deviation: ::libc::c_double, + pub kurtosis: ::libc::c_double, + pub skewness: ::libc::c_double, + pub entropy: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__ChannelStatistics { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ChannelStatistics { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChannelStatistics = Struct__ChannelStatistics; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ChannelMoments { + pub I: [::libc::c_double; 32usize], + pub centroid: PointInfo, + pub ellipse_axis: PointInfo, + pub ellipse_angle: ::libc::c_double, + pub ellipse_eccentricity: ::libc::c_double, + pub ellipse_intensity: ::libc::c_double, +} +impl ::std::clone::Clone for Struct__ChannelMoments { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ChannelMoments { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChannelMoments = Struct__ChannelMoments; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ChannelPerceptualHash { + pub P: [::libc::c_double; 32usize], + pub Q: [::libc::c_double; 32usize], +} +impl ::std::clone::Clone for Struct__ChannelPerceptualHash { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ChannelPerceptualHash { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChannelPerceptualHash = Struct__ChannelPerceptualHash; +pub type Enum_Unnamed57 = ::libc::c_uint; +pub const UndefinedEvaluateOperator: ::libc::c_uint = 0; +pub const AddEvaluateOperator: ::libc::c_uint = 1; +pub const AndEvaluateOperator: ::libc::c_uint = 2; +pub const DivideEvaluateOperator: ::libc::c_uint = 3; +pub const LeftShiftEvaluateOperator: ::libc::c_uint = 4; +pub const MaxEvaluateOperator: ::libc::c_uint = 5; +pub const MinEvaluateOperator: ::libc::c_uint = 6; +pub const MultiplyEvaluateOperator: ::libc::c_uint = 7; +pub const OrEvaluateOperator: ::libc::c_uint = 8; +pub const RightShiftEvaluateOperator: ::libc::c_uint = 9; +pub const SetEvaluateOperator: ::libc::c_uint = 10; +pub const SubtractEvaluateOperator: ::libc::c_uint = 11; +pub const XorEvaluateOperator: ::libc::c_uint = 12; +pub const PowEvaluateOperator: ::libc::c_uint = 13; +pub const LogEvaluateOperator: ::libc::c_uint = 14; +pub const ThresholdEvaluateOperator: ::libc::c_uint = 15; +pub const ThresholdBlackEvaluateOperator: ::libc::c_uint = 16; +pub const ThresholdWhiteEvaluateOperator: ::libc::c_uint = 17; +pub const GaussianNoiseEvaluateOperator: ::libc::c_uint = 18; +pub const ImpulseNoiseEvaluateOperator: ::libc::c_uint = 19; +pub const LaplacianNoiseEvaluateOperator: ::libc::c_uint = 20; +pub const MultiplicativeNoiseEvaluateOperator: ::libc::c_uint = 21; +pub const PoissonNoiseEvaluateOperator: ::libc::c_uint = 22; +pub const UniformNoiseEvaluateOperator: ::libc::c_uint = 23; +pub const CosineEvaluateOperator: ::libc::c_uint = 24; +pub const SineEvaluateOperator: ::libc::c_uint = 25; +pub const AddModulusEvaluateOperator: ::libc::c_uint = 26; +pub const MeanEvaluateOperator: ::libc::c_uint = 27; +pub const AbsEvaluateOperator: ::libc::c_uint = 28; +pub const ExponentialEvaluateOperator: ::libc::c_uint = 29; +pub const MedianEvaluateOperator: ::libc::c_uint = 30; +pub const SumEvaluateOperator: ::libc::c_uint = 31; +pub const RootMeanSquareEvaluateOperator: ::libc::c_uint = 32; +pub type MagickEvaluateOperator = Enum_Unnamed57; +pub type Enum_Unnamed58 = ::libc::c_uint; +pub const UndefinedFunction: ::libc::c_uint = 0; +pub const PolynomialFunction: ::libc::c_uint = 1; +pub const SinusoidFunction: ::libc::c_uint = 2; +pub const ArcsinFunction: ::libc::c_uint = 3; +pub const ArctanFunction: ::libc::c_uint = 4; +pub type MagickFunction = Enum_Unnamed58; +pub type Enum_Unnamed59 = ::libc::c_uint; +pub const UndefinedStatistic: ::libc::c_uint = 0; +pub const GradientStatistic: ::libc::c_uint = 1; +pub const MaximumStatistic: ::libc::c_uint = 2; +pub const MeanStatistic: ::libc::c_uint = 3; +pub const MedianStatistic: ::libc::c_uint = 4; +pub const MinimumStatistic: ::libc::c_uint = 5; +pub const ModeStatistic: ::libc::c_uint = 6; +pub const NonpeakStatistic: ::libc::c_uint = 7; +pub const StandardDeviationStatistic: ::libc::c_uint = 8; +pub const RootMeanSquareStatistic: ::libc::c_uint = 9; +pub type StatisticType = Enum_Unnamed59; +pub type Enum_Unnamed60 = ::libc::c_uint; +pub const UndefinedCache: ::libc::c_uint = 0; +pub const MemoryCache: ::libc::c_uint = 1; +pub const MapCache: ::libc::c_uint = 2; +pub const DiskCache: ::libc::c_uint = 3; +pub const PingCache: ::libc::c_uint = 4; +pub const DistributedCache: ::libc::c_uint = 5; +pub type CacheType = Enum_Unnamed60; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__CoderInfo, + pub next: *mut Struct__CoderInfo, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__CoderInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__CoderInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type CoderInfo = Struct__CoderInfo; +pub type Enum_Unnamed61 = ::libc::c_uint; +pub const UndefinedMetric: ::libc::c_uint = 0; +pub const AbsoluteErrorMetric: ::libc::c_uint = 1; +pub const MeanAbsoluteErrorMetric: ::libc::c_uint = 2; +pub const MeanErrorPerPixelMetric: ::libc::c_uint = 3; +pub const MeanSquaredErrorMetric: ::libc::c_uint = 4; +pub const PeakAbsoluteErrorMetric: ::libc::c_uint = 5; +pub const PeakSignalToNoiseRatioMetric: ::libc::c_uint = 6; +pub const RootMeanSquaredErrorMetric: ::libc::c_uint = 7; +pub const NormalizedCrossCorrelationErrorMetric: ::libc::c_uint = 8; +pub const FuzzErrorMetric: ::libc::c_uint = 9; +pub const UndefinedErrorMetric: ::libc::c_uint = 0; +pub const PerceptualHashErrorMetric: ::libc::c_uint = 255; +pub type MetricType = Enum_Unnamed61; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__ConfigureInfo, + pub next: *mut Struct__ConfigureInfo, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__ConfigureInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ConfigureInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ConfigureInfo = Struct__ConfigureInfo; +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct__FrameInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__FrameInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type FrameInfo = Struct__FrameInfo; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__DelegateInfo, + pub next: *mut Struct__DelegateInfo, + pub signature: size_t, + pub semaphore: *mut SemaphoreInfo, +} +impl ::std::clone::Clone for Struct__DelegateInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__DelegateInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type DelegateInfo = Struct__DelegateInfo; +pub type Enum_Unnamed62 = ::libc::c_uint; +pub const UndefinedDitherMethod: ::libc::c_uint = 0; +pub const NoDitherMethod: ::libc::c_uint = 1; +pub const RiemersmaDitherMethod: ::libc::c_uint = 2; +pub const FloydSteinbergDitherMethod: ::libc::c_uint = 3; +pub type DitherMethod = Enum_Unnamed62; +#[repr(C)] +#[derive(Copy)] +pub struct 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, +} +impl ::std::clone::Clone for Struct__QuantizeInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__QuantizeInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type QuantizeInfo = Struct__QuantizeInfo; +pub type Enum_Unnamed63 = ::libc::c_uint; +pub const UndefinedRegistryType: ::libc::c_uint = 0; +pub const ImageRegistryType: ::libc::c_uint = 1; +pub const ImageInfoRegistryType: ::libc::c_uint = 2; +pub const StringRegistryType: ::libc::c_uint = 3; +pub type RegistryType = Enum_Unnamed63; +pub type Enum_Unnamed64 = ::libc::c_uint; +pub const UndefinedMagickLayerMethod: ::libc::c_uint = 0; +pub type MagickLayerMethod = Enum_Unnamed64; +pub type ExtendedSignedIntegralType = MagickOffsetType; +pub type ExtendedUnsignedIntegralType = MagickSizeType; +pub type ExtendedRationalType = MagickRealType; +pub enum Struct__ViewInfo { } +pub type ViewInfo = Struct__ViewInfo; +pub type MonitorHandler = + ::std::option::Option MagickBooleanType>; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ImageAttribute { + pub key: *mut ::libc::c_char, + pub value: *mut ::libc::c_char, + pub compression: MagickBooleanType, + pub previous: *mut Struct__ImageAttribute, + pub next: *mut Struct__ImageAttribute, +} +impl ::std::clone::Clone for Struct__ImageAttribute { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ImageAttribute { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ImageAttribute = Struct__ImageAttribute; +pub type Enum_Unnamed65 = ::libc::c_uint; +pub const UndefinedDistortion: ::libc::c_uint = 0; +pub const AffineDistortion: ::libc::c_uint = 1; +pub const AffineProjectionDistortion: ::libc::c_uint = 2; +pub const ScaleRotateTranslateDistortion: ::libc::c_uint = 3; +pub const PerspectiveDistortion: ::libc::c_uint = 4; +pub const PerspectiveProjectionDistortion: ::libc::c_uint = 5; +pub const BilinearForwardDistortion: ::libc::c_uint = 6; +pub const BilinearDistortion: ::libc::c_uint = 6; +pub const BilinearReverseDistortion: ::libc::c_uint = 7; +pub const PolynomialDistortion: ::libc::c_uint = 8; +pub const ArcDistortion: ::libc::c_uint = 9; +pub const PolarDistortion: ::libc::c_uint = 10; +pub const DePolarDistortion: ::libc::c_uint = 11; +pub const Cylinder2PlaneDistortion: ::libc::c_uint = 12; +pub const Plane2CylinderDistortion: ::libc::c_uint = 13; +pub const BarrelDistortion: ::libc::c_uint = 14; +pub const BarrelInverseDistortion: ::libc::c_uint = 15; +pub const ShepardsDistortion: ::libc::c_uint = 16; +pub const ResizeDistortion: ::libc::c_uint = 17; +pub const SentinelDistortion: ::libc::c_uint = 18; +pub type DistortImageMethod = Enum_Unnamed65; +pub type Enum_Unnamed66 = ::libc::c_uint; +pub const UndefinedColorInterpolate: ::libc::c_uint = 0; +pub const BarycentricColorInterpolate: ::libc::c_uint = 1; +pub const BilinearColorInterpolate: ::libc::c_uint = 7; +pub const PolynomialColorInterpolate: ::libc::c_uint = 8; +pub const ShepardsColorInterpolate: ::libc::c_uint = 16; +pub const VoronoiColorInterpolate: ::libc::c_uint = 18; +pub const InverseColorInterpolate: ::libc::c_uint = 19; +pub type SparseColorMethod = Enum_Unnamed66; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ChannelFeatures { + pub angular_second_moment: [::libc::c_double; 4usize], + pub contrast: [::libc::c_double; 4usize], + pub correlation: [::libc::c_double; 4usize], + pub variance_sum_of_squares: [::libc::c_double; 4usize], + pub inverse_difference_moment: [::libc::c_double; 4usize], + pub sum_average: [::libc::c_double; 4usize], + pub sum_variance: [::libc::c_double; 4usize], + pub sum_entropy: [::libc::c_double; 4usize], + pub entropy: [::libc::c_double; 4usize], + pub difference_variance: [::libc::c_double; 4usize], + pub difference_entropy: [::libc::c_double; 4usize], + pub measure_of_correlation_1: [::libc::c_double; 4usize], + pub measure_of_correlation_2: [::libc::c_double; 4usize], + pub maximum_correlation_coefficient: [::libc::c_double; 4usize], +} +impl ::std::clone::Clone for Struct__ChannelFeatures { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ChannelFeatures { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ChannelFeatures = Struct__ChannelFeatures; +pub type Enum_Unnamed67 = ::libc::c_uint; +pub const UndefinedComplexOperator: ::libc::c_uint = 0; +pub const AddComplexOperator: ::libc::c_uint = 1; +pub const ConjugateComplexOperator: ::libc::c_uint = 2; +pub const DivideComplexOperator: ::libc::c_uint = 3; +pub const MagnitudePhaseComplexOperator: ::libc::c_uint = 4; +pub const MultiplyComplexOperator: ::libc::c_uint = 5; +pub const RealImaginaryComplexOperator: ::libc::c_uint = 6; +pub const SubtractComplexOperator: ::libc::c_uint = 7; +pub type ComplexOperator = Enum_Unnamed67; +pub enum Struct__RandomInfo { } +pub type RandomInfo = Struct__RandomInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__ColorPacket { + pub pixel: PixelPacket, + pub index: IndexPacket, + pub count: MagickSizeType, +} +impl ::std::clone::Clone for Struct__ColorPacket { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ColorPacket { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ColorPacket = Struct__ColorPacket; +pub enum Struct__ImageView { } +pub type ImageView = Struct__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 Enum_Unnamed68 = ::libc::c_uint; +pub const UndefinedEvents: ::libc::c_uint = 0; +pub const NoEvents: ::libc::c_uint = 0; +pub const TraceEvent: ::libc::c_uint = 1; +pub const AnnotateEvent: ::libc::c_uint = 2; +pub const BlobEvent: ::libc::c_uint = 4; +pub const CacheEvent: ::libc::c_uint = 8; +pub const CoderEvent: ::libc::c_uint = 16; +pub const ConfigureEvent: ::libc::c_uint = 32; +pub const DeprecateEvent: ::libc::c_uint = 64; +pub const DrawEvent: ::libc::c_uint = 128; +pub const ExceptionEvent: ::libc::c_uint = 256; +pub const ImageEvent: ::libc::c_uint = 512; +pub const LocaleEvent: ::libc::c_uint = 1024; +pub const ModuleEvent: ::libc::c_uint = 2048; +pub const PolicyEvent: ::libc::c_uint = 4096; +pub const ResourceEvent: ::libc::c_uint = 8192; +pub const TransformEvent: ::libc::c_uint = 16384; +pub const UserEvent: ::libc::c_uint = 36864; +pub const WandEvent: ::libc::c_uint = 65536; +pub const X11Event: ::libc::c_uint = 131072; +pub const AccelerateEvent: ::libc::c_uint = 262144; +pub const AllEvents: ::libc::c_uint = 2147483647; +pub type LogEventType = Enum_Unnamed68; +pub enum Struct__LogInfo { } +pub type LogInfo = Struct__LogInfo; +pub type MagickLogMethod = + ::std::option::Option ()>; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__MagicInfo, + pub next: *mut Struct__MagicInfo, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__MagicInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__MagicInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type MagicInfo = Struct__MagicInfo; +pub type Enum_Unnamed69 = ::libc::c_uint; +pub const UndefinedFormatType: ::libc::c_uint = 0; +pub const ImplicitFormatType: ::libc::c_uint = 1; +pub const ExplicitFormatType: ::libc::c_uint = 2; +pub type MagickFormatType = Enum_Unnamed69; +pub type Enum_Unnamed70 = ::libc::c_uint; +pub const NoThreadSupport: ::libc::c_uint = 0; +pub const DecoderThreadSupport: ::libc::c_uint = 1; +pub const EncoderThreadSupport: ::libc::c_uint = 2; +pub type MagickThreadSupport = Enum_Unnamed70; +pub type DecodeImageHandler = + extern "C" fn(arg1: *const ImageInfo, arg2: *mut ExceptionInfo) + -> *mut Image; +pub type EncodeImageHandler = + extern "C" fn(arg1: *const ImageInfo, arg2: *mut Image) + -> MagickBooleanType; +pub type IsImageFormatHandler = + extern "C" fn(arg1: *const ::libc::c_uchar, arg2: size_t) + -> MagickBooleanType; +#[repr(C)] +#[derive(Copy)] +pub struct 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: *mut ::std::option::Option *mut Image>, + pub encoder: *mut ::std::option::Option MagickBooleanType>, + pub magick: *mut ::std::option::Option MagickBooleanType>, + 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 Struct__MagickInfo, + pub next: *mut Struct__MagickInfo, + pub signature: size_t, + pub mime_type: *mut ::libc::c_char, + pub semaphore: *mut SemaphoreInfo, +} +impl ::std::clone::Clone for Struct__MagickInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__MagickInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type MagickInfo = Struct__MagickInfo; +pub enum Struct__MatrixInfo { } +pub type MatrixInfo = Struct__MatrixInfo; +pub enum Struct__MemoryInfo { } +pub type MemoryInfo = Struct__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 Enum_Unnamed71 = ::libc::c_uint; +pub const MagickImageCoderModule: ::libc::c_uint = 0; +pub const MagickImageFilterModule: ::libc::c_uint = 1; +pub type MagickModuleType = Enum_Unnamed71; +#[repr(C)] +#[derive(Copy)] +pub struct 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 Struct__ModuleInfo, + pub next: *mut Struct__ModuleInfo, + pub signature: size_t, +} +impl ::std::clone::Clone for Struct__ModuleInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__ModuleInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type ModuleInfo = Struct__ModuleInfo; +pub type ImageFilterHandler = + extern "C" fn(arg1: *mut *mut Image, arg2: ::libc::c_int, + arg3: *mut *const ::libc::c_char, arg4: *mut ExceptionInfo) + -> size_t; +pub enum Struct__MimeInfo { } +pub type MimeInfo = Struct__MimeInfo; +pub type Enum_Unnamed72 = ::libc::c_uint; +pub const UndefinedMode: ::libc::c_uint = 0; +pub const FrameMode: ::libc::c_uint = 1; +pub const UnframeMode: ::libc::c_uint = 2; +pub const ConcatenateMode: ::libc::c_uint = 3; +pub type MontageMode = Enum_Unnamed72; +#[repr(C)] +#[derive(Copy)] +pub struct 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: ::libc::c_double, + 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 Struct__MontageInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__MontageInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type MontageInfo = Struct__MontageInfo; +pub type Enum_Unnamed73 = ::libc::c_uint; +pub const MAGICK_OPENCL_ACCELERATE: ::libc::c_uint = 0; +pub const MAGICK_OPENCL_NUM_PROGRAMS: ::libc::c_uint = 1; +pub type MagickOpenCLProgram = Enum_Unnamed73; +pub enum Struct__MagickCLEnv { } +pub type MagickCLEnv = *mut Struct__MagickCLEnv; +pub type Enum_Unnamed74 = ::libc::c_uint; +pub const MAGICK_OPENCL_ENV_PARAM_DEVICE: ::libc::c_uint = 0; +pub const MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED: ::libc::c_uint = 1; +pub const MAGICK_OPENCL_ENV_PARAM_OPENCL_INITIALIZED: ::libc::c_uint = 2; +pub const MAGICK_OPENCL_ENV_PARAM_PROGRAM_CACHE_DISABLED: ::libc::c_uint = 3; +pub const MAGICK_OPENCL_ENV_PARAM_REGENERATE_PROFILE: ::libc::c_uint = 4; +pub type MagickOpenCLEnvParam = Enum_Unnamed74; +pub type Enum_Unnamed75 = ::libc::c_uint; +pub const MAGICK_OPENCL_OFF: ::libc::c_uint = 0; +pub const MAGICK_OPENCL_DEVICE_SELECT_AUTO: ::libc::c_uint = 1; +pub const MAGICK_OPENCL_DEVICE_SELECT_USER: ::libc::c_uint = 2; +pub const MAGICK_OPENCL_DEVICE_SELECT_AUTO_CLEAR_CACHE: ::libc::c_uint = 3; +pub type ImageMagickOpenCLMode = Enum_Unnamed75; +pub type Enum_Unnamed76 = ::libc::c_int; +pub const MagickUndefinedOptions: ::libc::c_int = -1; +pub const MagickAlignOptions: ::libc::c_int = 0; +pub const MagickAlphaOptions: ::libc::c_int = 1; +pub const MagickBooleanOptions: ::libc::c_int = 2; +pub const MagickCacheOptions: ::libc::c_int = 3; +pub const MagickChannelOptions: ::libc::c_int = 4; +pub const MagickClassOptions: ::libc::c_int = 5; +pub const MagickClipPathOptions: ::libc::c_int = 6; +pub const MagickCoderOptions: ::libc::c_int = 7; +pub const MagickColorOptions: ::libc::c_int = 8; +pub const MagickColorspaceOptions: ::libc::c_int = 9; +pub const MagickCommandOptions: ::libc::c_int = 10; +pub const MagickComposeOptions: ::libc::c_int = 11; +pub const MagickCompressOptions: ::libc::c_int = 12; +pub const MagickConfigureOptions: ::libc::c_int = 13; +pub const MagickDataTypeOptions: ::libc::c_int = 14; +pub const MagickDebugOptions: ::libc::c_int = 15; +pub const MagickDecorateOptions: ::libc::c_int = 16; +pub const MagickDelegateOptions: ::libc::c_int = 17; +pub const MagickDirectionOptions: ::libc::c_int = 18; +pub const MagickDisposeOptions: ::libc::c_int = 19; +pub const MagickDistortOptions: ::libc::c_int = 20; +pub const MagickDitherOptions: ::libc::c_int = 21; +pub const MagickEndianOptions: ::libc::c_int = 22; +pub const MagickEvaluateOptions: ::libc::c_int = 23; +pub const MagickFillRuleOptions: ::libc::c_int = 24; +pub const MagickFilterOptions: ::libc::c_int = 25; +pub const MagickFontOptions: ::libc::c_int = 26; +pub const MagickFontsOptions: ::libc::c_int = 27; +pub const MagickFormatOptions: ::libc::c_int = 28; +pub const MagickFunctionOptions: ::libc::c_int = 29; +pub const MagickGravityOptions: ::libc::c_int = 30; +pub const MagickIntentOptions: ::libc::c_int = 31; +pub const MagickInterlaceOptions: ::libc::c_int = 32; +pub const MagickInterpolateOptions: ::libc::c_int = 33; +pub const MagickKernelOptions: ::libc::c_int = 34; +pub const MagickLayerOptions: ::libc::c_int = 35; +pub const MagickLineCapOptions: ::libc::c_int = 36; +pub const MagickLineJoinOptions: ::libc::c_int = 37; +pub const MagickListOptions: ::libc::c_int = 38; +pub const MagickLocaleOptions: ::libc::c_int = 39; +pub const MagickLogEventOptions: ::libc::c_int = 40; +pub const MagickLogOptions: ::libc::c_int = 41; +pub const MagickMagicOptions: ::libc::c_int = 42; +pub const MagickMethodOptions: ::libc::c_int = 43; +pub const MagickMetricOptions: ::libc::c_int = 44; +pub const MagickMimeOptions: ::libc::c_int = 45; +pub const MagickModeOptions: ::libc::c_int = 46; +pub const MagickModuleOptions: ::libc::c_int = 47; +pub const MagickMorphologyOptions: ::libc::c_int = 48; +pub const MagickNoiseOptions: ::libc::c_int = 49; +pub const MagickOrientationOptions: ::libc::c_int = 50; +pub const MagickPixelIntensityOptions: ::libc::c_int = 51; +pub const MagickPolicyOptions: ::libc::c_int = 52; +pub const MagickPolicyDomainOptions: ::libc::c_int = 53; +pub const MagickPolicyRightsOptions: ::libc::c_int = 54; +pub const MagickPreviewOptions: ::libc::c_int = 55; +pub const MagickPrimitiveOptions: ::libc::c_int = 56; +pub const MagickQuantumFormatOptions: ::libc::c_int = 57; +pub const MagickResolutionOptions: ::libc::c_int = 58; +pub const MagickResourceOptions: ::libc::c_int = 59; +pub const MagickSparseColorOptions: ::libc::c_int = 60; +pub const MagickStatisticOptions: ::libc::c_int = 61; +pub const MagickStorageOptions: ::libc::c_int = 62; +pub const MagickStretchOptions: ::libc::c_int = 63; +pub const MagickStyleOptions: ::libc::c_int = 64; +pub const MagickThresholdOptions: ::libc::c_int = 65; +pub const MagickTypeOptions: ::libc::c_int = 66; +pub const MagickValidateOptions: ::libc::c_int = 67; +pub const MagickVirtualPixelOptions: ::libc::c_int = 68; +pub const MagickComplexOptions: ::libc::c_int = 69; +pub const MagickIntensityOptions: ::libc::c_int = 70; +pub type CommandOption = Enum_Unnamed76; +pub type Enum_Unnamed77 = ::libc::c_uint; +pub const UndefinedValidate: ::libc::c_uint = 0; +pub const NoValidate: ::libc::c_uint = 0; +pub const ColorspaceValidate: ::libc::c_uint = 1; +pub const CompareValidate: ::libc::c_uint = 2; +pub const CompositeValidate: ::libc::c_uint = 4; +pub const ConvertValidate: ::libc::c_uint = 8; +pub const FormatsDiskValidate: ::libc::c_uint = 16; +pub const FormatsMapValidate: ::libc::c_uint = 32; +pub const FormatsMemoryValidate: ::libc::c_uint = 64; +pub const IdentifyValidate: ::libc::c_uint = 128; +pub const ImportExportValidate: ::libc::c_uint = 256; +pub const MontageValidate: ::libc::c_uint = 512; +pub const StreamValidate: ::libc::c_uint = 1024; +pub const AllValidate: ::libc::c_uint = 2147483647; +pub type ValidateType = Enum_Unnamed77; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__OptionInfo { + pub mnemonic: *const ::libc::c_char, + pub _type: ssize_t, + pub flags: ssize_t, + pub stealth: MagickBooleanType, +} +impl ::std::clone::Clone for Struct__OptionInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__OptionInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type OptionInfo = Struct__OptionInfo; +pub type Enum_Unnamed78 = ::libc::c_uint; +pub const UndefinedOptionFlag: ::libc::c_uint = 0; +pub const FireOptionFlag: ::libc::c_uint = 1; +pub const ImageInfoOptionFlag: ::libc::c_uint = 2; +pub const DrawInfoOptionFlag: ::libc::c_uint = 4; +pub const QuantizeInfoOptionFlag: ::libc::c_uint = 8; +pub const GlobalOptionFlag: ::libc::c_uint = 16; +pub const SimpleOperatorOptionFlag: ::libc::c_uint = 256; +pub const ListOperatorOptionFlag: ::libc::c_uint = 512; +pub const SpecialOperatorOptionFlag: ::libc::c_uint = 1024; +pub const GenesisOptionFlag: ::libc::c_uint = 1024; +pub const NonConvertOptionFlag: ::libc::c_uint = 16384; +pub const DeprecateOptionFlag: ::libc::c_uint = 32768; +pub type CommandOptionFlags = Enum_Unnamed78; +pub type Enum_Unnamed79 = ::libc::c_uint; +pub const UndefinedPolicyDomain: ::libc::c_uint = 0; +pub const CoderPolicyDomain: ::libc::c_uint = 1; +pub const DelegatePolicyDomain: ::libc::c_uint = 2; +pub const FilterPolicyDomain: ::libc::c_uint = 3; +pub const PathPolicyDomain: ::libc::c_uint = 4; +pub const ResourcePolicyDomain: ::libc::c_uint = 5; +pub const SystemPolicyDomain: ::libc::c_uint = 6; +pub type PolicyDomain = Enum_Unnamed79; +pub type Enum_Unnamed80 = ::libc::c_uint; +pub const UndefinedPolicyRights: ::libc::c_uint = 0; +pub const NoPolicyRights: ::libc::c_uint = 0; +pub const ReadPolicyRights: ::libc::c_uint = 1; +pub const WritePolicyRights: ::libc::c_uint = 2; +pub const ExecutePolicyRights: ::libc::c_uint = 4; +pub type PolicyRights = Enum_Unnamed80; +pub enum Struct__PolicyInfo { } +pub type PolicyInfo = Struct__PolicyInfo; +pub type Enum_Unnamed81 = ::libc::c_uint; +pub const UndefinedResource: ::libc::c_uint = 0; +pub const AreaResource: ::libc::c_uint = 1; +pub const DiskResource: ::libc::c_uint = 2; +pub const FileResource: ::libc::c_uint = 3; +pub const MapResource: ::libc::c_uint = 4; +pub const MemoryResource: ::libc::c_uint = 5; +pub const ThreadResource: ::libc::c_uint = 6; +pub const TimeResource: ::libc::c_uint = 7; +pub const ThrottleResource: ::libc::c_uint = 8; +pub const WidthResource: ::libc::c_uint = 9; +pub const HeightResource: ::libc::c_uint = 10; +pub type ResourceType = Enum_Unnamed81; +pub enum Struct__SplayTreeInfo { } +pub type SplayTreeInfo = Struct__SplayTreeInfo; +pub enum Struct__TokenInfo { } +pub type TokenInfo = Struct__TokenInfo; +pub enum Struct__ThresholdMap { } +pub type ThresholdMap = Struct__ThresholdMap; +pub type Enum_Unnamed82 = ::libc::c_uint; +pub const UndefinedPath: ::libc::c_uint = 0; +pub const MagickPath: ::libc::c_uint = 1; +pub const RootPath: ::libc::c_uint = 2; +pub const HeadPath: ::libc::c_uint = 3; +pub const TailPath: ::libc::c_uint = 4; +pub const BasePath: ::libc::c_uint = 5; +pub const ExtensionPath: ::libc::c_uint = 6; +pub const SubimagePath: ::libc::c_uint = 7; +pub const CanonicalPath: ::libc::c_uint = 8; +pub type PathType = Enum_Unnamed82; +pub enum Struct__XMLTreeInfo { } +pub type XMLTreeInfo = Struct__XMLTreeInfo; +#[repr(C)] +#[derive(Copy)] +pub struct Struct__XImportInfo { + pub frame: MagickBooleanType, + pub borders: MagickBooleanType, + pub screen: MagickBooleanType, + pub descend: MagickBooleanType, + pub silent: MagickBooleanType, +} +impl ::std::clone::Clone for Struct__XImportInfo { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct__XImportInfo { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +pub type XImportInfo = Struct__XImportInfo; +pub enum Struct__PixelWand { } +pub type PixelWand = Struct__PixelWand; +pub enum Struct__DrawingWand { } +pub type DrawingWand = Struct__DrawingWand; +pub enum Struct__PixelIterator { } +pub type PixelIterator = Struct__PixelIterator; +pub type DrawContext = *mut Struct__DrawingWand; +pub enum Struct__PixelView { } +pub type PixelView = Struct__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 Struct__WandView { } +pub type WandView = Struct__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]; +pub type __va_list_tag = Struct___va_list_tag; +#[repr(C)] +#[derive(Copy)] +pub struct 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::clone::Clone for Struct___va_list_tag { + fn clone(&self) -> Self { *self } +} +impl ::std::default::Default for Struct___va_list_tag { + fn default() -> Self { unsafe { ::std::mem::zeroed() } } +} +#[link(name = "MagickWand-6.Q16")] +#[link(name = "MagickCore-6.Q16")] +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 *const ::libc::c_char; + 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 *mut ::libc::c_char; + 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.Q16")] +#[link(name = "MagickCore-6.Q16")] +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 Struct_rlimit) + -> ::libc::c_int; + pub fn getrusage(arg1: ::libc::c_int, arg2: *mut Struct_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 Struct_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 Struct_rusage) -> pid_t; + pub fn wait4(arg1: pid_t, arg2: *mut ::libc::c_int, arg3: ::libc::c_int, + arg4: *mut Struct_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) -> ::libc::c_double; + 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) + -> ::libc::c_double; + pub fn strtof(arg1: *const ::libc::c_char, arg2: *mut *mut ::libc::c_char) + -> ::libc::c_float; + 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) -> ::libc::c_double; + 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() -> ::libc::c_double; + pub fn ecvt(arg1: ::libc::c_double, 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) -> ::libc::c_double; + pub fn fcvt(arg1: ::libc::c_double, arg2: ::libc::c_int, + arg3: *mut ::libc::c_int, arg4: *mut ::libc::c_int) + -> *mut ::libc::c_char; + pub fn gcvt(arg1: ::libc::c_double, 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 atexit_b(arg1: ::libc::c_void) -> ::libc::c_int; + pub fn bsearch_b(arg1: *const ::libc::c_void, arg2: *const ::libc::c_void, + arg3: size_t, arg4: size_t, arg5: ::libc::c_void) + -> *mut ::libc::c_void; + 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 ::libc::c_double, 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 heapsort_b(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: ::libc::c_void) -> ::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 mergesort_b(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: ::libc::c_void) -> ::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_b(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: ::libc::c_void) -> (); + 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_b(arg1: *mut ::libc::c_void, arg2: size_t, arg3: size_t, + arg4: ::libc::c_void) -> (); + 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: ::libc::c_float) -> ::libc::c_int; + pub fn __fpclassifyd(arg1: ::libc::c_double) -> ::libc::c_int; + pub fn __fpclassifyl(arg1: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_isfinitef(__x: ::libc::c_float) -> ::libc::c_int; + pub fn __inline_isfinited(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_isfinitel(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_isinff(__x: ::libc::c_float) -> ::libc::c_int; + pub fn __inline_isinfd(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_isinfl(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_isnanf(__x: ::libc::c_float) -> ::libc::c_int; + pub fn __inline_isnand(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_isnanl(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_isnormalf(__x: ::libc::c_float) -> ::libc::c_int; + pub fn __inline_isnormald(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_isnormall(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_signbitf(__x: ::libc::c_float) -> ::libc::c_int; + pub fn __inline_signbitd(__x: ::libc::c_double) -> ::libc::c_int; + pub fn __inline_signbitl(__x: ::libc::c_double) -> ::libc::c_int; + pub fn acosf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn acos(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn acosl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn asinf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn asin(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn asinl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn atanf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn atan(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn atanl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn atan2f(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn atan2(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn atan2l(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn cosf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn cos(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn cosl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn sinf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn sin(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn sinl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn tanf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn tan(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn tanl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn acoshf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn acosh(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn acoshl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn asinhf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn asinh(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn asinhl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn atanhf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn atanh(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn atanhl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn coshf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn cosh(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn coshl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn sinhf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn sinh(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn sinhl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn tanhf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn tanh(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn tanhl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn expf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn exp(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn expl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn exp2f(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn exp2(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn exp2l(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn expm1f(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn expm1(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn expm1l(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn logf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn log(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn logl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn log10f(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn log10(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn log10l(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn log2f(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn log2(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn log2l(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn log1pf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn log1p(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn log1pl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn logbf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn logb(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn logbl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn modff(arg1: ::libc::c_float, arg2: *mut ::libc::c_float) + -> ::libc::c_float; + pub fn modf(arg1: ::libc::c_double, arg2: *mut ::libc::c_double) + -> ::libc::c_double; + pub fn modfl(arg1: ::libc::c_double, arg2: *mut ::libc::c_double) + -> ::libc::c_double; + pub fn ldexpf(arg1: ::libc::c_float, arg2: ::libc::c_int) + -> ::libc::c_float; + pub fn ldexp(arg1: ::libc::c_double, arg2: ::libc::c_int) + -> ::libc::c_double; + pub fn ldexpl(arg1: ::libc::c_double, arg2: ::libc::c_int) + -> ::libc::c_double; + pub fn frexpf(arg1: ::libc::c_float, arg2: *mut ::libc::c_int) + -> ::libc::c_float; + pub fn frexp(arg1: ::libc::c_double, arg2: *mut ::libc::c_int) + -> ::libc::c_double; + pub fn frexpl(arg1: ::libc::c_double, arg2: *mut ::libc::c_int) + -> ::libc::c_double; + pub fn ilogbf(arg1: ::libc::c_float) -> ::libc::c_int; + pub fn ilogb(arg1: ::libc::c_double) -> ::libc::c_int; + pub fn ilogbl(arg1: ::libc::c_double) -> ::libc::c_int; + pub fn scalbnf(arg1: ::libc::c_float, arg2: ::libc::c_int) + -> ::libc::c_float; + pub fn scalbn(arg1: ::libc::c_double, arg2: ::libc::c_int) + -> ::libc::c_double; + pub fn scalbnl(arg1: ::libc::c_double, arg2: ::libc::c_int) + -> ::libc::c_double; + pub fn scalblnf(arg1: ::libc::c_float, arg2: ::libc::c_long) + -> ::libc::c_float; + pub fn scalbln(arg1: ::libc::c_double, arg2: ::libc::c_long) + -> ::libc::c_double; + pub fn scalblnl(arg1: ::libc::c_double, arg2: ::libc::c_long) + -> ::libc::c_double; + pub fn fabsf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn fabs(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn fabsl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn cbrtf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn cbrt(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn cbrtl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn hypotf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn hypot(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn hypotl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn powf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn pow(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn powl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn sqrtf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn sqrt(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn sqrtl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn erff(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn erf(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn erfl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn erfcf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn erfc(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn erfcl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn lgammaf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn lgamma(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn lgammal(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn tgammaf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn tgamma(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn tgammal(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn ceilf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn ceil(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn ceill(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn floorf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn floor(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn floorl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn nearbyintf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn nearbyint(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn nearbyintl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn rintf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn rint(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn rintl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn lrintf(arg1: ::libc::c_float) -> ::libc::c_long; + pub fn lrint(arg1: ::libc::c_double) -> ::libc::c_long; + pub fn lrintl(arg1: ::libc::c_double) -> ::libc::c_long; + pub fn roundf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn round(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn roundl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn lroundf(arg1: ::libc::c_float) -> ::libc::c_long; + pub fn lround(arg1: ::libc::c_double) -> ::libc::c_long; + pub fn lroundl(arg1: ::libc::c_double) -> ::libc::c_long; + pub fn llrintf(arg1: ::libc::c_float) -> ::libc::c_longlong; + pub fn llrint(arg1: ::libc::c_double) -> ::libc::c_longlong; + pub fn llrintl(arg1: ::libc::c_double) -> ::libc::c_longlong; + pub fn llroundf(arg1: ::libc::c_float) -> ::libc::c_longlong; + pub fn llround(arg1: ::libc::c_double) -> ::libc::c_longlong; + pub fn llroundl(arg1: ::libc::c_double) -> ::libc::c_longlong; + pub fn truncf(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn trunc(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn truncl(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn fmodf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn fmod(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn fmodl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn remainderf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn remainder(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn remainderl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn remquof(arg1: ::libc::c_float, arg2: ::libc::c_float, + arg3: *mut ::libc::c_int) -> ::libc::c_float; + pub fn remquo(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: *mut ::libc::c_int) -> ::libc::c_double; + pub fn remquol(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: *mut ::libc::c_int) -> ::libc::c_double; + pub fn copysignf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn copysign(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn copysignl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn nanf(arg1: *const ::libc::c_char) -> ::libc::c_float; + pub fn nan(arg1: *const ::libc::c_char) -> ::libc::c_double; + pub fn nanl(arg1: *const ::libc::c_char) -> ::libc::c_double; + pub fn nextafterf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn nextafter(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn nextafterl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn nexttoward(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn nexttowardf(arg1: ::libc::c_float, arg2: ::libc::c_double) + -> ::libc::c_float; + pub fn nexttowardl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn fdimf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn fdim(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn fdiml(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn fmaxf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn fmax(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn fmaxl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn fminf(arg1: ::libc::c_float, arg2: ::libc::c_float) + -> ::libc::c_float; + pub fn fmin(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn fminl(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn fmaf(arg1: ::libc::c_float, arg2: ::libc::c_float, + arg3: ::libc::c_float) -> ::libc::c_float; + pub fn fma(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> ::libc::c_double; + pub fn fmal(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> ::libc::c_double; + pub fn __inff() -> ::libc::c_float; + pub fn __inf() -> ::libc::c_double; + pub fn __infl() -> ::libc::c_double; + pub fn __nan() -> ::libc::c_float; + pub fn __exp10f(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn __exp10(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn __sincosf(__x: ::libc::c_float, __sinp: *mut ::libc::c_float, + __cosp: *mut ::libc::c_float) -> (); + pub fn __sincos(__x: ::libc::c_double, __sinp: *mut ::libc::c_double, + __cosp: *mut ::libc::c_double) -> (); + pub fn __cospif(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn __cospi(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn __sinpif(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn __sinpi(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn __tanpif(arg1: ::libc::c_float) -> ::libc::c_float; + pub fn __tanpi(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn __sincospif(__x: ::libc::c_float, __sinp: *mut ::libc::c_float, + __cosp: *mut ::libc::c_float) -> (); + pub fn __sincospi(__x: ::libc::c_double, __sinp: *mut ::libc::c_double, + __cosp: *mut ::libc::c_double) -> (); + pub fn __sincosf_stret(arg1: ::libc::c_float) -> Struct___float2; + pub fn __sincos_stret(arg1: ::libc::c_double) -> Struct___double2; + pub fn __sincospif_stret(arg1: ::libc::c_float) -> Struct___float2; + pub fn __sincospi_stret(arg1: ::libc::c_double) -> Struct___double2; + pub fn j0(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn j1(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn jn(arg1: ::libc::c_int, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn y0(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn y1(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn yn(arg1: ::libc::c_int, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn scalb(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn rinttol(arg1: ::libc::c_double) -> ::libc::c_long; + pub fn roundtol(arg1: ::libc::c_double) -> ::libc::c_long; + pub fn drem(arg1: ::libc::c_double, arg2: ::libc::c_double) + -> ::libc::c_double; + pub fn finite(arg1: ::libc::c_double) -> ::libc::c_int; + pub fn gamma(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn significand(arg1: ::libc::c_double) -> ::libc::c_double; + pub fn matherr(arg1: *mut Struct_exception) -> ::libc::c_int; + pub fn asctime(arg1: *const Struct_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) -> ::libc::c_double; + pub fn getdate(arg1: *const ::libc::c_char) -> *mut Struct_tm; + pub fn gmtime(arg1: *const time_t) -> *mut Struct_tm; + pub fn localtime(arg1: *const time_t) -> *mut Struct_tm; + pub fn mktime(arg1: *mut Struct_tm) -> time_t; + pub fn strftime(arg1: *mut ::libc::c_char, arg2: size_t, + arg3: *const ::libc::c_char, arg4: *const Struct_tm) + -> size_t; + pub fn strptime(arg1: *const ::libc::c_char, arg2: *const ::libc::c_char, + arg3: *mut Struct_tm) -> *mut ::libc::c_char; + pub fn time(arg1: *mut time_t) -> time_t; + pub fn tzset() -> (); + pub fn asctime_r(arg1: *const Struct_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 Struct_tm) + -> *mut Struct_tm; + pub fn localtime_r(arg1: *const time_t, arg2: *mut Struct_tm) + -> *mut Struct_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 Struct_tm) -> time_t; + pub fn timegm(arg1: *mut Struct_tm) -> time_t; + pub fn nanosleep(arg1: *const Struct_timespec, arg2: *mut Struct_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 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: ::libc::c_double, + arg5: ::libc::c_double, + 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: ::libc::c_double, + arg3: GeometryFlags) -> (); + pub fn ShowKernelInfo(arg1: *const KernelInfo) -> (); + pub fn UnityAddKernelInfo(arg1: *mut KernelInfo, arg2: ::libc::c_double) + -> (); + pub fn AdaptiveBlurImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn AdaptiveBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn AdaptiveSharpenImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn AdaptiveSharpenImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) + -> *mut Image; + pub fn BlurImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn BlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn ConvolveImage(arg1: *const Image, arg2: size_t, + arg3: *const ::libc::c_double, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ConvolveImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: size_t, arg4: *const ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn DespeckleImage(arg1: *const Image, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn EdgeImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn EmbossImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn GaussianBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn KuwaharaImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn KuwaharaImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn MotionBlurImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn MotionBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double, + 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: ::libc::c_double, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn RotationalBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn SelectiveBlurImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SelectiveBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn ShadeImage(arg1: *const Image, arg2: MagickBooleanType, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SharpenImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn SharpenImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SpreadImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn UnsharpMaskImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn UnsharpMaskImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double, + arg6: ::libc::c_double, + 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) + -> ::libc::c_double; + 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 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 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) + -> ::libc::c_double; + pub fn StringToArrayOfDoubles(arg1: *const ::libc::c_char, + arg2: *mut ssize_t, + arg3: *mut ExceptionInfo) + -> *mut ::libc::c_double; + pub fn CompareStringInfo(arg1: *const StringInfo, arg2: *const StringInfo) + -> ::libc::c_int; + 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 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 LocaleLower(arg1: *mut ::libc::c_char) -> (); + pub fn LocaleUpper(arg1: *mut ::libc::c_char) -> (); + 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: ::libc::c_double) + -> (); + pub fn ResamplePixelColor(arg1: *mut ResampleFilter, + arg2: ::libc::c_double, arg3: ::libc::c_double, + 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: ::libc::c_double, arg3: ::libc::c_double, + arg4: ::libc::c_double, arg5: ::libc::c_double) + -> (); + pub fn SetResampleFilter(arg1: *mut ResampleFilter, arg2: FilterTypes, + arg3: ::libc::c_double) -> (); + 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: ::libc::c_double, arg5: ::libc::c_double, + 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: FilterTypes, + arg5: ::libc::c_double, arg6: *mut ExceptionInfo) + -> *mut Image; + pub fn ResizeImage(arg1: *const Image, arg2: size_t, arg3: size_t, + arg4: FilterTypes, arg5: ::libc::c_double, + 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) -> ::libc::c_double; + pub fn GetUserTime(arg1: *mut TimerInfo) -> ::libc::c_double; + 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 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: ::libc::c_double, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn CharcoalImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, 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: ::libc::c_double, + 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: ::libc::c_double, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn SepiaToneImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ShadowImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ssize_t, arg5: ssize_t, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn SketchImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + 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: ::libc::c_double, + 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: ssize_t, arg5: ssize_t, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn WaveImage(arg1: *const Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, 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: ::libc::c_double) + -> MagickBooleanType; + pub fn SolarizeImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: ::libc::c_double, + 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 ::libc::c_double, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn PolynomialImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: size_t, arg4: *const ::libc::c_double, + 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: ::libc::c_double, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn EvaluateImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: MagickEvaluateOperator, + arg4: ::libc::c_double, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn FunctionImage(arg1: *mut Image, arg2: MagickFunction, arg3: size_t, + arg4: *const ::libc::c_double, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn FunctionImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: MagickFunction, arg4: size_t, + arg5: *const ::libc::c_double, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageChannelEntropy(arg1: *const Image, arg2: ChannelType, + arg3: *mut ::libc::c_double, + 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 ::libc::c_double, + arg4: *mut ::libc::c_double, + arg5: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetImageChannelKurtosis(arg1: *const Image, arg2: ChannelType, + arg3: *mut ::libc::c_double, + arg4: *mut ::libc::c_double, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageChannelRange(arg1: *const Image, arg2: ChannelType, + arg3: *mut ::libc::c_double, + arg4: *mut ::libc::c_double, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageEntropy(arg1: *const Image, arg2: *mut ::libc::c_double, + 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 ::libc::c_double, + arg3: *mut ::libc::c_double, arg4: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageKurtosis(arg1: *const Image, arg2: *mut ::libc::c_double, + arg3: *mut ::libc::c_double, + arg4: *mut ExceptionInfo) -> MagickBooleanType; + pub fn GetImageRange(arg1: *const Image, arg2: *mut ::libc::c_double, + arg3: *mut ::libc::c_double, + arg4: *mut ExceptionInfo) -> MagickBooleanType; + pub fn AccelerateCompositeImage(arg1: *mut Image, arg2: ChannelType, + arg3: CompositeOperator, + arg4: *const Image, arg5: ssize_t, + arg6: ssize_t, arg7: ::libc::c_float, + arg8: ::libc::c_float, + 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: ::libc::c_double, + arg4: ::libc::c_double, + 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 ::libc::c_double, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateGrayscaleImage(arg1: *mut Image, + arg2: PixelIntensityMethod, + arg3: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateModulateImage(arg1: *mut Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ColorspaceType, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn AccelerateRandomImage(arg1: *mut Image, arg2: *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: ::libc::c_double, arg4: ::libc::c_double, + 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 AccelerateMotionBlurImage(arg1: *const Image, arg2: ChannelType, + arg3: *const ::libc::c_double, + arg4: size_t, arg5: *const OffsetInfo, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn AccelerateRadialBlurImage(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + 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: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double, + arg6: ::libc::c_double, + arg7: *mut ExceptionInfo) -> *mut Image; + 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 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 SetImageGray(arg1: *mut Image, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn SetImageMonochrome(arg1: *mut 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 ::libc::c_double; + pub fn CompareImageChannels(arg1: *mut Image, arg2: *const Image, + arg3: ChannelType, arg4: MetricType, + arg5: *mut ::libc::c_double, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn CompareImages(arg1: *mut Image, arg2: *const Image, + arg3: MetricType, arg4: *mut ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SimilarityImage(arg1: *mut Image, arg2: *const Image, + arg3: *mut RectangleInfo, + arg4: *mut ::libc::c_double, + arg5: *mut ExceptionInfo) -> *mut Image; + pub fn SimilarityMetricImage(arg1: *mut Image, arg2: *const Image, + arg3: MetricType, arg4: *mut RectangleInfo, + arg5: *mut ::libc::c_double, + arg6: *mut ExceptionInfo) -> *mut Image; + pub fn GetImageChannelDistortion(arg1: *mut Image, arg2: *const Image, + arg3: ChannelType, arg4: MetricType, + arg5: *mut ::libc::c_double, + arg6: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetImageDistortion(arg1: *mut Image, arg2: *const Image, + arg3: MetricType, arg4: *mut ::libc::c_double, + 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: ::libc::c_double, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn ModeImage(arg1: *const Image, arg2: ::libc::c_double, + 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: ::libc::c_double, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn RadialBlurImageChannel(arg1: *const Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn RecolorImage(arg1: *const Image, arg2: size_t, + arg3: *const ::libc::c_double, + arg4: *mut ExceptionInfo) -> *mut Image; + pub fn ReduceNoiseImage(arg1: *const Image, arg2: ::libc::c_double, + 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: ::libc::c_double, + arg5: ::libc::c_double, + 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: ::libc::c_double) -> ::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: ::libc::c_double) + -> ::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 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: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, 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 ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + 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 ::libc::c_double, + 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: ::libc::c_double, + arg3: *mut ExceptionInfo) -> *mut Image; + pub fn SparseColorImage(arg1: *const Image, arg2: ChannelType, + arg3: SparseColorMethod, arg4: size_t, + arg5: *const ::libc::c_double, + 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: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn BrightnessContrastImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> 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: ::libc::c_double, + arg4: ::libc::c_double) + -> 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: ::libc::c_double) -> 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: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double) -> MagickBooleanType; + pub fn LevelizeImage(arg1: *mut Image, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn LevelizeImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) -> 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: ::libc::c_double, + arg3: ::libc::c_double) -> 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: ::libc::c_double, + arg5: ::libc::c_double) + -> 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double, 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: ::libc::c_double, 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) -> ::libc::c_double; + pub fn GetPseudoRandomValue(arg1: *mut RandomInfo) -> ::libc::c_double; + 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) -> ::libc::c_double; + pub fn GenerateDifferentialNoise(arg1: *mut RandomInfo, arg2: Quantum, + arg3: NoiseType, arg4: MagickRealType) + -> ::libc::c_double; + pub fn GetOptimalKernelWidth(arg1: ::libc::c_double, + arg2: ::libc::c_double) -> size_t; + pub fn GetOptimalKernelWidth1D(arg1: ::libc::c_double, + arg2: ::libc::c_double) -> size_t; + pub fn GetOptimalKernelWidth2D(arg1: ::libc::c_double, + arg2: ::libc::c_double) -> size_t; + pub fn ConvertHCLToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertHCLpToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertHSBToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertHSIToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertHSLToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertHSVToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertHWBToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertLCHabToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertLCHuvToRGB(arg1: ::libc::c_double, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut Quantum, + arg5: *mut Quantum, arg6: *mut Quantum) -> (); + pub fn ConvertRGBToHCL(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + pub fn ConvertRGBToHCLp(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + pub fn ConvertRGBToHSB(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + pub fn ConvertRGBToHSI(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + pub fn ConvertRGBToHSL(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + pub fn ConvertRGBToHSV(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + pub fn ConvertRGBToHWB(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + pub fn ConvertRGBToLCHab(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + pub fn ConvertRGBToLCHuv(arg1: Quantum, arg2: Quantum, arg3: Quantum, + arg4: *mut ::libc::c_double, + arg5: *mut ::libc::c_double, + arg6: *mut ::libc::c_double) -> (); + 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 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: ::libc::c_double, arg4: ::libc::c_double) + -> 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) + -> + *mut ::std::option::Option *mut Image>; + pub fn GetImageEncoder(arg1: *const MagickInfo) + -> + *mut ::std::option::Option MagickBooleanType>; + 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 ::libc::c_double; + pub fn RelinquishMagickMatrix(arg1: *mut *mut ::libc::c_double, + arg2: size_t) -> *mut *mut ::libc::c_double; + pub fn MatrixToImage(arg1: *const MatrixInfo, arg2: *mut ExceptionInfo) + -> *mut Image; + pub fn GaussJordanElimination(arg1: *mut *mut ::libc::c_double, + arg2: *mut *mut ::libc::c_double, + 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 ::libc::c_double, + arg2: *mut *mut ::libc::c_double, + arg3: *const ::libc::c_double, + arg4: *const ::libc::c_double, 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 AcquireMagickOpenCLEnv() -> MagickCLEnv; + pub fn RelinquishMagickOpenCLEnv(arg1: MagickCLEnv) -> MagickBooleanType; + pub fn GetDefaultOpenCLEnv() -> MagickCLEnv; + pub fn SetDefaultOpenCLEnv(arg1: MagickCLEnv) -> MagickCLEnv; + pub fn SetMagickOpenCLEnvParam(arg1: MagickCLEnv, + arg2: MagickOpenCLEnvParam, arg3: size_t, + arg4: *mut ::libc::c_void, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn GetMagickOpenCLEnvParam(arg1: MagickCLEnv, + arg2: MagickOpenCLEnvParam, arg3: size_t, + arg4: *mut ::libc::c_void, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn InitOpenCLEnv(arg1: MagickCLEnv, arg2: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn InitImageMagickOpenCL(arg1: ImageMagickOpenCLMode, + arg2: *mut ::libc::c_void, + arg3: *mut ::libc::c_void, + arg4: *mut ExceptionInfo) + -> MagickBooleanType; + 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: ::libc::c_double, + 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) -> ::libc::c_double; + 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: ::libc::c_double, + arg3: ::libc::c_double, + arg4: *mut MagickPixelPacket, + arg5: *mut ExceptionInfo) + -> MagickBooleanType; + pub fn SegmentImage(arg1: *mut Image, arg2: ColorspaceType, + arg3: MagickBooleanType, arg4: ::libc::c_double, + arg5: ::libc::c_double) -> MagickBooleanType; + pub fn DeskewImage(arg1: *const Image, arg2: ::libc::c_double, + 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: *mut ExceptionInfo) + -> *mut Image; + pub fn ShearRotateImage(arg1: *const Image, arg2: ::libc::c_double, + 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 GetMagickToken(arg1: *const ::libc::c_char, + arg2: *mut *const ::libc::c_char, + arg3: *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: ::libc::c_double) + -> MagickBooleanType; + pub fn BilevelImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: ::libc::c_double) -> 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: ::libc::c_double) + -> MagickBooleanType; + pub fn PerceptibleImageChannel(arg1: *mut Image, arg2: ChannelType, + arg3: ::libc::c_double) + -> 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) -> ::libc::c_double; + pub fn PixelGetBlack(arg1: *const PixelWand) -> ::libc::c_double; + pub fn PixelGetBlue(arg1: *const PixelWand) -> ::libc::c_double; + pub fn PixelGetCyan(arg1: *const PixelWand) -> ::libc::c_double; + pub fn PixelGetFuzz(arg1: *const PixelWand) -> ::libc::c_double; + pub fn PixelGetGreen(arg1: *const PixelWand) -> ::libc::c_double; + pub fn PixelGetMagenta(arg1: *const PixelWand) -> ::libc::c_double; + pub fn PixelGetOpacity(arg1: *const PixelWand) -> ::libc::c_double; + pub fn PixelGetRed(arg1: *const PixelWand) -> ::libc::c_double; + pub fn PixelGetYellow(arg1: *const PixelWand) -> ::libc::c_double; + 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: ::libc::c_double) -> 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 ::libc::c_double, + arg3: *mut ::libc::c_double, + arg4: *mut ::libc::c_double) -> (); + 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: ::libc::c_double) -> (); + pub fn PixelSetAlphaQuantum(arg1: *mut PixelWand, arg2: Quantum) -> (); + pub fn PixelSetBlack(arg1: *mut PixelWand, arg2: ::libc::c_double) -> (); + pub fn PixelSetBlackQuantum(arg1: *mut PixelWand, arg2: Quantum) -> (); + pub fn PixelSetBlue(arg1: *mut PixelWand, arg2: ::libc::c_double) -> (); + 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: ::libc::c_double) -> (); + pub fn PixelSetCyanQuantum(arg1: *mut PixelWand, arg2: Quantum) -> (); + pub fn PixelSetFuzz(arg1: *mut PixelWand, arg2: ::libc::c_double) -> (); + pub fn PixelSetGreen(arg1: *mut PixelWand, arg2: ::libc::c_double) -> (); + pub fn PixelSetGreenQuantum(arg1: *mut PixelWand, arg2: Quantum) -> (); + pub fn PixelSetHSL(arg1: *mut PixelWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double) -> (); + pub fn PixelSetIndex(arg1: *mut PixelWand, arg2: IndexPacket) -> (); + pub fn PixelSetMagenta(arg1: *mut PixelWand, arg2: ::libc::c_double) + -> (); + pub fn PixelSetMagentaQuantum(arg1: *mut PixelWand, arg2: Quantum) -> (); + pub fn PixelSetMagickColor(arg1: *mut PixelWand, + arg2: *const MagickPixelPacket) -> (); + pub fn PixelSetOpacity(arg1: *mut PixelWand, arg2: ::libc::c_double) + -> (); + pub fn PixelSetOpacityQuantum(arg1: *mut PixelWand, arg2: Quantum) -> (); + pub fn PixelSetQuantumColor(arg1: *mut PixelWand, + arg2: *const PixelPacket) -> (); + pub fn PixelSetRed(arg1: *mut PixelWand, arg2: ::libc::c_double) -> (); + pub fn PixelSetRedQuantum(arg1: *mut PixelWand, arg2: Quantum) -> (); + pub fn PixelSetYellow(arg1: *mut PixelWand, arg2: ::libc::c_double) -> (); + 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 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) -> ::libc::c_double; + pub fn DrawGetFontSize(arg1: *const DrawingWand) -> ::libc::c_double; + pub fn DrawGetOpacity(arg1: *const DrawingWand) -> ::libc::c_double; + pub fn DrawGetStrokeDashArray(arg1: *const DrawingWand, arg2: *mut size_t) + -> *mut ::libc::c_double; + pub fn DrawGetStrokeDashOffset(arg1: *const DrawingWand) + -> ::libc::c_double; + pub fn DrawGetStrokeOpacity(arg1: *const DrawingWand) -> ::libc::c_double; + pub fn DrawGetStrokeWidth(arg1: *const DrawingWand) -> ::libc::c_double; + pub fn DrawGetTextKerning(arg1: *mut DrawingWand) -> ::libc::c_double; + pub fn DrawGetTextInterlineSpacing(arg1: *mut DrawingWand) + -> ::libc::c_double; + pub fn DrawGetTextInterwordSpacing(arg1: *mut DrawingWand) + -> ::libc::c_double; + pub fn PeekDrawingWand(arg1: *const DrawingWand) -> *mut DrawInfo; + pub fn CloneDrawingWand(arg1: *const DrawingWand) -> *mut DrawingWand; + pub fn DestroyDrawingWand(arg1: *mut DrawingWand) -> *mut DrawingWand; + pub fn DrawAllocateWand(arg1: *const DrawInfo, arg2: *mut Image) + -> *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: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double, arg6: ::libc::c_double, + arg7: *mut MagickWand) -> MagickBooleanType; + pub fn DrawGetFontResolution(arg1: *const DrawingWand, + arg2: *mut ::libc::c_double, + arg3: *mut ::libc::c_double) + -> 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: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double, arg6: ::libc::c_double) + -> MagickBooleanType; + pub fn DrawRender(arg1: *mut DrawingWand) -> MagickBooleanType; + pub fn DrawSetClipPath(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: ::libc::c_double, + arg3: ::libc::c_double) -> MagickBooleanType; + pub fn DrawSetStrokeDashArray(arg1: *mut DrawingWand, arg2: size_t, + arg3: *const ::libc::c_double) + -> 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: ::libc::c_double, + arg3: ::libc::c_double, + arg4: *const ::libc::c_uchar) -> (); + pub fn DrawArc(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double, arg6: ::libc::c_double, + arg7: ::libc::c_double) -> (); + 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double) -> (); + pub fn DrawColor(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: PaintMethod) -> (); + pub fn DrawComment(arg1: *mut DrawingWand, arg2: *const ::libc::c_char) + -> (); + pub fn DrawEllipse(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double, arg6: ::libc::c_double, + arg7: ::libc::c_double) -> (); + 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: ::libc::c_double) + -> (); + pub fn DrawSetTextInterlineSpacing(arg1: *mut DrawingWand, + arg2: ::libc::c_double) -> (); + pub fn DrawSetTextInterwordSpacing(arg1: *mut DrawingWand, + arg2: ::libc::c_double) -> (); + pub fn DrawGetTextUnderColor(arg1: *const DrawingWand, + arg2: *mut PixelWand) -> (); + pub fn DrawLine(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double) -> (); + pub fn DrawMatte(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: PaintMethod) -> (); + pub fn DrawPathClose(arg1: *mut DrawingWand) -> (); + pub fn DrawPathCurveToAbsolute(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double, + arg6: ::libc::c_double, + arg7: ::libc::c_double) -> (); + pub fn DrawPathCurveToRelative(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double, + arg6: ::libc::c_double, + arg7: ::libc::c_double) -> (); + pub fn DrawPathCurveToQuadraticBezierAbsolute(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) + -> (); + pub fn DrawPathCurveToQuadraticBezierRelative(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) + -> (); + pub fn DrawPathCurveToQuadraticBezierSmoothAbsolute(arg1: + *mut DrawingWand, + arg2: + ::libc::c_double, + arg3: + ::libc::c_double) + -> (); + pub fn DrawPathCurveToQuadraticBezierSmoothRelative(arg1: + *mut DrawingWand, + arg2: + ::libc::c_double, + arg3: + ::libc::c_double) + -> (); + pub fn DrawPathCurveToSmoothAbsolute(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) -> (); + pub fn DrawPathCurveToSmoothRelative(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) -> (); + pub fn DrawPathEllipticArcAbsolute(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: MagickBooleanType, + arg6: MagickBooleanType, + arg7: ::libc::c_double, + arg8: ::libc::c_double) -> (); + pub fn DrawPathEllipticArcRelative(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: MagickBooleanType, + arg6: MagickBooleanType, + arg7: ::libc::c_double, + arg8: ::libc::c_double) -> (); + pub fn DrawPathFinish(arg1: *mut DrawingWand) -> (); + pub fn DrawPathLineToAbsolute(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) -> (); + pub fn DrawPathLineToRelative(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) -> (); + pub fn DrawPathLineToHorizontalAbsolute(arg1: *mut DrawingWand, + arg2: ::libc::c_double) -> (); + pub fn DrawPathLineToHorizontalRelative(arg1: *mut DrawingWand, + arg2: ::libc::c_double) -> (); + pub fn DrawPathLineToVerticalAbsolute(arg1: *mut DrawingWand, + arg2: ::libc::c_double) -> (); + pub fn DrawPathLineToVerticalRelative(arg1: *mut DrawingWand, + arg2: ::libc::c_double) -> (); + pub fn DrawPathMoveToAbsolute(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) -> (); + pub fn DrawPathMoveToRelative(arg1: *mut DrawingWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) -> (); + pub fn DrawPathStart(arg1: *mut DrawingWand) -> (); + pub fn DrawPoint(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> (); + 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double) -> (); + pub fn DrawResetVectorGraphics(arg1: *mut DrawingWand) -> (); + pub fn DrawRotate(arg1: *mut DrawingWand, arg2: ::libc::c_double) -> (); + pub fn DrawRoundRectangle(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double, arg6: ::libc::c_double, + arg7: ::libc::c_double) -> (); + pub fn DrawScale(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> (); + 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: ::libc::c_double) + -> (); + pub fn DrawSetFillRule(arg1: *mut DrawingWand, arg2: FillRule) -> (); + pub fn DrawSetFontSize(arg1: *mut DrawingWand, arg2: ::libc::c_double) + -> (); + 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: ::libc::c_double) + -> (); + pub fn DrawSetStrokeAntialias(arg1: *mut DrawingWand, + arg2: MagickBooleanType) -> (); + pub fn DrawSetStrokeColor(arg1: *mut DrawingWand, arg2: *const PixelWand) + -> (); + pub fn DrawSetStrokeDashOffset(arg1: *mut DrawingWand, + dashoffset: ::libc::c_double) -> (); + 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: ::libc::c_double) -> (); + pub fn DrawSetStrokeWidth(arg1: *mut DrawingWand, arg2: ::libc::c_double) + -> (); + 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: ::libc::c_double) -> (); + pub fn DrawSkewY(arg1: *mut DrawingWand, arg2: ::libc::c_double) -> (); + pub fn DrawTranslate(arg1: *mut DrawingWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> (); + 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 GetPixelViewException(arg1: *const PixelView, + arg2: *mut ExceptionType) + -> *mut ::libc::c_char; + pub fn DrawGetFillAlpha(arg1: *const DrawingWand) -> ::libc::c_double; + pub fn DrawGetStrokeAlpha(arg1: *const DrawingWand) -> ::libc::c_double; + 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: ::libc::c_double, + 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: ::libc::c_double, + arg3: ::libc::c_double, + arg4: *const PixelWand, arg5: ssize_t, + arg6: ssize_t) -> MagickBooleanType; + pub fn MagickMedianFilterImage(arg1: *mut MagickWand, + arg2: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickModeImage(arg1: *mut MagickWand, arg2: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickReduceNoiseImage(arg1: *mut MagickWand, + arg2: ::libc::c_double) + -> 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: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickPaintFloodfillImage(arg1: *mut MagickWand, arg2: ChannelType, + arg3: *const PixelWand, + arg4: ::libc::c_double, + arg5: *const PixelWand, arg6: ssize_t, + arg7: ssize_t) -> MagickBooleanType; + pub fn MagickPaintOpaqueImage(arg1: *mut MagickWand, + arg2: *const PixelWand, + arg3: *const PixelWand, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickPaintOpaqueImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *const PixelWand, + arg4: *const PixelWand, + arg5: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickPaintTransparentImage(arg1: *mut MagickWand, + arg2: *const PixelWand, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickRadialBlurImage(arg1: *mut MagickWand, + arg2: ::libc::c_double) -> MagickBooleanType; + pub fn MagickRadialBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickRecolorImage(arg1: *mut MagickWand, arg2: size_t, + arg3: *const ::libc::c_double) + -> 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: ::libc::c_double, + arg4: ::libc::c_double) + -> 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: ::libc::c_double) + -> (); + pub fn DrawSetStrokeAlpha(arg1: *mut DrawingWand, arg2: ::libc::c_double) + -> (); + 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) -> ::libc::c_double; + pub fn MagickGetSamplingFactors(arg1: *mut MagickWand, arg2: *mut size_t) + -> *mut ::libc::c_double; + pub fn MagickQueryFontMetrics(arg1: *mut MagickWand, + arg2: *const DrawingWand, + arg3: *const ::libc::c_char) + -> *mut ::libc::c_double; + pub fn MagickQueryMultilineFontMetrics(arg1: *mut MagickWand, + arg2: *const DrawingWand, + arg3: *const ::libc::c_char) + -> *mut ::libc::c_double; + 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 ::libc::c_double, + arg3: *mut ::libc::c_double) + -> 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: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSetResolution(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> MagickBooleanType; + pub fn MagickSetResourceLimit(_type: ResourceType, limit: MagickSizeType) + -> MagickBooleanType; + pub fn MagickSetSamplingFactors(arg1: *mut MagickWand, arg2: size_t, + arg3: *const ::libc::c_double) + -> 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 ::libc::c_double; + pub fn MagickGetImageFuzz(arg1: *mut MagickWand) -> ::libc::c_double; + pub fn MagickGetImageGamma(arg1: *mut MagickWand) -> ::libc::c_double; + pub fn MagickGetImageTotalInkDensity(arg1: *mut MagickWand) + -> ::libc::c_double; + 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: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickAdaptiveBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickAdaptiveResizeImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t) -> MagickBooleanType; + pub fn MagickAdaptiveSharpenImage(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickAdaptiveSharpenImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> 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: ::libc::c_double, arg4: ::libc::c_double, + arg5: ::libc::c_double, + 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: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickBlurImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> MagickBooleanType; + pub fn MagickBlurImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickBorderImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: size_t, arg4: size_t) -> MagickBooleanType; + pub fn MagickBrightnessContrastImage(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickBrightnessContrastImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickCharcoalImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> 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 MagickCompositeLayers(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 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: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickContrastStretchImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickConvolveImage(arg1: *mut MagickWand, arg2: size_t, + arg3: *const ::libc::c_double) + -> MagickBooleanType; + pub fn MagickConvolveImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: size_t, + arg4: *const ::libc::c_double) + -> 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: ::libc::c_double) + -> 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 ::libc::c_double, + arg5: MagickBooleanType) -> MagickBooleanType; + pub fn MagickDrawImage(arg1: *mut MagickWand, arg2: *const DrawingWand) + -> MagickBooleanType; + pub fn MagickEdgeImage(arg1: *mut MagickWand, arg2: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickEmbossImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> 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: ::libc::c_double) -> MagickBooleanType; + pub fn MagickEvaluateImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: MagickEvaluateOperator, + arg4: ::libc::c_double) + -> 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: ::libc::c_double, + 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 ::libc::c_double) + -> MagickBooleanType; + pub fn MagickFunctionImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, arg3: MagickFunction, + arg4: size_t, + arg5: *const ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGammaImage(arg1: *mut MagickWand, arg2: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGammaImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGaussianBlurImage(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGaussianBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> 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 ::libc::c_double, + arg3: *mut ::libc::c_double) + -> 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 ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGetImageChannelKurtosis(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *mut ::libc::c_double, + arg4: *mut ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGetImageChannelMean(arg1: *mut MagickWand, arg2: ChannelType, + arg3: *mut ::libc::c_double, + arg4: *mut ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGetImageChannelRange(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *mut ::libc::c_double, + arg4: *mut ::libc::c_double) + -> 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 ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGetImageGreenPrimary(arg1: *mut MagickWand, + arg2: *mut ::libc::c_double, + arg3: *mut ::libc::c_double) + -> 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 ::libc::c_double, + arg3: *mut ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGetImageRedPrimary(arg1: *mut MagickWand, + arg2: *mut ::libc::c_double, + arg3: *mut ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGetImageResolution(arg1: *mut MagickWand, + arg2: *mut ::libc::c_double, + arg3: *mut ::libc::c_double) + -> MagickBooleanType; + pub fn MagickGetImageWhitePoint(arg1: *mut MagickWand, + arg2: *mut ::libc::c_double, + arg3: *mut ::libc::c_double) + -> 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: ::libc::c_double) + -> 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickLevelImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickLinearStretchImage(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickLiquidRescaleImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t, arg4: ::libc::c_double, + arg5: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickMagnifyImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickMinifyImage(arg1: *mut MagickWand) -> MagickBooleanType; + pub fn MagickModulateImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double) + -> 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: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double) -> MagickBooleanType; + pub fn MagickMotionBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) + -> 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: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickOpaquePaintImage(arg1: *mut MagickWand, + arg2: *const PixelWand, + arg3: *const PixelWand, + arg4: ::libc::c_double, + arg5: MagickBooleanType) + -> MagickBooleanType; + pub fn MagickOpaquePaintImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: *const PixelWand, + arg4: *const PixelWand, + arg5: ::libc::c_double, + 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: ::libc::c_double, + arg4: ::libc::c_double, + 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: ::libc::c_double) -> 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: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickRandomThresholdImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> 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: ::libc::c_double, + arg3: ::libc::c_double, arg4: FilterTypes, + arg5: ::libc::c_double) -> 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: ::libc::c_double) -> MagickBooleanType; + pub fn MagickRollImage(arg1: *mut MagickWand, arg2: ssize_t, + arg3: ssize_t) -> MagickBooleanType; + pub fn MagickRotateImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: ::libc::c_double) -> MagickBooleanType; + pub fn MagickRotationalBlurImage(arg1: *mut MagickWand, + arg2: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickRotationalBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double) + -> 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: ::libc::c_double, + arg5: ::libc::c_double) -> MagickBooleanType; + pub fn MagickSelectiveBlurImage(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSelectiveBlurImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSeparateImageChannel(arg1: *mut MagickWand, + arg2: ChannelType) -> MagickBooleanType; + pub fn MagickSepiaToneImage(arg1: *mut MagickWand, arg2: ::libc::c_double) + -> 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: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSetImageBluePrimary(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) + -> 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: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSetImageGamma(arg1: *mut MagickWand, arg2: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSetImageGravity(arg1: *mut MagickWand, arg2: GravityType) + -> MagickBooleanType; + pub fn MagickSetImageGreenPrimary(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) + -> 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: ::libc::c_double) -> 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: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSetImageRenderingIntent(arg1: *mut MagickWand, + arg2: RenderingIntent) + -> MagickBooleanType; + pub fn MagickSetImageResolution(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double) + -> 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: ::libc::c_double, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickShadeImage(arg1: *mut MagickWand, arg2: MagickBooleanType, + arg3: ::libc::c_double, arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickShadowImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ssize_t, + arg5: ssize_t) -> MagickBooleanType; + pub fn MagickSharpenImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> MagickBooleanType; + pub fn MagickSharpenImageChannel(arg1: *mut MagickWand, arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickShaveImage(arg1: *mut MagickWand, arg2: size_t, arg3: size_t) + -> MagickBooleanType; + pub fn MagickShearImage(arg1: *mut MagickWand, arg2: *const PixelWand, + arg3: ::libc::c_double, arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSigmoidalContrastImage(arg1: *mut MagickWand, + arg2: MagickBooleanType, + arg3: ::libc::c_double, + arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSigmoidalContrastImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: MagickBooleanType, + arg4: ::libc::c_double, + arg5: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSketchImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSolarizeImage(arg1: *mut MagickWand, arg2: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSolarizeImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickSparseColorImage(arg1: *mut MagickWand, arg2: ChannelType, + arg3: SparseColorMethod, arg4: size_t, + arg5: *const ::libc::c_double) + -> 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: ::libc::c_double) + -> 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: ::libc::c_double) + -> 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: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickThresholdImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickThumbnailImage(arg1: *mut MagickWand, arg2: size_t, + arg3: size_t) -> MagickBooleanType; + pub fn MagickTrimImage(arg1: *mut MagickWand, arg2: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickUniqueImageColors(arg1: *mut MagickWand) + -> MagickBooleanType; + pub fn MagickUnsharpMaskImage(arg1: *mut MagickWand, + arg2: ::libc::c_double, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickUnsharpMaskImageChannel(arg1: *mut MagickWand, + arg2: ChannelType, + arg3: ::libc::c_double, + arg4: ::libc::c_double, + arg5: ::libc::c_double, + arg6: ::libc::c_double) + -> MagickBooleanType; + pub fn MagickVignetteImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double, arg4: ssize_t, + arg5: ssize_t) -> MagickBooleanType; + pub fn MagickWaveImage(arg1: *mut MagickWand, arg2: ::libc::c_double, + arg3: ::libc::c_double) -> 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 ::libc::c_double) + -> *mut MagickWand; + pub fn MagickCompareImages(arg1: *mut MagickWand, arg2: *const MagickWand, + arg3: MetricType, arg4: *mut ::libc::c_double) + -> *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 ::libc::c_double) + -> *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/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..0da5687 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,94 @@ +/* + * Copyright 2015 Nathan Fiedler + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +//! +//! "Safe" wrapper around the low-level bindings to ImageMagick. +//! + +// Make the Rust bindings compile cleanly, despite being very un-Rust-like +// wrappers around C code. +#![allow(dead_code)] +#![allow(non_upper_case_globals)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] + +extern crate libc; + +mod bindings; + +/// MagickWand is a Rustic wrapper to the Rust bindings to ImageMagick. +pub struct MagickWand { + wand: *mut bindings::MagickWand +} + +impl MagickWand { + + /// Create a new MagickWand instance. This instance will be properly + /// cleaned up once it falls out of scope. + pub fn new() -> MagickWand { + MagickWand { + wand: unsafe { bindings::NewMagickWand() } + } + } + +// wand-of-rust wrapper around MagickResizeImage +// pub fn resize_image(&self, width: uint, height: uint, +// filter: FilterType, blur_factor: f64) { +// unsafe { +// bindings::MagickResizeImage( +// self.wand, width as size_t, height as size_t, +// filter as c_uint, blur_factor as c_double +// ); +// } +// } +} + +// Automate safe cleanup for MagickWand instances. +impl Drop for MagickWand { + + /// Clear any exceptions and destroy the magic wand. + fn drop(&mut self) { + unsafe { + bindings::MagickClearException(self.wand); + bindings::DestroyMagickWand(self.wand); + } + } +} + +/// This function must be called before any other ImageMagick operations +/// are attempted. +pub fn magick_wand_genesis() { + unsafe { + bindings::MagickWandGenesis(); + } +} + +/// This function should be called when ImageMagick is no longer needed. +pub fn magick_wand_terminus() { + unsafe { + bindings::MagickWandTerminus(); + } +} + +#[cfg(test)] +mod test { + + use super::{MagickWand}; + + #[test] + fn test_new_drop() { + MagickWand::new(); + } +}