libflycapture2_sys/

lib.rs

/* automatically generated by rust-bindgen */

#![allow(dead_code,
         non_camel_case_types,
         non_upper_case_globals,
         non_snake_case)]
pub type size_t = usize;
pub type wchar_t = ::std::os::raw::c_int;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum idtype_t { P_ALL = 0, P_PID = 1, P_PGID = 2, }
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_char;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct __fsid_t {
    pub __val: [::std::os::raw::c_int; 2usize],
}
impl ::std::default::Default for __fsid_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __qaddr_t = *mut __quad_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct wait {
    pub _bindgen_data_: [u32; 1usize],
}
impl wait {
    pub unsafe fn w_status(&mut self) -> *mut ::std::os::raw::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __wait_terminated(&mut self) -> *mut Struct_Unnamed1 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __wait_stopped(&mut self) -> *mut Struct_Unnamed2 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for wait {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed1 {
    pub _bindgen_bitfield_1_: ::std::os::raw::c_uint,
}
impl ::std::default::Default for Struct_Unnamed1 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed2 {
    pub _bindgen_bitfield_1_: ::std::os::raw::c_uint,
}
impl ::std::default::Default for Struct_Unnamed2 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct __WAIT_STATUS {
    pub _bindgen_data_: [u64; 1usize],
}
impl __WAIT_STATUS {
    pub unsafe fn __uptr(&mut self) -> *mut *mut wait {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __iptr(&mut self) -> *mut *mut ::std::os::raw::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for __WAIT_STATUS {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct div_t {
    pub quot: ::std::os::raw::c_int,
    pub rem: ::std::os::raw::c_int,
}
impl ::std::default::Default for div_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct ldiv_t {
    pub quot: ::std::os::raw::c_long,
    pub rem: ::std::os::raw::c_long,
}
impl ::std::default::Default for ldiv_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct lldiv_t {
    pub quot: ::std::os::raw::c_longlong,
    pub rem: ::std::os::raw::c_longlong,
}
impl ::std::default::Default for lldiv_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type u_long = __u_long;
pub type quad_t = __quad_t;
pub type u_quad_t = __u_quad_t;
pub type fsid_t = __fsid_t;
pub type loff_t = __loff_t;
pub type ino_t = __ino_t;
pub type dev_t = __dev_t;
pub type gid_t = __gid_t;
pub type mode_t = __mode_t;
pub type nlink_t = __nlink_t;
pub type uid_t = __uid_t;
pub type off_t = __off_t;
pub type pid_t = __pid_t;
pub type id_t = __id_t;
pub type ssize_t = isize;
pub type daddr_t = __daddr_t;
pub type caddr_t = __caddr_t;
pub type key_t = __key_t;
pub type clock_t = __clock_t;
pub type time_t = __time_t;
pub type clockid_t = __clockid_t;
pub type timer_t = __timer_t;
pub type ulong = ::std::os::raw::c_ulong;
pub type ushort = ::std::os::raw::c_ushort;
pub type uint_ = ::std::os::raw::c_uint;
pub type int8_t = i8;
pub type int16_t = i16;
pub type int32_t = i32;
pub type int64_t = i64;
pub type u_int8_t = ::std::os::raw::c_uchar;
pub type u_int16_t = ::std::os::raw::c_ushort;
pub type u_int32_t = ::std::os::raw::c_uint;
pub type u_int64_t = ::std::os::raw::c_ulong;
pub type register_t = ::std::os::raw::c_long;
pub type __sig_atomic_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct __sigset_t {
    pub __val: [::std::os::raw::c_ulong; 16usize],
}
impl ::std::default::Default for __sigset_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type sigset_t = __sigset_t;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct timespec {
    pub tv_sec: __time_t,
    pub tv_nsec: __syscall_slong_t,
}
impl ::std::default::Default for timespec {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
impl ::std::default::Default for timeval {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type suseconds_t = __suseconds_t;
pub type __fd_mask = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct fd_set {
    pub __fds_bits: [__fd_mask; 16usize],
}
impl ::std::default::Default for fd_set {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fd_mask = __fd_mask;
pub type blksize_t = __blksize_t;
pub type blkcnt_t = __blkcnt_t;
pub type fsblkcnt_t = __fsblkcnt_t;
pub type fsfilcnt_t = __fsfilcnt_t;
pub type pthread_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy)]
pub struct pthread_attr_t {
    pub _bindgen_data_: [u64; 7usize],
}
impl pthread_attr_t {
    pub unsafe fn __size(&mut self)
     -> *mut [::std::os::raw::c_char; 56usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for pthread_attr_t {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for pthread_attr_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct __pthread_internal_list {
    pub __prev: *mut __pthread_internal_list,
    pub __next: *mut __pthread_internal_list,
}
impl ::std::default::Default for __pthread_internal_list {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Copy)]
pub struct pthread_mutex_t {
    pub _bindgen_data_: [u64; 5usize],
}
impl pthread_mutex_t {
    pub unsafe fn __data(&mut self) -> *mut __pthread_mutex_s {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __size(&mut self)
     -> *mut [::std::os::raw::c_char; 40usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for pthread_mutex_t {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for pthread_mutex_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct __pthread_mutex_s {
    pub __lock: ::std::os::raw::c_int,
    pub __count: ::std::os::raw::c_uint,
    pub __owner: ::std::os::raw::c_int,
    pub __nusers: ::std::os::raw::c_uint,
    pub __kind: ::std::os::raw::c_int,
    pub __spins: ::std::os::raw::c_short,
    pub __elision: ::std::os::raw::c_short,
    pub __list: __pthread_list_t,
}
impl ::std::default::Default for __pthread_mutex_s {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct pthread_mutexattr_t {
    pub _bindgen_data_: [u32; 1usize],
}
impl pthread_mutexattr_t {
    pub unsafe fn __size(&mut self) -> *mut [::std::os::raw::c_char; 4usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for pthread_mutexattr_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct pthread_cond_t {
    pub _bindgen_data_: [u64; 6usize],
}
impl pthread_cond_t {
    pub unsafe fn __data(&mut self) -> *mut Struct_Unnamed3 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __size(&mut self)
     -> *mut [::std::os::raw::c_char; 48usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_longlong {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for pthread_cond_t {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for pthread_cond_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed3 {
    pub __lock: ::std::os::raw::c_int,
    pub __futex: ::std::os::raw::c_uint,
    pub __total_seq: ::std::os::raw::c_ulonglong,
    pub __wakeup_seq: ::std::os::raw::c_ulonglong,
    pub __woken_seq: ::std::os::raw::c_ulonglong,
    pub __mutex: *mut ::std::os::raw::c_void,
    pub __nwaiters: ::std::os::raw::c_uint,
    pub __broadcast_seq: ::std::os::raw::c_uint,
}
impl ::std::default::Default for Struct_Unnamed3 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct pthread_condattr_t {
    pub _bindgen_data_: [u32; 1usize],
}
impl pthread_condattr_t {
    pub unsafe fn __size(&mut self) -> *mut [::std::os::raw::c_char; 4usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for pthread_condattr_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_key_t = ::std::os::raw::c_uint;
pub type pthread_once_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy)]
pub struct pthread_rwlock_t {
    pub _bindgen_data_: [u64; 7usize],
}
impl pthread_rwlock_t {
    pub unsafe fn __data(&mut self) -> *mut Struct_Unnamed4 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __size(&mut self)
     -> *mut [::std::os::raw::c_char; 56usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for pthread_rwlock_t {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for pthread_rwlock_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed4 {
    pub __lock: ::std::os::raw::c_int,
    pub __nr_readers: ::std::os::raw::c_uint,
    pub __readers_wakeup: ::std::os::raw::c_uint,
    pub __writer_wakeup: ::std::os::raw::c_uint,
    pub __nr_readers_queued: ::std::os::raw::c_uint,
    pub __nr_writers_queued: ::std::os::raw::c_uint,
    pub __writer: ::std::os::raw::c_int,
    pub __shared: ::std::os::raw::c_int,
    pub __rwelision: ::std::os::raw::c_char,
    pub __pad1: [::std::os::raw::c_uchar; 7usize],
    pub __pad2: ::std::os::raw::c_ulong,
    pub __flags: ::std::os::raw::c_uint,
}
impl ::std::default::Default for Struct_Unnamed4 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct pthread_rwlockattr_t {
    pub _bindgen_data_: [u64; 1usize],
}
impl pthread_rwlockattr_t {
    pub unsafe fn __size(&mut self) -> *mut [::std::os::raw::c_char; 8usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for pthread_rwlockattr_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_spinlock_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct pthread_barrier_t {
    pub _bindgen_data_: [u64; 4usize],
}
impl pthread_barrier_t {
    pub unsafe fn __size(&mut self)
     -> *mut [::std::os::raw::c_char; 32usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for pthread_barrier_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct pthread_barrierattr_t {
    pub _bindgen_data_: [u32; 1usize],
}
impl pthread_barrierattr_t {
    pub unsafe fn __size(&mut self) -> *mut [::std::os::raw::c_char; 4usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::std::os::raw::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for pthread_barrierattr_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct random_data {
    pub fptr: *mut int32_t,
    pub rptr: *mut int32_t,
    pub state: *mut int32_t,
    pub rand_type: ::std::os::raw::c_int,
    pub rand_deg: ::std::os::raw::c_int,
    pub rand_sep: ::std::os::raw::c_int,
    pub end_ptr: *mut int32_t,
}
impl ::std::default::Default for random_data {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct drand48_data {
    pub __x: [::std::os::raw::c_ushort; 3usize],
    pub __old_x: [::std::os::raw::c_ushort; 3usize],
    pub __c: ::std::os::raw::c_ushort,
    pub __init: ::std::os::raw::c_ushort,
    pub __a: ::std::os::raw::c_ulonglong,
}
impl ::std::default::Default for drand48_data {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __compar_fn_t =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *const ::std::os::raw::c_void,
                                               arg2:
                                                   *const ::std::os::raw::c_void)
                              -> ::std::os::raw::c_int>;
pub type BOOL = ::std::os::raw::c_int;
pub type fc2Context = *mut ::std::os::raw::c_void;
pub type fc2GuiContext = *mut ::std::os::raw::c_void;
pub type fc2ImageImpl = *mut ::std::os::raw::c_void;
pub type fc2AVIContext = *mut ::std::os::raw::c_void;
pub type fc2ImageStatisticsContext = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2PGRGuid {
    pub value: [::std::os::raw::c_uint; 4usize],
}
impl ::std::default::Default for _fc2PGRGuid {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2PGRGuid = _fc2PGRGuid;
#[derive(Copy, Clone)]
#[repr(i32)]
#[derive(Debug)]
pub enum _fc2Error {
    FC2_ERROR_UNDEFINED = -1,
    FC2_ERROR_OK = 0,
    FC2_ERROR_FAILED = 1,
    FC2_ERROR_NOT_IMPLEMENTED = 2,
    FC2_ERROR_FAILED_BUS_MASTER_CONNECTION = 3,
    FC2_ERROR_NOT_CONNECTED = 4,
    FC2_ERROR_INIT_FAILED = 5,
    FC2_ERROR_NOT_INTITIALIZED = 6,
    FC2_ERROR_INVALID_PARAMETER = 7,
    FC2_ERROR_INVALID_SETTINGS = 8,
    FC2_ERROR_INVALID_BUS_MANAGER = 9,
    FC2_ERROR_MEMORY_ALLOCATION_FAILED = 10,
    FC2_ERROR_LOW_LEVEL_FAILURE = 11,
    FC2_ERROR_NOT_FOUND = 12,
    FC2_ERROR_FAILED_GUID = 13,
    FC2_ERROR_INVALID_PACKET_SIZE = 14,
    FC2_ERROR_INVALID_MODE = 15,
    FC2_ERROR_NOT_IN_FORMAT7 = 16,
    FC2_ERROR_NOT_SUPPORTED = 17,
    FC2_ERROR_TIMEOUT = 18,
    FC2_ERROR_BUS_MASTER_FAILED = 19,
    FC2_ERROR_INVALID_GENERATION = 20,
    FC2_ERROR_LUT_FAILED = 21,
    FC2_ERROR_IIDC_FAILED = 22,
    FC2_ERROR_STROBE_FAILED = 23,
    FC2_ERROR_TRIGGER_FAILED = 24,
    FC2_ERROR_PROPERTY_FAILED = 25,
    FC2_ERROR_PROPERTY_NOT_PRESENT = 26,
    FC2_ERROR_REGISTER_FAILED = 27,
    FC2_ERROR_READ_REGISTER_FAILED = 28,
    FC2_ERROR_WRITE_REGISTER_FAILED = 29,
    FC2_ERROR_ISOCH_FAILED = 30,
    FC2_ERROR_ISOCH_ALREADY_STARTED = 31,
    FC2_ERROR_ISOCH_NOT_STARTED = 32,
    FC2_ERROR_ISOCH_START_FAILED = 33,
    FC2_ERROR_ISOCH_RETRIEVE_BUFFER_FAILED = 34,
    FC2_ERROR_ISOCH_STOP_FAILED = 35,
    FC2_ERROR_ISOCH_SYNC_FAILED = 36,
    FC2_ERROR_ISOCH_BANDWIDTH_EXCEEDED = 37,
    FC2_ERROR_IMAGE_CONVERSION_FAILED = 38,
    FC2_ERROR_IMAGE_LIBRARY_FAILURE = 39,
    FC2_ERROR_BUFFER_TOO_SMALL = 40,
    FC2_ERROR_IMAGE_CONSISTENCY_ERROR = 41,
    FC2_ERROR_INCOMPATIBLE_DRIVER = 42,
    FC2_ERROR_FORCE_32BITS = 2147483647,
}
pub type fc2Error = _fc2Error;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2BusCallbackType {
    FC2_BUS_RESET = 0,
    FC2_ARRIVAL = 1,
    FC2_REMOVAL = 2,
    FC2_CALLBACK_TYPE_FORCE_32BITS = 2147483647,
}
pub type fc2BusCallbackType = _fc2BusCallbackType;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2GrabMode {
    FC2_DROP_FRAMES = 0,
    FC2_BUFFER_FRAMES = 1,
    FC2_UNSPECIFIED_GRAB_MODE = 2,
    FC2_GRAB_MODE_FORCE_32BITS = 2147483647,
}
pub type fc2GrabMode = _fc2GrabMode;
#[derive(Copy, Clone)]
#[repr(i32)]
#[derive(Debug)]
pub enum _fc2GrabTimeout {
    FC2_TIMEOUT_NONE = 0,
    FC2_TIMEOUT_INFINITE = -1,
    FC2_TIMEOUT_UNSPECIFIED = -2,
    FC2_GRAB_TIMEOUT_FORCE_32BITS = 2147483647,
}
pub type fc2GrabTimeout = _fc2GrabTimeout;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2BandwidthAllocation {
    FC2_BANDWIDTH_ALLOCATION_OFF = 0,
    FC2_BANDWIDTH_ALLOCATION_ON = 1,
    FC2_BANDWIDTH_ALLOCATION_UNSUPPORTED = 2,
    FC2_BANDWIDTH_ALLOCATION_UNSPECIFIED = 3,
    FC2_BANDWIDTH_ALLOCATION_FORCE_32BITS = 2147483647,
}
pub type fc2BandwidthAllocation = _fc2BandwidthAllocation;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2InterfaceType {
    FC2_INTERFACE_IEEE1394 = 0,
    FC2_INTERFACE_USB_2 = 1,
    FC2_INTERFACE_USB_3 = 2,
    FC2_INTERFACE_GIGE = 3,
    FC2_INTERFACE_UNKNOWN = 4,
    FC2_INTERFACE_TYPE_FORCE_32BITS = 2147483647,
}
pub type fc2InterfaceType = _fc2InterfaceType;
#[derive(Copy, Clone)]
#[repr(i32)]
#[derive(Debug)]
pub enum _fc2DriverType {
    FC2_DRIVER_1394_CAM = 0,
    FC2_DRIVER_1394_PRO = 1,
    FC2_DRIVER_1394_JUJU = 2,
    FC2_DRIVER_1394_VIDEO1394 = 3,
    FC2_DRIVER_1394_RAW1394 = 4,
    FC2_DRIVER_USB_NONE = 5,
    FC2_DRIVER_USB_CAM = 6,
    FC2_DRIVER_USB3_PRO = 7,
    FC2_DRIVER_GIGE_NONE = 8,
    FC2_DRIVER_GIGE_FILTER = 9,
    FC2_DRIVER_GIGE_PRO = 10,
    FC2_DRIVER_GIGE_LWF = 11,
    FC2_DRIVER_UNKNOWN = -1,
    FC2_DRIVER_FORCE_32BITS = 2147483647,
}
pub type fc2DriverType = _fc2DriverType;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2PropertyType {
    FC2_BRIGHTNESS = 0,
    FC2_AUTO_EXPOSURE = 1,
    FC2_SHARPNESS = 2,
    FC2_WHITE_BALANCE = 3,
    FC2_HUE = 4,
    FC2_SATURATION = 5,
    FC2_GAMMA = 6,
    FC2_IRIS = 7,
    FC2_FOCUS = 8,
    FC2_ZOOM = 9,
    FC2_PAN = 10,
    FC2_TILT = 11,
    FC2_SHUTTER = 12,
    FC2_GAIN = 13,
    FC2_TRIGGER_MODE = 14,
    FC2_TRIGGER_DELAY = 15,
    FC2_FRAME_RATE = 16,
    FC2_TEMPERATURE = 17,
    FC2_UNSPECIFIED_PROPERTY_TYPE = 18,
    FC2_PROPERTY_TYPE_FORCE_32BITS = 2147483647,
}
pub type fc2PropertyType = _fc2PropertyType;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2FrameRate {
    FC2_FRAMERATE_1_875 = 0,
    FC2_FRAMERATE_3_75 = 1,
    FC2_FRAMERATE_7_5 = 2,
    FC2_FRAMERATE_15 = 3,
    FC2_FRAMERATE_30 = 4,
    FC2_FRAMERATE_60 = 5,
    FC2_FRAMERATE_120 = 6,
    FC2_FRAMERATE_240 = 7,
    FC2_FRAMERATE_FORMAT7 = 8,
    FC2_NUM_FRAMERATES = 9,
    FC2_FRAMERATE_FORCE_32BITS = 2147483647,
}
pub type fc2FrameRate = _fc2FrameRate;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2VideoMode {
    FC2_VIDEOMODE_160x120YUV444 = 0,
    FC2_VIDEOMODE_320x240YUV422 = 1,
    FC2_VIDEOMODE_640x480YUV411 = 2,
    FC2_VIDEOMODE_640x480YUV422 = 3,
    FC2_VIDEOMODE_640x480RGB = 4,
    FC2_VIDEOMODE_640x480Y8 = 5,
    FC2_VIDEOMODE_640x480Y16 = 6,
    FC2_VIDEOMODE_800x600YUV422 = 7,
    FC2_VIDEOMODE_800x600RGB = 8,
    FC2_VIDEOMODE_800x600Y8 = 9,
    FC2_VIDEOMODE_800x600Y16 = 10,
    FC2_VIDEOMODE_1024x768YUV422 = 11,
    FC2_VIDEOMODE_1024x768RGB = 12,
    FC2_VIDEOMODE_1024x768Y8 = 13,
    FC2_VIDEOMODE_1024x768Y16 = 14,
    FC2_VIDEOMODE_1280x960YUV422 = 15,
    FC2_VIDEOMODE_1280x960RGB = 16,
    FC2_VIDEOMODE_1280x960Y8 = 17,
    FC2_VIDEOMODE_1280x960Y16 = 18,
    FC2_VIDEOMODE_1600x1200YUV422 = 19,
    FC2_VIDEOMODE_1600x1200RGB = 20,
    FC2_VIDEOMODE_1600x1200Y8 = 21,
    FC2_VIDEOMODE_1600x1200Y16 = 22,
    FC2_VIDEOMODE_FORMAT7 = 23,
    FC2_NUM_VIDEOMODES = 24,
    FC2_VIDEOMODE_FORCE_32BITS = 2147483647,
}
pub type fc2VideoMode = _fc2VideoMode;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2Mode {
    FC2_MODE_0 = 0,
    FC2_MODE_1 = 1,
    FC2_MODE_2 = 2,
    FC2_MODE_3 = 3,
    FC2_MODE_4 = 4,
    FC2_MODE_5 = 5,
    FC2_MODE_6 = 6,
    FC2_MODE_7 = 7,
    FC2_MODE_8 = 8,
    FC2_MODE_9 = 9,
    FC2_MODE_10 = 10,
    FC2_MODE_11 = 11,
    FC2_MODE_12 = 12,
    FC2_MODE_13 = 13,
    FC2_MODE_14 = 14,
    FC2_MODE_15 = 15,
    FC2_MODE_16 = 16,
    FC2_MODE_17 = 17,
    FC2_MODE_18 = 18,
    FC2_MODE_19 = 19,
    FC2_MODE_20 = 20,
    FC2_MODE_21 = 21,
    FC2_MODE_22 = 22,
    FC2_MODE_23 = 23,
    FC2_MODE_24 = 24,
    FC2_MODE_25 = 25,
    FC2_MODE_26 = 26,
    FC2_MODE_27 = 27,
    FC2_MODE_28 = 28,
    FC2_MODE_29 = 29,
    FC2_MODE_30 = 30,
    FC2_MODE_31 = 31,
    FC2_NUM_MODES = 32,
    FC2_MODE_FORCE_32BITS = 2147483647,
}
pub type fc2Mode = _fc2Mode;
pub const FC2_PIXEL_FORMAT_RGB: _fc2PixelFormat =
    _fc2PixelFormat::FC2_PIXEL_FORMAT_RGB8;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2PixelFormat {
    FC2_PIXEL_FORMAT_MONO8 = 2147483648,
    FC2_PIXEL_FORMAT_411YUV8 = 1073741824,
    FC2_PIXEL_FORMAT_422YUV8 = 536870912,
    FC2_PIXEL_FORMAT_444YUV8 = 268435456,
    FC2_PIXEL_FORMAT_RGB8 = 134217728,
    FC2_PIXEL_FORMAT_MONO16 = 67108864,
    FC2_PIXEL_FORMAT_RGB16 = 33554432,
    FC2_PIXEL_FORMAT_S_MONO16 = 16777216,
    FC2_PIXEL_FORMAT_S_RGB16 = 8388608,
    FC2_PIXEL_FORMAT_RAW8 = 4194304,
    FC2_PIXEL_FORMAT_RAW16 = 2097152,
    FC2_PIXEL_FORMAT_MONO12 = 1048576,
    FC2_PIXEL_FORMAT_RAW12 = 524288,
    FC2_PIXEL_FORMAT_BGR = 2147483656,
    FC2_PIXEL_FORMAT_BGRU = 1073741832,
    FC2_PIXEL_FORMAT_RGBU = 1073741826,
    FC2_PIXEL_FORMAT_BGR16 = 33554433,
    FC2_PIXEL_FORMAT_BGRU16 = 33554434,
    FC2_PIXEL_FORMAT_422YUV8_JPEG = 1073741825,
    FC2_NUM_PIXEL_FORMATS = 20,
    FC2_UNSPECIFIED_PIXEL_FORMAT = 0,
}
pub type fc2PixelFormat = _fc2PixelFormat;
#[derive(Copy, Clone)]
#[repr(i32)]
#[derive(Debug)]
pub enum _fc2BusSpeed {
    FC2_BUSSPEED_S100 = 0,
    FC2_BUSSPEED_S200 = 1,
    FC2_BUSSPEED_S400 = 2,
    FC2_BUSSPEED_S480 = 3,
    FC2_BUSSPEED_S800 = 4,
    FC2_BUSSPEED_S1600 = 5,
    FC2_BUSSPEED_S3200 = 6,
    FC2_BUSSPEED_S5000 = 7,
    FC2_BUSSPEED_10BASE_T = 8,
    FC2_BUSSPEED_100BASE_T = 9,
    FC2_BUSSPEED_1000BASE_T = 10,
    FC2_BUSSPEED_10000BASE_T = 11,
    FC2_BUSSPEED_S_FASTEST = 12,
    FC2_BUSSPEED_ANY = 13,
    FC2_BUSSPEED_SPEED_UNKNOWN = -1,
    FC2_BUSSPEED_FORCE_32BITS = 2147483647,
}
pub type fc2BusSpeed = _fc2BusSpeed;
#[derive(Copy, Clone)]
#[repr(i32)]
#[derive(Debug)]
pub enum _fc2PCIeBusSpeed {
    FC2_PCIE_BUSSPEED_2_5 = 0,
    FC2_PCIE_BUSSPEED_5_0 = 1,
    FC2_PCIE_BUSSPEED_UNKNOWN = -1,
    FC2_PCIE_BUSSPEED_FORCE_32BITS = 2147483647,
}
pub type fc2PCIeBusSpeed = _fc2PCIeBusSpeed;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2ColorProcessingAlgorithm {
    FC2_DEFAULT = 0,
    FC2_NO_COLOR_PROCESSING = 1,
    FC2_NEAREST_NEIGHBOR_FAST = 2,
    FC2_EDGE_SENSING = 3,
    FC2_HQ_LINEAR = 4,
    FC2_RIGOROUS = 5,
    FC2_IPP = 6,
    FC2_DIRECTIONAL = 7,
    FC2_COLOR_PROCESSING_ALGORITHM_FORCE_32BITS = 2147483647,
}
pub type fc2ColorProcessingAlgorithm = _fc2ColorProcessingAlgorithm;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2BayerTileFormat {
    FC2_BT_NONE = 0,
    FC2_BT_RGGB = 1,
    FC2_BT_GRBG = 2,
    FC2_BT_GBRG = 3,
    FC2_BT_BGGR = 4,
    FC2_BT_FORCE_32BITS = 2147483647,
}
pub type fc2BayerTileFormat = _fc2BayerTileFormat;
#[derive(Copy, Clone)]
#[repr(i32)]
#[derive(Debug)]
pub enum _fc2ImageFileFormat {
    FC2_FROM_FILE_EXT = -1,
    FC2_PGM = 0,
    FC2_PPM = 1,
    FC2_BMP = 2,
    FC2_JPEG = 3,
    FC2_JPEG2000 = 4,
    FC2_TIFF = 5,
    FC2_PNG = 6,
    FC2_RAW = 7,
    FC2_IMAGE_FILE_FORMAT_FORCE_32BITS = 2147483647,
}
pub type fc2ImageFileFormat = _fc2ImageFileFormat;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2GigEPropertyType {
    FC2_HEARTBEAT = 0,
    FC2_HEARTBEAT_TIMEOUT = 1,
}
pub type fc2GigEPropertyType = _fc2GigEPropertyType;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2StatisticsChannel {
    FC2_STATISTICS_GREY = 0,
    FC2_STATISTICS_RED = 1,
    FC2_STATISTICS_GREEN = 2,
    FC2_STATISTICS_BLUE = 3,
    FC2_STATISTICS_HUE = 4,
    FC2_STATISTICS_SATURATION = 5,
    FC2_STATISTICS_LIGHTNESS = 6,
    FC2_STATISTICS_FORCE_32BITS = 2147483647,
}
pub type fc2StatisticsChannel = _fc2StatisticsChannel;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2OSType {
    FC2_WINDOWS_X86 = 0,
    FC2_WINDOWS_X64 = 1,
    FC2_LINUX_X86 = 2,
    FC2_LINUX_X64 = 3,
    FC2_MAC = 4,
    FC2_UNKNOWN_OS = 5,
    FC2_OSTYPE_FORCE_32BITS = 2147483647,
}
pub type fc2OSType = _fc2OSType;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2ByteOrder {
    FC2_BYTE_ORDER_LITTLE_ENDIAN = 0,
    FC2_BYTE_ORDER_BIG_ENDIAN = 1,
    FC2_BYTE_ORDER_FORCE_32BITS = 2147483647,
}
pub type fc2ByteOrder = _fc2ByteOrder;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2Image {
    pub rows: ::std::os::raw::c_uint,
    pub cols: ::std::os::raw::c_uint,
    pub stride: ::std::os::raw::c_uint,
    pub pData: *mut ::std::os::raw::c_uchar,
    pub dataSize: ::std::os::raw::c_uint,
    pub receivedDataSize: ::std::os::raw::c_uint,
    pub format: fc2PixelFormat,
    pub bayerFormat: fc2BayerTileFormat,
    pub imageImpl: fc2ImageImpl,
}
impl ::std::default::Default for _fc2Image {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2Image = _fc2Image;
#[repr(C)]
#[derive(Copy)]
pub struct _fc2SystemInfo {
    pub osType: fc2OSType,
    pub osDescription: [::std::os::raw::c_char; 512usize],
    pub byteOrder: fc2ByteOrder,
    pub sysMemSize: size_t,
    pub cpuDescription: [::std::os::raw::c_char; 512usize],
    pub numCpuCores: size_t,
    pub driverList: [::std::os::raw::c_char; 512usize],
    pub libraryList: [::std::os::raw::c_char; 512usize],
    pub gpuDescription: [::std::os::raw::c_char; 512usize],
    pub screenWidth: size_t,
    pub screenHeight: size_t,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::clone::Clone for _fc2SystemInfo {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for _fc2SystemInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2SystemInfo = _fc2SystemInfo;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2Version {
    pub major: ::std::os::raw::c_uint,
    pub minor: ::std::os::raw::c_uint,
    pub type_: ::std::os::raw::c_uint,
    pub build: ::std::os::raw::c_uint,
}
impl ::std::default::Default for _fc2Version {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2Version = _fc2Version;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2Config {
    pub numBuffers: ::std::os::raw::c_uint,
    pub numImageNotifications: ::std::os::raw::c_uint,
    pub minNumImageNotifications: ::std::os::raw::c_uint,
    pub grabTimeout: ::std::os::raw::c_int,
    pub grabMode: fc2GrabMode,
    pub isochBusSpeed: fc2BusSpeed,
    pub asyncBusSpeed: fc2BusSpeed,
    pub bandwidthAllocation: fc2BandwidthAllocation,
    pub registerTimeoutRetries: ::std::os::raw::c_uint,
    pub registerTimeout: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2Config {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2Config = _fc2Config;
#[repr(C)]
#[derive(Copy)]
pub struct _fc2PropertyInfo {
    pub type_: fc2PropertyType,
    pub present: BOOL,
    pub autoSupported: BOOL,
    pub manualSupported: BOOL,
    pub onOffSupported: BOOL,
    pub onePushSupported: BOOL,
    pub absValSupported: BOOL,
    pub readOutSupported: BOOL,
    pub min: ::std::os::raw::c_uint,
    pub max: ::std::os::raw::c_uint,
    pub absMin: f32,
    pub absMax: f32,
    pub pUnits: [::std::os::raw::c_char; 512usize],
    pub pUnitAbbr: [::std::os::raw::c_char; 512usize],
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::clone::Clone for _fc2PropertyInfo {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for _fc2PropertyInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2PropertyInfo = _fc2PropertyInfo;
pub type fc2TriggerDelayInfo = _fc2PropertyInfo;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _Property {
    pub type_: fc2PropertyType,
    pub present: BOOL,
    pub absControl: BOOL,
    pub onePush: BOOL,
    pub onOff: BOOL,
    pub autoManualMode: BOOL,
    pub valueA: ::std::os::raw::c_uint,
    pub valueB: ::std::os::raw::c_uint,
    pub absValue: f32,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _Property {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2Property = _Property;
pub type fc2TriggerDelay = _Property;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2TriggerModeInfo {
    pub present: BOOL,
    pub readOutSupported: BOOL,
    pub onOffSupported: BOOL,
    pub polaritySupported: BOOL,
    pub valueReadable: BOOL,
    pub sourceMask: ::std::os::raw::c_uint,
    pub softwareTriggerSupported: BOOL,
    pub modeMask: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2TriggerModeInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2TriggerModeInfo = _fc2TriggerModeInfo;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2TriggerMode {
    pub onOff: BOOL,
    pub polarity: ::std::os::raw::c_uint,
    pub source: ::std::os::raw::c_uint,
    pub mode: ::std::os::raw::c_uint,
    pub parameter: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2TriggerMode {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2TriggerMode = _fc2TriggerMode;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2StrobeInfo {
    pub source: ::std::os::raw::c_uint,
    pub present: BOOL,
    pub readOutSupported: BOOL,
    pub onOffSupported: BOOL,
    pub polaritySupported: BOOL,
    pub minValue: f32,
    pub maxValue: f32,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2StrobeInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2StrobeInfo = _fc2StrobeInfo;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2StrobeControl {
    pub source: ::std::os::raw::c_uint,
    pub onOff: BOOL,
    pub polarity: ::std::os::raw::c_uint,
    pub delay: f32,
    pub duration: f32,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2StrobeControl {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2StrobeControl = _fc2StrobeControl;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2Format7ImageSettings {
    pub mode: fc2Mode,
    pub offsetX: ::std::os::raw::c_uint,
    pub offsetY: ::std::os::raw::c_uint,
    pub width: ::std::os::raw::c_uint,
    pub height: ::std::os::raw::c_uint,
    pub pixelFormat: fc2PixelFormat,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2Format7ImageSettings {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2Format7ImageSettings = _fc2Format7ImageSettings;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2Format7Info {
    pub mode: fc2Mode,
    pub maxWidth: ::std::os::raw::c_uint,
    pub maxHeight: ::std::os::raw::c_uint,
    pub offsetHStepSize: ::std::os::raw::c_uint,
    pub offsetVStepSize: ::std::os::raw::c_uint,
    pub imageHStepSize: ::std::os::raw::c_uint,
    pub imageVStepSize: ::std::os::raw::c_uint,
    pub pixelFormatBitField: ::std::os::raw::c_uint,
    pub vendorPixelFormatBitField: ::std::os::raw::c_uint,
    pub packetSize: ::std::os::raw::c_uint,
    pub minPacketSize: ::std::os::raw::c_uint,
    pub maxPacketSize: ::std::os::raw::c_uint,
    pub percentage: f32,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2Format7Info {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2Format7Info = _fc2Format7Info;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2Format7PacketInfo {
    pub recommendedBytesPerPacket: ::std::os::raw::c_uint,
    pub maxBytesPerPacket: ::std::os::raw::c_uint,
    pub unitBytesPerPacket: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2Format7PacketInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2Format7PacketInfo = _fc2Format7PacketInfo;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2IPAddress {
    pub octets: [::std::os::raw::c_uchar; 4usize],
}
impl ::std::default::Default for _fc2IPAddress {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2IPAddress = _fc2IPAddress;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2MACAddress {
    pub octets: [::std::os::raw::c_uchar; 6usize],
}
impl ::std::default::Default for _fc2MACAddress {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2MACAddress = _fc2MACAddress;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2GigEProperty {
    pub propType: fc2GigEPropertyType,
    pub isReadable: BOOL,
    pub isWritable: BOOL,
    pub min: ::std::os::raw::c_uint,
    pub max: ::std::os::raw::c_uint,
    pub value: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2GigEProperty {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2GigEProperty = _fc2GigEProperty;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2GigEStreamChannel {
    pub networkInterfaceIndex: ::std::os::raw::c_uint,
    pub hostPost: ::std::os::raw::c_uint,
    pub doNotFragment: BOOL,
    pub packetSize: ::std::os::raw::c_uint,
    pub interPacketDelay: ::std::os::raw::c_uint,
    pub destinationIpAddress: fc2IPAddress,
    pub sourcePort: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2GigEStreamChannel {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2GigEStreamChannel = _fc2GigEStreamChannel;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2GigEConfig {
    pub enablePacketResend: BOOL,
    pub timeoutForPacketResend: ::std::os::raw::c_uint,
    pub maxPacketsToResend: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2GigEConfig {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2GigEConfig = _fc2GigEConfig;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2GigEImageSettingsInfo {
    pub maxWidth: ::std::os::raw::c_uint,
    pub maxHeight: ::std::os::raw::c_uint,
    pub offsetHStepSize: ::std::os::raw::c_uint,
    pub offsetVStepSize: ::std::os::raw::c_uint,
    pub imageHStepSize: ::std::os::raw::c_uint,
    pub imageVStepSize: ::std::os::raw::c_uint,
    pub pixelFormatBitField: ::std::os::raw::c_uint,
    pub vendorPixelFormatBitField: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2GigEImageSettingsInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2GigEImageSettingsInfo = _fc2GigEImageSettingsInfo;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2GigEImageSettings {
    pub offsetX: ::std::os::raw::c_uint,
    pub offsetY: ::std::os::raw::c_uint,
    pub width: ::std::os::raw::c_uint,
    pub height: ::std::os::raw::c_uint,
    pub pixelFormat: fc2PixelFormat,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2GigEImageSettings {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2GigEImageSettings = _fc2GigEImageSettings;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2TimeStamp {
    pub seconds: ::std::os::raw::c_longlong,
    pub microSeconds: ::std::os::raw::c_uint,
    pub cycleSeconds: ::std::os::raw::c_uint,
    pub cycleCount: ::std::os::raw::c_uint,
    pub cycleOffset: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2TimeStamp {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2TimeStamp = _fc2TimeStamp;
#[repr(C)]
#[derive(Copy)]
pub struct _fc2ConfigROM {
    pub nodeVendorId: ::std::os::raw::c_uint,
    pub chipIdHi: ::std::os::raw::c_uint,
    pub chipIdLo: ::std::os::raw::c_uint,
    pub unitSpecId: ::std::os::raw::c_uint,
    pub unitSWVer: ::std::os::raw::c_uint,
    pub unitSubSWVer: ::std::os::raw::c_uint,
    pub vendorUniqueInfo_0: ::std::os::raw::c_uint,
    pub vendorUniqueInfo_1: ::std::os::raw::c_uint,
    pub vendorUniqueInfo_2: ::std::os::raw::c_uint,
    pub vendorUniqueInfo_3: ::std::os::raw::c_uint,
    pub pszKeyword: [::std::os::raw::c_char; 512usize],
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::clone::Clone for _fc2ConfigROM {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for _fc2ConfigROM {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2ConfigROM = _fc2ConfigROM;
#[repr(C)]
#[derive(Copy)]
pub struct _fc2CameraInfo {
    pub serialNumber: ::std::os::raw::c_uint,
    pub interfaceType: fc2InterfaceType,
    pub driverType: fc2DriverType,
    pub isColorCamera: BOOL,
    pub modelName: [::std::os::raw::c_char; 512usize],
    pub vendorName: [::std::os::raw::c_char; 512usize],
    pub sensorInfo: [::std::os::raw::c_char; 512usize],
    pub sensorResolution: [::std::os::raw::c_char; 512usize],
    pub driverName: [::std::os::raw::c_char; 512usize],
    pub firmwareVersion: [::std::os::raw::c_char; 512usize],
    pub firmwareBuildTime: [::std::os::raw::c_char; 512usize],
    pub maximumBusSpeed: fc2BusSpeed,
    pub pcieBusSpeed: fc2PCIeBusSpeed,
    pub bayerTileFormat: fc2BayerTileFormat,
    pub busNumber: ::std::os::raw::c_ushort,
    pub nodeNumber: ::std::os::raw::c_ushort,
    pub iidcVer: ::std::os::raw::c_uint,
    pub configROM: fc2ConfigROM,
    pub gigEMajorVersion: ::std::os::raw::c_uint,
    pub gigEMinorVersion: ::std::os::raw::c_uint,
    pub userDefinedName: [::std::os::raw::c_char; 512usize],
    pub xmlURL1: [::std::os::raw::c_char; 512usize],
    pub xmlURL2: [::std::os::raw::c_char; 512usize],
    pub macAddress: fc2MACAddress,
    pub ipAddress: fc2IPAddress,
    pub subnetMask: fc2IPAddress,
    pub defaultGateway: fc2IPAddress,
    pub ccpStatus: ::std::os::raw::c_uint,
    pub applicationIPAddress: ::std::os::raw::c_uint,
    pub applicationPort: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::clone::Clone for _fc2CameraInfo {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for _fc2CameraInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2CameraInfo = _fc2CameraInfo;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2EmbeddedImageInfoProperty {
    pub available: BOOL,
    pub onOff: BOOL,
}
impl ::std::default::Default for _fc2EmbeddedImageInfoProperty {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2EmbeddedImageInfoProperty = _fc2EmbeddedImageInfoProperty;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2EmbeddedImageInfo {
    pub timestamp: fc2EmbeddedImageInfoProperty,
    pub gain: fc2EmbeddedImageInfoProperty,
    pub shutter: fc2EmbeddedImageInfoProperty,
    pub brightness: fc2EmbeddedImageInfoProperty,
    pub exposure: fc2EmbeddedImageInfoProperty,
    pub whiteBalance: fc2EmbeddedImageInfoProperty,
    pub frameCounter: fc2EmbeddedImageInfoProperty,
    pub strobePattern: fc2EmbeddedImageInfoProperty,
    pub GPIOPinState: fc2EmbeddedImageInfoProperty,
    pub ROIPosition: fc2EmbeddedImageInfoProperty,
}
impl ::std::default::Default for _fc2EmbeddedImageInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2EmbeddedImageInfo = _fc2EmbeddedImageInfo;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2ImageMetadata {
    pub embeddedTimeStamp: ::std::os::raw::c_uint,
    pub embeddedGain: ::std::os::raw::c_uint,
    pub embeddedShutter: ::std::os::raw::c_uint,
    pub embeddedBrightness: ::std::os::raw::c_uint,
    pub embeddedExposure: ::std::os::raw::c_uint,
    pub embeddedWhiteBalance: ::std::os::raw::c_uint,
    pub embeddedFrameCounter: ::std::os::raw::c_uint,
    pub embeddedStrobePattern: ::std::os::raw::c_uint,
    pub embeddedGPIOPinState: ::std::os::raw::c_uint,
    pub embeddedROIPosition: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 31usize],
}
impl ::std::default::Default for _fc2ImageMetadata {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2ImageMetadata = _fc2ImageMetadata;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2LUTData {
    pub supported: BOOL,
    pub enabled: BOOL,
    pub numBanks: ::std::os::raw::c_uint,
    pub numChannels: ::std::os::raw::c_uint,
    pub inputBitDepth: ::std::os::raw::c_uint,
    pub outputBitDepth: ::std::os::raw::c_uint,
    pub numEntries: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 8usize],
}
impl ::std::default::Default for _fc2LUTData {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2LUTData = _fc2LUTData;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2PNGOption {
    pub interlaced: BOOL,
    pub compressionLevel: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2PNGOption {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2PNGOption = _fc2PNGOption;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2PPMOption {
    pub binaryFile: BOOL,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2PPMOption {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2PPMOption = _fc2PPMOption;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2PGMOption {
    pub binaryFile: BOOL,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2PGMOption {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2PGMOption = _fc2PGMOption;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum _fc2TIFFCompressionMethod {
    FC2_TIFF_NONE = 1,
    FC2_TIFF_PACKBITS = 2,
    FC2_TIFF_DEFLATE = 3,
    FC2_TIFF_ADOBE_DEFLATE = 4,
    FC2_TIFF_CCITTFAX3 = 5,
    FC2_TIFF_CCITTFAX4 = 6,
    FC2_TIFF_LZW = 7,
    FC2_TIFF_JPEG = 8,
}
pub type fc2TIFFCompressionMethod = _fc2TIFFCompressionMethod;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2TIFFOption {
    pub compression: fc2TIFFCompressionMethod,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2TIFFOption {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2TIFFOption = _fc2TIFFOption;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2JPEGOption {
    pub progressive: BOOL,
    pub quality: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2JPEGOption {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2JPEGOption = _fc2JPEGOption;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _fc2JPG2Option {
    pub quality: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 16usize],
}
impl ::std::default::Default for _fc2JPG2Option {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2JPG2Option = _fc2JPG2Option;
#[repr(C)]
#[derive(Copy)]
pub struct _fc2AVIOption {
    pub frameRate: f32,
    pub reserved: [::std::os::raw::c_uint; 256usize],
}
impl ::std::clone::Clone for _fc2AVIOption {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for _fc2AVIOption {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2AVIOption = _fc2AVIOption;
#[repr(C)]
#[derive(Copy)]
pub struct _fc2MJPGOption {
    pub frameRate: f32,
    pub quality: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 256usize],
}
impl ::std::clone::Clone for _fc2MJPGOption {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for _fc2MJPGOption {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2MJPGOption = _fc2MJPGOption;
#[repr(C)]
#[derive(Copy)]
pub struct _fc2H264Option {
    pub frameRate: f32,
    pub width: ::std::os::raw::c_uint,
    pub height: ::std::os::raw::c_uint,
    pub bitrate: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_uint; 256usize],
}
impl ::std::clone::Clone for _fc2H264Option {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for _fc2H264Option {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fc2H264Option = _fc2H264Option;
pub type fc2CallbackHandle = *mut ::std::os::raw::c_void;
pub type fc2BusEventCallback =
    ::std::option::Option<unsafe extern "C" fn(pParameter:
                                                   *mut ::std::os::raw::c_void,
                                               serialNumber:
                                                   ::std::os::raw::c_uint)>;
pub type fc2ImageEventCallback =
    ::std::option::Option<unsafe extern "C" fn(image: *mut fc2Image,
                                               pCallbackData:
                                                   *mut ::std::os::raw::c_void)>;
pub type fc2AsyncCommandCallback =
    ::std::option::Option<unsafe extern "C" fn(retError: fc2Error,
                                               pUserData:
                                                   *mut ::std::os::raw::c_void)>;
extern "C" {
    pub fn __ctype_get_mb_cur_max() -> size_t;
    pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
    pub fn atoi(__nptr: *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn atol(__nptr: *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_long;
    pub fn atoll(__nptr: *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_longlong;
    pub fn strtod(__nptr: *const ::std::os::raw::c_char,
                  __endptr: *mut *mut ::std::os::raw::c_char) -> f64;
    pub fn strtof(__nptr: *const ::std::os::raw::c_char,
                  __endptr: *mut *mut ::std::os::raw::c_char) -> f32;
    pub fn strtold(__nptr: *const ::std::os::raw::c_char,
                   __endptr: *mut *mut ::std::os::raw::c_char) -> f64;
    pub fn strtol(__nptr: *const ::std::os::raw::c_char,
                  __endptr: *mut *mut ::std::os::raw::c_char,
                  __base: ::std::os::raw::c_int) -> ::std::os::raw::c_long;
    pub fn strtoul(__nptr: *const ::std::os::raw::c_char,
                   __endptr: *mut *mut ::std::os::raw::c_char,
                   __base: ::std::os::raw::c_int) -> ::std::os::raw::c_ulong;
    pub fn strtoq(__nptr: *const ::std::os::raw::c_char,
                  __endptr: *mut *mut ::std::os::raw::c_char,
                  __base: ::std::os::raw::c_int)
     -> ::std::os::raw::c_longlong;
    pub fn strtouq(__nptr: *const ::std::os::raw::c_char,
                   __endptr: *mut *mut ::std::os::raw::c_char,
                   __base: ::std::os::raw::c_int)
     -> ::std::os::raw::c_ulonglong;
    pub fn strtoll(__nptr: *const ::std::os::raw::c_char,
                   __endptr: *mut *mut ::std::os::raw::c_char,
                   __base: ::std::os::raw::c_int)
     -> ::std::os::raw::c_longlong;
    pub fn strtoull(__nptr: *const ::std::os::raw::c_char,
                    __endptr: *mut *mut ::std::os::raw::c_char,
                    __base: ::std::os::raw::c_int)
     -> ::std::os::raw::c_ulonglong;
    pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
    pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
    pub fn select(__nfds: ::std::os::raw::c_int, __readfds: *mut fd_set,
                  __writefds: *mut fd_set, __exceptfds: *mut fd_set,
                  __timeout: *mut timeval) -> ::std::os::raw::c_int;
    pub fn pselect(__nfds: ::std::os::raw::c_int, __readfds: *mut fd_set,
                   __writefds: *mut fd_set, __exceptfds: *mut fd_set,
                   __timeout: *const timespec, __sigmask: *const __sigset_t)
     -> ::std::os::raw::c_int;
    pub fn gnu_dev_major(__dev: ::std::os::raw::c_ulonglong)
     -> ::std::os::raw::c_uint;
    pub fn gnu_dev_minor(__dev: ::std::os::raw::c_ulonglong)
     -> ::std::os::raw::c_uint;
    pub fn gnu_dev_makedev(__major: ::std::os::raw::c_uint,
                           __minor: ::std::os::raw::c_uint)
     -> ::std::os::raw::c_ulonglong;
    pub fn random() -> ::std::os::raw::c_long;
    pub fn srandom(__seed: ::std::os::raw::c_uint);
    pub fn initstate(__seed: ::std::os::raw::c_uint,
                     __statebuf: *mut ::std::os::raw::c_char,
                     __statelen: size_t) -> *mut ::std::os::raw::c_char;
    pub fn setstate(__statebuf: *mut ::std::os::raw::c_char)
     -> *mut ::std::os::raw::c_char;
    pub fn random_r(__buf: *mut random_data, __result: *mut int32_t)
     -> ::std::os::raw::c_int;
    pub fn srandom_r(__seed: ::std::os::raw::c_uint, __buf: *mut random_data)
     -> ::std::os::raw::c_int;
    pub fn initstate_r(__seed: ::std::os::raw::c_uint,
                       __statebuf: *mut ::std::os::raw::c_char,
                       __statelen: size_t, __buf: *mut random_data)
     -> ::std::os::raw::c_int;
    pub fn setstate_r(__statebuf: *mut ::std::os::raw::c_char,
                      __buf: *mut random_data) -> ::std::os::raw::c_int;
    pub fn rand() -> ::std::os::raw::c_int;
    pub fn srand(__seed: ::std::os::raw::c_uint);
    pub fn rand_r(__seed: *mut ::std::os::raw::c_uint)
     -> ::std::os::raw::c_int;
    pub fn drand48() -> f64;
    pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
    pub fn lrand48() -> ::std::os::raw::c_long;
    pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort)
     -> ::std::os::raw::c_long;
    pub fn mrand48() -> ::std::os::raw::c_long;
    pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort)
     -> ::std::os::raw::c_long;
    pub fn srand48(__seedval: ::std::os::raw::c_long);
    pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort)
     -> *mut ::std::os::raw::c_ushort;
    pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
    pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64)
     -> ::std::os::raw::c_int;
    pub fn erand48_r(__xsubi: *mut ::std::os::raw::c_ushort,
                     __buffer: *mut drand48_data, __result: *mut f64)
     -> ::std::os::raw::c_int;
    pub fn lrand48_r(__buffer: *mut drand48_data,
                     __result: *mut ::std::os::raw::c_long)
     -> ::std::os::raw::c_int;
    pub fn nrand48_r(__xsubi: *mut ::std::os::raw::c_ushort,
                     __buffer: *mut drand48_data,
                     __result: *mut ::std::os::raw::c_long)
     -> ::std::os::raw::c_int;
    pub fn mrand48_r(__buffer: *mut drand48_data,
                     __result: *mut ::std::os::raw::c_long)
     -> ::std::os::raw::c_int;
    pub fn jrand48_r(__xsubi: *mut ::std::os::raw::c_ushort,
                     __buffer: *mut drand48_data,
                     __result: *mut ::std::os::raw::c_long)
     -> ::std::os::raw::c_int;
    pub fn srand48_r(__seedval: ::std::os::raw::c_long,
                     __buffer: *mut drand48_data) -> ::std::os::raw::c_int;
    pub fn seed48_r(__seed16v: *mut ::std::os::raw::c_ushort,
                    __buffer: *mut drand48_data) -> ::std::os::raw::c_int;
    pub fn lcong48_r(__param: *mut ::std::os::raw::c_ushort,
                     __buffer: *mut drand48_data) -> ::std::os::raw::c_int;
    pub fn malloc(__size: size_t) -> *mut ::std::os::raw::c_void;
    pub fn calloc(__nmemb: size_t, __size: size_t)
     -> *mut ::std::os::raw::c_void;
    pub fn realloc(__ptr: *mut ::std::os::raw::c_void, __size: size_t)
     -> *mut ::std::os::raw::c_void;
    pub fn free(__ptr: *mut ::std::os::raw::c_void);
    pub fn cfree(__ptr: *mut ::std::os::raw::c_void);
    pub fn alloca(__size: size_t) -> *mut ::std::os::raw::c_void;
    pub fn valloc(__size: size_t) -> *mut ::std::os::raw::c_void;
    pub fn posix_memalign(__memptr: *mut *mut ::std::os::raw::c_void,
                          __alignment: size_t, __size: size_t)
     -> ::std::os::raw::c_int;
    pub fn aligned_alloc(__alignment: size_t, __size: size_t)
     -> *mut ::std::os::raw::c_void;
    pub fn abort();
    pub fn atexit(__func: ::std::option::Option<extern "C" fn()>)
     -> ::std::os::raw::c_int;
    pub fn at_quick_exit(__func: ::std::option::Option<extern "C" fn()>)
     -> ::std::os::raw::c_int;
    pub fn on_exit(__func:
                       ::std::option::Option<unsafe extern "C" fn(__status:
                                                                      ::std::os::raw::c_int,
                                                                  __arg:
                                                                      *mut ::std::os::raw::c_void)>,
                   __arg: *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn exit(__status: ::std::os::raw::c_int);
    pub fn quick_exit(__status: ::std::os::raw::c_int);
    pub fn _Exit(__status: ::std::os::raw::c_int);
    pub fn getenv(__name: *const ::std::os::raw::c_char)
     -> *mut ::std::os::raw::c_char;
    pub fn putenv(__string: *mut ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn setenv(__name: *const ::std::os::raw::c_char,
                  __value: *const ::std::os::raw::c_char,
                  __replace: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
    pub fn unsetenv(__name: *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn clearenv() -> ::std::os::raw::c_int;
    pub fn mktemp(__template: *mut ::std::os::raw::c_char)
     -> *mut ::std::os::raw::c_char;
    pub fn mkstemp(__template: *mut ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn mkstemps(__template: *mut ::std::os::raw::c_char,
                    __suffixlen: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn mkdtemp(__template: *mut ::std::os::raw::c_char)
     -> *mut ::std::os::raw::c_char;
    pub fn system(__command: *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn realpath(__name: *const ::std::os::raw::c_char,
                    __resolved: *mut ::std::os::raw::c_char)
     -> *mut ::std::os::raw::c_char;
    pub fn bsearch(__key: *const ::std::os::raw::c_void,
                   __base: *const ::std::os::raw::c_void, __nmemb: size_t,
                   __size: size_t, __compar: __compar_fn_t)
     -> *mut ::std::os::raw::c_void;
    pub fn qsort(__base: *mut ::std::os::raw::c_void, __nmemb: size_t,
                 __size: size_t, __compar: __compar_fn_t);
    pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
    pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
    pub fn llabs(__x: ::std::os::raw::c_longlong)
     -> ::std::os::raw::c_longlong;
    pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int)
     -> div_t;
    pub fn ldiv(__numer: ::std::os::raw::c_long,
                __denom: ::std::os::raw::c_long) -> ldiv_t;
    pub fn lldiv(__numer: ::std::os::raw::c_longlong,
                 __denom: ::std::os::raw::c_longlong) -> lldiv_t;
    pub fn ecvt(__value: f64, __ndigit: ::std::os::raw::c_int,
                __decpt: *mut ::std::os::raw::c_int,
                __sign: *mut ::std::os::raw::c_int)
     -> *mut ::std::os::raw::c_char;
    pub fn fcvt(__value: f64, __ndigit: ::std::os::raw::c_int,
                __decpt: *mut ::std::os::raw::c_int,
                __sign: *mut ::std::os::raw::c_int)
     -> *mut ::std::os::raw::c_char;
    pub fn gcvt(__value: f64, __ndigit: ::std::os::raw::c_int,
                __buf: *mut ::std::os::raw::c_char)
     -> *mut ::std::os::raw::c_char;
    pub fn qecvt(__value: f64, __ndigit: ::std::os::raw::c_int,
                 __decpt: *mut ::std::os::raw::c_int,
                 __sign: *mut ::std::os::raw::c_int)
     -> *mut ::std::os::raw::c_char;
    pub fn qfcvt(__value: f64, __ndigit: ::std::os::raw::c_int,
                 __decpt: *mut ::std::os::raw::c_int,
                 __sign: *mut ::std::os::raw::c_int)
     -> *mut ::std::os::raw::c_char;
    pub fn qgcvt(__value: f64, __ndigit: ::std::os::raw::c_int,
                 __buf: *mut ::std::os::raw::c_char)
     -> *mut ::std::os::raw::c_char;
    pub fn ecvt_r(__value: f64, __ndigit: ::std::os::raw::c_int,
                  __decpt: *mut ::std::os::raw::c_int,
                  __sign: *mut ::std::os::raw::c_int,
                  __buf: *mut ::std::os::raw::c_char, __len: size_t)
     -> ::std::os::raw::c_int;
    pub fn fcvt_r(__value: f64, __ndigit: ::std::os::raw::c_int,
                  __decpt: *mut ::std::os::raw::c_int,
                  __sign: *mut ::std::os::raw::c_int,
                  __buf: *mut ::std::os::raw::c_char, __len: size_t)
     -> ::std::os::raw::c_int;
    pub fn qecvt_r(__value: f64, __ndigit: ::std::os::raw::c_int,
                   __decpt: *mut ::std::os::raw::c_int,
                   __sign: *mut ::std::os::raw::c_int,
                   __buf: *mut ::std::os::raw::c_char, __len: size_t)
     -> ::std::os::raw::c_int;
    pub fn qfcvt_r(__value: f64, __ndigit: ::std::os::raw::c_int,
                   __decpt: *mut ::std::os::raw::c_int,
                   __sign: *mut ::std::os::raw::c_int,
                   __buf: *mut ::std::os::raw::c_char, __len: size_t)
     -> ::std::os::raw::c_int;
    pub fn mblen(__s: *const ::std::os::raw::c_char, __n: size_t)
     -> ::std::os::raw::c_int;
    pub fn mbtowc(__pwc: *mut wchar_t, __s: *const ::std::os::raw::c_char,
                  __n: size_t) -> ::std::os::raw::c_int;
    pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t)
     -> ::std::os::raw::c_int;
    pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const ::std::os::raw::c_char,
                    __n: size_t) -> size_t;
    pub fn wcstombs(__s: *mut ::std::os::raw::c_char, __pwcs: *const wchar_t,
                    __n: size_t) -> size_t;
    pub fn rpmatch(__response: *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn getsubopt(__optionp: *mut *mut ::std::os::raw::c_char,
                     __tokens: *const *mut ::std::os::raw::c_char,
                     __valuep: *mut *mut ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn fc2CreateContext(pContext: *mut fc2Context) -> fc2Error;
    pub fn fc2CreateGigEContext(pContext: *mut fc2Context) -> fc2Error;
    pub fn fc2DestroyContext(context: fc2Context) -> fc2Error;
    pub fn fc2FireBusReset(context: fc2Context, pGuid: *mut fc2PGRGuid)
     -> fc2Error;
    pub fn fc2GetNumOfCameras(context: fc2Context,
                              pNumCameras: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2IsCameraControlable(context: fc2Context, pGuid: *mut fc2PGRGuid,
                                  pControlable: *mut BOOL) -> fc2Error;
    pub fn fc2GetCameraFromIndex(context: fc2Context,
                                 index: ::std::os::raw::c_uint,
                                 pGuid: *mut fc2PGRGuid) -> fc2Error;
    pub fn fc2GetCameraFromIPAddress(context: fc2Context,
                                     ipAddress: fc2IPAddress,
                                     pGuid: *mut fc2PGRGuid) -> fc2Error;
    pub fn fc2GetCameraFromSerialNumber(context: fc2Context,
                                        serialNumber: ::std::os::raw::c_uint,
                                        pGuid: *mut fc2PGRGuid) -> fc2Error;
    pub fn fc2GetCameraSerialNumberFromIndex(context: fc2Context,
                                             index: ::std::os::raw::c_uint,
                                             pSerialNumber:
                                                 *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2GetInterfaceTypeFromGuid(context: fc2Context,
                                       pGuid: *mut fc2PGRGuid,
                                       pInterfaceType: *mut fc2InterfaceType)
     -> fc2Error;
    pub fn fc2GetNumOfDevices(context: fc2Context,
                              pNumDevices: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2GetDeviceFromIndex(context: fc2Context,
                                 index: ::std::os::raw::c_uint,
                                 pGuid: *mut fc2PGRGuid) -> fc2Error;
    pub fn fc2RegisterCallback(context: fc2Context,
                               enumCallback: fc2BusEventCallback,
                               callbackType: fc2BusCallbackType,
                               pParameter: *mut ::std::os::raw::c_void,
                               pCallbackHandle: *mut fc2CallbackHandle)
     -> fc2Error;
    pub fn fc2UnregisterCallback(context: fc2Context,
                                 callbackHandle: fc2CallbackHandle)
     -> fc2Error;
    pub fn fc2RescanBus(context: fc2Context) -> fc2Error;
    pub fn fc2ForceIPAddressToCamera(context: fc2Context,
                                     macAddress: fc2MACAddress,
                                     ipAddress: fc2IPAddress,
                                     subnetMask: fc2IPAddress,
                                     defaultGateway: fc2IPAddress)
     -> fc2Error;
    pub fn fc2ForceAllIPAddressesAutomatically() -> fc2Error;
    pub fn fc2ForceIPAddressAutomatically(serialNumber:
                                              ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2DiscoverGigECameras(context: fc2Context,
                                  gigECameras: *mut fc2CameraInfo,
                                  arraySize: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2WriteRegister(context: fc2Context,
                            address: ::std::os::raw::c_uint,
                            value: ::std::os::raw::c_uint) -> fc2Error;
    pub fn fc2WriteRegisterBroadcast(context: fc2Context,
                                     address: ::std::os::raw::c_uint,
                                     value: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2ReadRegister(context: fc2Context,
                           address: ::std::os::raw::c_uint,
                           pValue: *mut ::std::os::raw::c_uint) -> fc2Error;
    pub fn fc2WriteRegisterBlock(context: fc2Context,
                                 addressHigh: ::std::os::raw::c_ushort,
                                 addressLow: ::std::os::raw::c_uint,
                                 pBuffer: *const ::std::os::raw::c_uint,
                                 length: ::std::os::raw::c_uint) -> fc2Error;
    pub fn fc2ReadRegisterBlock(context: fc2Context,
                                addressHigh: ::std::os::raw::c_ushort,
                                addressLow: ::std::os::raw::c_uint,
                                pBuffer: *mut ::std::os::raw::c_uint,
                                length: ::std::os::raw::c_uint) -> fc2Error;
    pub fn fc2Connect(context: fc2Context, guid: *mut fc2PGRGuid) -> fc2Error;
    pub fn fc2Disconnect(context: fc2Context) -> fc2Error;
    pub fn fc2SetCallback(context: fc2Context,
                          pCallbackFn: fc2ImageEventCallback,
                          pCallbackData: *mut ::std::os::raw::c_void)
     -> fc2Error;
    pub fn fc2StartCapture(context: fc2Context) -> fc2Error;
    pub fn fc2StartCaptureCallback(context: fc2Context,
                                   pCallbackFn: fc2ImageEventCallback,
                                   pCallbackData: *mut ::std::os::raw::c_void)
     -> fc2Error;
    pub fn fc2StartSyncCapture(numCameras: ::std::os::raw::c_uint,
                               pContexts: *mut fc2Context) -> fc2Error;
    pub fn fc2StartSyncCaptureCallback(numCameras: ::std::os::raw::c_uint,
                                       pContexts: *mut fc2Context,
                                       pCallbackFns:
                                           *mut fc2ImageEventCallback,
                                       pCallbackDataArray:
                                           *mut *mut ::std::os::raw::c_void)
     -> fc2Error;
    pub fn fc2RetrieveBuffer(context: fc2Context, pImage: *mut fc2Image)
     -> fc2Error;
    pub fn fc2StopCapture(context: fc2Context) -> fc2Error;
    pub fn fc2SetUserBuffers(context: fc2Context,
                             ppMemBuffers: *mut ::std::os::raw::c_uchar,
                             size: ::std::os::raw::c_int,
                             nNumBuffers: ::std::os::raw::c_int) -> fc2Error;
    pub fn fc2GetConfiguration(context: fc2Context, config: *mut fc2Config)
     -> fc2Error;
    pub fn fc2SetConfiguration(context: fc2Context, config: *mut fc2Config)
     -> fc2Error;
    pub fn fc2GetCameraInfo(context: fc2Context,
                            pCameraInfo: *mut fc2CameraInfo) -> fc2Error;
    pub fn fc2GetPropertyInfo(context: fc2Context,
                              propInfo: *mut fc2PropertyInfo) -> fc2Error;
    pub fn fc2GetProperty(context: fc2Context, prop: *mut fc2Property)
     -> fc2Error;
    pub fn fc2SetProperty(context: fc2Context, prop: *mut fc2Property)
     -> fc2Error;
    pub fn fc2SetPropertyBroadcast(context: fc2Context,
                                   prop: *mut fc2Property) -> fc2Error;
    pub fn fc2GetGPIOPinDirection(context: fc2Context,
                                  pin: ::std::os::raw::c_uint,
                                  pDirection: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2SetGPIOPinDirection(context: fc2Context,
                                  pin: ::std::os::raw::c_uint,
                                  direction: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2SetGPIOPinDirectionBroadcast(context: fc2Context,
                                           pin: ::std::os::raw::c_uint,
                                           direction: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2GetTriggerModeInfo(context: fc2Context,
                                 triggerModeInfo: *mut fc2TriggerModeInfo)
     -> fc2Error;
    pub fn fc2GetTriggerMode(context: fc2Context,
                             triggerMode: *mut fc2TriggerMode) -> fc2Error;
    pub fn fc2SetTriggerMode(context: fc2Context,
                             triggerMode: *mut fc2TriggerMode) -> fc2Error;
    pub fn fc2SetTriggerModeBroadcast(context: fc2Context,
                                      triggerMode: *mut fc2TriggerMode)
     -> fc2Error;
    pub fn fc2FireSoftwareTrigger(context: fc2Context) -> fc2Error;
    pub fn fc2FireSoftwareTriggerBroadcast(context: fc2Context) -> fc2Error;
    pub fn fc2GetTriggerDelayInfo(context: fc2Context,
                                  triggerDelayInfo: *mut fc2TriggerDelayInfo)
     -> fc2Error;
    pub fn fc2GetTriggerDelay(context: fc2Context,
                              triggerDelay: *mut fc2TriggerDelay) -> fc2Error;
    pub fn fc2SetTriggerDelay(context: fc2Context,
                              triggerDelay: *mut fc2TriggerDelay) -> fc2Error;
    pub fn fc2SetTriggerDelayBroadcast(context: fc2Context,
                                       triggerDelay: *mut fc2TriggerDelay)
     -> fc2Error;
    pub fn fc2GetStrobeInfo(context: fc2Context,
                            strobeInfo: *mut fc2StrobeInfo) -> fc2Error;
    pub fn fc2GetStrobe(context: fc2Context,
                        strobeControl: *mut fc2StrobeControl) -> fc2Error;
    pub fn fc2SetStrobe(context: fc2Context,
                        strobeControl: *mut fc2StrobeControl) -> fc2Error;
    pub fn fc2SetStrobeBroadcast(context: fc2Context,
                                 strobeControl: *mut fc2StrobeControl)
     -> fc2Error;
    pub fn fc2GetVideoModeAndFrameRateInfo(context: fc2Context,
                                           videoMode: fc2VideoMode,
                                           frameRate: fc2FrameRate,
                                           pSupported: *mut BOOL) -> fc2Error;
    pub fn fc2GetVideoModeAndFrameRate(context: fc2Context,
                                       videoMode: *mut fc2VideoMode,
                                       frameRate: *mut fc2FrameRate)
     -> fc2Error;
    pub fn fc2SetVideoModeAndFrameRate(context: fc2Context,
                                       videoMode: fc2VideoMode,
                                       frameRate: fc2FrameRate) -> fc2Error;
    pub fn fc2GetFormat7Info(context: fc2Context, info: *mut fc2Format7Info,
                             pSupported: *mut BOOL) -> fc2Error;
    pub fn fc2ValidateFormat7Settings(context: fc2Context,
                                      imageSettings:
                                          *mut fc2Format7ImageSettings,
                                      settingsAreValid: *mut BOOL,
                                      packetInfo: *mut fc2Format7PacketInfo)
     -> fc2Error;
    pub fn fc2GetFormat7Configuration(context: fc2Context,
                                      imageSettings:
                                          *mut fc2Format7ImageSettings,
                                      packetSize: *mut ::std::os::raw::c_uint,
                                      percentage: *mut f32) -> fc2Error;
    pub fn fc2SetFormat7ConfigurationPacket(context: fc2Context,
                                            imageSettings:
                                                *mut fc2Format7ImageSettings,
                                            packetSize:
                                                ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2SetFormat7Configuration(context: fc2Context,
                                      imageSettings:
                                          *mut fc2Format7ImageSettings,
                                      percentSpeed: f32) -> fc2Error;
    pub fn fc2WriteGVCPRegister(context: fc2Context,
                                address: ::std::os::raw::c_uint,
                                value: ::std::os::raw::c_uint) -> fc2Error;
    pub fn fc2WriteGVCPRegisterBroadcast(context: fc2Context,
                                         address: ::std::os::raw::c_uint,
                                         value: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2ReadGVCPRegister(context: fc2Context,
                               address: ::std::os::raw::c_uint,
                               pValue: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2WriteGVCPRegisterBlock(context: fc2Context,
                                     address: ::std::os::raw::c_uint,
                                     pBuffer: *const ::std::os::raw::c_uint,
                                     length: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2ReadGVCPRegisterBlock(context: fc2Context,
                                    address: ::std::os::raw::c_uint,
                                    pBuffer: *mut ::std::os::raw::c_uint,
                                    length: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2WriteGVCPMemory(context: fc2Context,
                              address: ::std::os::raw::c_uint,
                              pBuffer: *const ::std::os::raw::c_uchar,
                              length: ::std::os::raw::c_uint) -> fc2Error;
    pub fn fc2ReadGVCPMemory(context: fc2Context,
                             address: ::std::os::raw::c_uint,
                             pBuffer: *mut ::std::os::raw::c_uchar,
                             length: ::std::os::raw::c_uint) -> fc2Error;
    pub fn fc2GetGigEProperty(context: fc2Context,
                              pGigEProp: *mut fc2GigEProperty) -> fc2Error;
    pub fn fc2SetGigEProperty(context: fc2Context,
                              pGigEProp: *const fc2GigEProperty) -> fc2Error;
    pub fn fc2QueryGigEImagingMode(context: fc2Context, mode: fc2Mode,
                                   isSupported: *mut BOOL) -> fc2Error;
    pub fn fc2GetGigEImagingMode(context: fc2Context, mode: *mut fc2Mode)
     -> fc2Error;
    pub fn fc2SetGigEImagingMode(context: fc2Context, mode: fc2Mode)
     -> fc2Error;
    pub fn fc2GetGigEImageSettingsInfo(context: fc2Context,
                                       pInfo: *mut fc2GigEImageSettingsInfo)
     -> fc2Error;
    pub fn fc2GetGigEImageSettings(context: fc2Context,
                                   pImageSettings: *mut fc2GigEImageSettings)
     -> fc2Error;
    pub fn fc2SetGigEImageSettings(context: fc2Context,
                                   pImageSettings:
                                       *const fc2GigEImageSettings)
     -> fc2Error;
    pub fn fc2GetGigEConfig(context: fc2Context, pConfig: *mut fc2GigEConfig)
     -> fc2Error;
    pub fn fc2SetGigEConfig(context: fc2Context,
                            pConfig: *const fc2GigEConfig) -> fc2Error;
    pub fn fc2GetGigEImageBinningSettings(context: fc2Context,
                                          horzBinnningValue:
                                              *mut ::std::os::raw::c_uint,
                                          vertBinnningValue:
                                              *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2SetGigEImageBinningSettings(context: fc2Context,
                                          horzBinnningValue:
                                              ::std::os::raw::c_uint,
                                          vertBinnningValue:
                                              ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2GetNumStreamChannels(context: fc2Context,
                                   numChannels: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2GetGigEStreamChannelInfo(context: fc2Context,
                                       channel: ::std::os::raw::c_uint,
                                       pChannel: *mut fc2GigEStreamChannel)
     -> fc2Error;
    pub fn fc2SetGigEStreamChannelInfo(context: fc2Context,
                                       channel: ::std::os::raw::c_uint,
                                       pChannel: *mut fc2GigEStreamChannel)
     -> fc2Error;
    pub fn fc2GetLUTInfo(context: fc2Context, pData: *mut fc2LUTData)
     -> fc2Error;
    pub fn fc2GetLUTBankInfo(context: fc2Context,
                             bank: ::std::os::raw::c_uint,
                             pReadSupported: *mut BOOL,
                             pWriteSupported: *mut BOOL) -> fc2Error;
    pub fn fc2GetActiveLUTBank(context: fc2Context,
                               pActiveBank: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2SetActiveLUTBank(context: fc2Context,
                               activeBank: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2EnableLUT(context: fc2Context, on: BOOL) -> fc2Error;
    pub fn fc2GetLUTChannel(context: fc2Context, bank: ::std::os::raw::c_uint,
                            channel: ::std::os::raw::c_uint,
                            sizeEntries: ::std::os::raw::c_uint,
                            pEntries: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2SetLUTChannel(context: fc2Context, bank: ::std::os::raw::c_uint,
                            channel: ::std::os::raw::c_uint,
                            sizeEntries: ::std::os::raw::c_uint,
                            pEntries: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2GetMemoryChannel(context: fc2Context,
                               pCurrentChannel: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2SaveToMemoryChannel(context: fc2Context,
                                  channel: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2RestoreFromMemoryChannel(context: fc2Context,
                                       channel: ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2GetMemoryChannelInfo(context: fc2Context,
                                   pNumChannels: *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2GetEmbeddedImageInfo(context: fc2Context,
                                   pInfo: *mut fc2EmbeddedImageInfo)
     -> fc2Error;
    pub fn fc2SetEmbeddedImageInfo(context: fc2Context,
                                   pInfo: *mut fc2EmbeddedImageInfo)
     -> fc2Error;
    pub fn fc2GetRegisterString(registerVal: ::std::os::raw::c_uint)
     -> *const ::std::os::raw::c_char;
    pub fn fc2CreateImage(pImage: *mut fc2Image) -> fc2Error;
    pub fn fc2DestroyImage(image: *mut fc2Image) -> fc2Error;
    pub fn fc2SetDefaultColorProcessing(defaultMethod:
                                            fc2ColorProcessingAlgorithm)
     -> fc2Error;
    pub fn fc2GetDefaultColorProcessing(pDefaultMethod:
                                            *mut fc2ColorProcessingAlgorithm)
     -> fc2Error;
    pub fn fc2SetDefaultOutputFormat(format: fc2PixelFormat) -> fc2Error;
    pub fn fc2GetDefaultOutputFormat(pFormat: *mut fc2PixelFormat)
     -> fc2Error;
    pub fn fc2DetermineBitsPerPixel(format: fc2PixelFormat,
                                    pBitsPerPixel:
                                        *mut ::std::os::raw::c_uint)
     -> fc2Error;
    pub fn fc2SaveImage(pImage: *mut fc2Image,
                        pFilename: *const ::std::os::raw::c_char,
                        format: fc2ImageFileFormat) -> fc2Error;
    pub fn fc2SaveImageWithOption(pImage: *mut fc2Image,
                                  pFilename: *const ::std::os::raw::c_char,
                                  format: fc2ImageFileFormat,
                                  pOption: *mut ::std::os::raw::c_void)
     -> fc2Error;
    pub fn fc2ConvertImage(pImageIn: *mut fc2Image, pImageOut: *mut fc2Image)
     -> fc2Error;
    pub fn fc2ConvertImageTo(format: fc2PixelFormat, pImageIn: *mut fc2Image,
                             pImageOut: *mut fc2Image) -> fc2Error;
    pub fn fc2GetImageData(pImage: *mut fc2Image,
                           ppData: *mut *mut ::std::os::raw::c_uchar)
     -> fc2Error;
    pub fn fc2SetImageData(pImage: *mut fc2Image,
                           pData: *const ::std::os::raw::c_uchar,
                           dataSize: ::std::os::raw::c_uint) -> fc2Error;
    pub fn fc2SetImageDimensions(pImage: *mut fc2Image,
                                 rows: ::std::os::raw::c_uint,
                                 cols: ::std::os::raw::c_uint,
                                 stride: ::std::os::raw::c_uint,
                                 pixelFormat: fc2PixelFormat,
                                 bayerFormat: fc2BayerTileFormat) -> fc2Error;
    pub fn fc2GetImageTimeStamp(pImage: *mut fc2Image) -> fc2TimeStamp;
    pub fn fc2CalculateImageStatistics(pImage: *mut fc2Image,
                                       pImageStatisticsContext:
                                           *mut fc2ImageStatisticsContext)
     -> fc2Error;
    pub fn fc2CreateImageStatistics(pImageStatisticsContext:
                                        *mut fc2ImageStatisticsContext)
     -> fc2Error;
    pub fn fc2DestroyImageStatistics(imageStatisticsContext:
                                         fc2ImageStatisticsContext)
     -> fc2Error;
    pub fn fc2GetChannelStatus(imageStatisticsContext:
                                   fc2ImageStatisticsContext,
                               channel: fc2StatisticsChannel,
                               pEnabled: *mut BOOL) -> fc2Error;
    pub fn fc2SetChannelStatus(imageStatisticsContext:
                                   fc2ImageStatisticsContext,
                               channel: fc2StatisticsChannel, enabled: BOOL)
     -> fc2Error;
    pub fn fc2GetImageStatistics(imageStatisticsContext:
                                     fc2ImageStatisticsContext,
                                 channel: fc2StatisticsChannel,
                                 pRangeMin: *mut ::std::os::raw::c_uint,
                                 pRangeMax: *mut ::std::os::raw::c_uint,
                                 pPixelValueMin: *mut ::std::os::raw::c_uint,
                                 pPixelValueMax: *mut ::std::os::raw::c_uint,
                                 pNumPixelValues: *mut ::std::os::raw::c_uint,
                                 pPixelValueMean: *mut f32,
                                 ppHistogram: *mut *mut ::std::os::raw::c_int)
     -> fc2Error;
    pub fn fc2CreateAVI(pAVIContext: *mut fc2AVIContext) -> fc2Error;
    pub fn fc2AVIOpen(AVIContext: fc2AVIContext,
                      pFileName: *const ::std::os::raw::c_char,
                      pOption: *mut fc2AVIOption) -> fc2Error;
    pub fn fc2MJPGOpen(AVIContext: fc2AVIContext,
                       pFileName: *const ::std::os::raw::c_char,
                       pOption: *mut fc2MJPGOption) -> fc2Error;
    pub fn fc2H264Open(AVIContext: fc2AVIContext,
                       pFileName: *const ::std::os::raw::c_char,
                       pOption: *mut fc2H264Option) -> fc2Error;
    pub fn fc2AVIAppend(AVIContext: fc2AVIContext, pImage: *mut fc2Image)
     -> fc2Error;
    pub fn fc2AVIClose(AVIContext: fc2AVIContext) -> fc2Error;
    pub fn fc2DestroyAVI(AVIContext: fc2AVIContext) -> fc2Error;
    pub fn fc2GetSystemInfo(pSystemInfo: *mut fc2SystemInfo) -> fc2Error;
    pub fn fc2GetLibraryVersion(pVersion: *mut fc2Version) -> fc2Error;
    pub fn fc2LaunchBrowser(pAddress: *const ::std::os::raw::c_char)
     -> fc2Error;
    pub fn fc2LaunchHelp(pFileName: *const ::std::os::raw::c_char)
     -> fc2Error;
    pub fn fc2LaunchCommand(pCommand: *const ::std::os::raw::c_char)
     -> fc2Error;
    pub fn fc2LaunchCommandAsync(pCommand: *const ::std::os::raw::c_char,
                                 pCallback: fc2AsyncCommandCallback,
                                 pUserData: *mut ::std::os::raw::c_void)
     -> fc2Error;
    pub fn fc2ErrorToDescription(error: fc2Error)
     -> *const ::std::os::raw::c_char;
    pub fn fc2GetCycleTime(context: fc2Context, pTimeStamp: *mut fc2TimeStamp)
     -> fc2Error;
}