pub const _STDINT_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __WORDSIZE: u32 = 32;
pub const __WORDSIZE32_SIZE_ULONG: u32 = 0;
pub const __WORDSIZE32_PTRDIFF_LONG: u32 = 0;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 0;
pub const __TIMESIZE: u32 = 32;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_60559_BFP__: u32 = 201404;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 35;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_TYPES_H: u32 = 1;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 0;
pub const __STATFS_MATCHES_STATFS64: u32 = 0;
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 0;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i32 = -2147483648;
pub const INT_FAST32_MIN: i32 = -2147483648;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u32 = 2147483647;
pub const INT_FAST32_MAX: u32 = 2147483647;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: u32 = 4294967295;
pub const UINT_FAST32_MAX: u32 = 4294967295;
pub const INTPTR_MIN: i32 = -2147483648;
pub const INTPTR_MAX: u32 = 2147483647;
pub const UINTPTR_MAX: u32 = 4294967295;
pub const PTRDIFF_MIN: i32 = -2147483648;
pub const PTRDIFF_MAX: u32 = 2147483647;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: u32 = 4294967295;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const _INTTYPES_H: u32 = 1;
pub const ____gwchar_t_defined: u32 = 1;
pub const __PRI64_PREFIX: &[u8; 3] = b"ll\0";
pub const PRId8: &[u8; 2] = b"d\0";
pub const PRId16: &[u8; 2] = b"d\0";
pub const PRId32: &[u8; 2] = b"d\0";
pub const PRId64: &[u8; 4] = b"lld\0";
pub const PRIdLEAST8: &[u8; 2] = b"d\0";
pub const PRIdLEAST16: &[u8; 2] = b"d\0";
pub const PRIdLEAST32: &[u8; 2] = b"d\0";
pub const PRIdLEAST64: &[u8; 4] = b"lld\0";
pub const PRIdFAST8: &[u8; 2] = b"d\0";
pub const PRIdFAST64: &[u8; 4] = b"lld\0";
pub const PRIi8: &[u8; 2] = b"i\0";
pub const PRIi16: &[u8; 2] = b"i\0";
pub const PRIi32: &[u8; 2] = b"i\0";
pub const PRIi64: &[u8; 4] = b"lli\0";
pub const PRIiLEAST8: &[u8; 2] = b"i\0";
pub const PRIiLEAST16: &[u8; 2] = b"i\0";
pub const PRIiLEAST32: &[u8; 2] = b"i\0";
pub const PRIiLEAST64: &[u8; 4] = b"lli\0";
pub const PRIiFAST8: &[u8; 2] = b"i\0";
pub const PRIiFAST64: &[u8; 4] = b"lli\0";
pub const PRIo8: &[u8; 2] = b"o\0";
pub const PRIo16: &[u8; 2] = b"o\0";
pub const PRIo32: &[u8; 2] = b"o\0";
pub const PRIo64: &[u8; 4] = b"llo\0";
pub const PRIoLEAST8: &[u8; 2] = b"o\0";
pub const PRIoLEAST16: &[u8; 2] = b"o\0";
pub const PRIoLEAST32: &[u8; 2] = b"o\0";
pub const PRIoLEAST64: &[u8; 4] = b"llo\0";
pub const PRIoFAST8: &[u8; 2] = b"o\0";
pub const PRIoFAST64: &[u8; 4] = b"llo\0";
pub const PRIu8: &[u8; 2] = b"u\0";
pub const PRIu16: &[u8; 2] = b"u\0";
pub const PRIu32: &[u8; 2] = b"u\0";
pub const PRIu64: &[u8; 4] = b"llu\0";
pub const PRIuLEAST8: &[u8; 2] = b"u\0";
pub const PRIuLEAST16: &[u8; 2] = b"u\0";
pub const PRIuLEAST32: &[u8; 2] = b"u\0";
pub const PRIuLEAST64: &[u8; 4] = b"llu\0";
pub const PRIuFAST8: &[u8; 2] = b"u\0";
pub const PRIuFAST64: &[u8; 4] = b"llu\0";
pub const PRIx8: &[u8; 2] = b"x\0";
pub const PRIx16: &[u8; 2] = b"x\0";
pub const PRIx32: &[u8; 2] = b"x\0";
pub const PRIx64: &[u8; 4] = b"llx\0";
pub const PRIxLEAST8: &[u8; 2] = b"x\0";
pub const PRIxLEAST16: &[u8; 2] = b"x\0";
pub const PRIxLEAST32: &[u8; 2] = b"x\0";
pub const PRIxLEAST64: &[u8; 4] = b"llx\0";
pub const PRIxFAST8: &[u8; 2] = b"x\0";
pub const PRIxFAST64: &[u8; 4] = b"llx\0";
pub const PRIX8: &[u8; 2] = b"X\0";
pub const PRIX16: &[u8; 2] = b"X\0";
pub const PRIX32: &[u8; 2] = b"X\0";
pub const PRIX64: &[u8; 4] = b"llX\0";
pub const PRIXLEAST8: &[u8; 2] = b"X\0";
pub const PRIXLEAST16: &[u8; 2] = b"X\0";
pub const PRIXLEAST32: &[u8; 2] = b"X\0";
pub const PRIXLEAST64: &[u8; 4] = b"llX\0";
pub const PRIXFAST8: &[u8; 2] = b"X\0";
pub const PRIXFAST64: &[u8; 4] = b"llX\0";
pub const PRIdMAX: &[u8; 4] = b"lld\0";
pub const PRIiMAX: &[u8; 4] = b"lli\0";
pub const PRIoMAX: &[u8; 4] = b"llo\0";
pub const PRIuMAX: &[u8; 4] = b"llu\0";
pub const PRIxMAX: &[u8; 4] = b"llx\0";
pub const PRIXMAX: &[u8; 4] = b"llX\0";
pub const SCNd8: &[u8; 4] = b"hhd\0";
pub const SCNd16: &[u8; 3] = b"hd\0";
pub const SCNd32: &[u8; 2] = b"d\0";
pub const SCNd64: &[u8; 4] = b"lld\0";
pub const SCNdLEAST8: &[u8; 4] = b"hhd\0";
pub const SCNdLEAST16: &[u8; 3] = b"hd\0";
pub const SCNdLEAST32: &[u8; 2] = b"d\0";
pub const SCNdLEAST64: &[u8; 4] = b"lld\0";
pub const SCNdFAST8: &[u8; 4] = b"hhd\0";
pub const SCNdFAST64: &[u8; 4] = b"lld\0";
pub const SCNi8: &[u8; 4] = b"hhi\0";
pub const SCNi16: &[u8; 3] = b"hi\0";
pub const SCNi32: &[u8; 2] = b"i\0";
pub const SCNi64: &[u8; 4] = b"lli\0";
pub const SCNiLEAST8: &[u8; 4] = b"hhi\0";
pub const SCNiLEAST16: &[u8; 3] = b"hi\0";
pub const SCNiLEAST32: &[u8; 2] = b"i\0";
pub const SCNiLEAST64: &[u8; 4] = b"lli\0";
pub const SCNiFAST8: &[u8; 4] = b"hhi\0";
pub const SCNiFAST64: &[u8; 4] = b"lli\0";
pub const SCNu8: &[u8; 4] = b"hhu\0";
pub const SCNu16: &[u8; 3] = b"hu\0";
pub const SCNu32: &[u8; 2] = b"u\0";
pub const SCNu64: &[u8; 4] = b"llu\0";
pub const SCNuLEAST8: &[u8; 4] = b"hhu\0";
pub const SCNuLEAST16: &[u8; 3] = b"hu\0";
pub const SCNuLEAST32: &[u8; 2] = b"u\0";
pub const SCNuLEAST64: &[u8; 4] = b"llu\0";
pub const SCNuFAST8: &[u8; 4] = b"hhu\0";
pub const SCNuFAST64: &[u8; 4] = b"llu\0";
pub const SCNo8: &[u8; 4] = b"hho\0";
pub const SCNo16: &[u8; 3] = b"ho\0";
pub const SCNo32: &[u8; 2] = b"o\0";
pub const SCNo64: &[u8; 4] = b"llo\0";
pub const SCNoLEAST8: &[u8; 4] = b"hho\0";
pub const SCNoLEAST16: &[u8; 3] = b"ho\0";
pub const SCNoLEAST32: &[u8; 2] = b"o\0";
pub const SCNoLEAST64: &[u8; 4] = b"llo\0";
pub const SCNoFAST8: &[u8; 4] = b"hho\0";
pub const SCNoFAST64: &[u8; 4] = b"llo\0";
pub const SCNx8: &[u8; 4] = b"hhx\0";
pub const SCNx16: &[u8; 3] = b"hx\0";
pub const SCNx32: &[u8; 2] = b"x\0";
pub const SCNx64: &[u8; 4] = b"llx\0";
pub const SCNxLEAST8: &[u8; 4] = b"hhx\0";
pub const SCNxLEAST16: &[u8; 3] = b"hx\0";
pub const SCNxLEAST32: &[u8; 2] = b"x\0";
pub const SCNxLEAST64: &[u8; 4] = b"llx\0";
pub const SCNxFAST8: &[u8; 4] = b"hhx\0";
pub const SCNxFAST64: &[u8; 4] = b"llx\0";
pub const SCNdMAX: &[u8; 4] = b"lld\0";
pub const SCNiMAX: &[u8; 4] = b"lli\0";
pub const SCNoMAX: &[u8; 4] = b"llo\0";
pub const SCNuMAX: &[u8; 4] = b"llu\0";
pub const SCNxMAX: &[u8; 4] = b"llx\0";
pub const INT64PRId: &[u8; 4] = b"lld\0";
pub const INT64PRIi: &[u8; 4] = b"lli\0";
pub const UINT64PRIo: &[u8; 4] = b"llo\0";
pub const UINT64PRIu: &[u8; 4] = b"llu\0";
pub const UINT64PRIx: &[u8; 4] = b"llx\0";
pub const INT64SCNd: &[u8; 4] = b"lld\0";
pub const INT64SCNi: &[u8; 4] = b"lli\0";
pub const UINT64SCNo: &[u8; 4] = b"llo\0";
pub const UINT64SCNu: &[u8; 4] = b"llu\0";
pub const UINT64SCNx: &[u8; 4] = b"llx\0";
pub const ZFP_CACHE_LINE_SIZE: u32 = 256;
pub const ZFP_VERSION_MAJOR: u32 = 1;
pub const ZFP_VERSION_MINOR: u32 = 0;
pub const ZFP_VERSION_PATCH: u32 = 0;
pub const ZFP_VERSION_TWEAK: u32 = 0;
pub const ZFP_CODEC: u32 = 5;
pub const ZFP_MIN_BITS: u32 = 1;
pub const ZFP_MAX_BITS: u32 = 16658;
pub const ZFP_MAX_PREC: u32 = 64;
pub const ZFP_MIN_EXP: i32 = -1074;
pub const ZFP_HEADER_NONE: u32 = 0;
pub const ZFP_HEADER_MAGIC: u32 = 1;
pub const ZFP_HEADER_META: u32 = 2;
pub const ZFP_HEADER_MODE: u32 = 4;
pub const ZFP_HEADER_FULL: u32 = 7;
pub const ZFP_DATA_UNUSED: u32 = 1;
pub const ZFP_DATA_PADDING: u32 = 2;
pub const ZFP_DATA_META: u32 = 4;
pub const ZFP_DATA_MISC: u32 = 8;
pub const ZFP_DATA_PAYLOAD: u32 = 16;
pub const ZFP_DATA_INDEX: u32 = 32;
pub const ZFP_DATA_CACHE: u32 = 64;
pub const ZFP_DATA_HEADER: u32 = 128;
pub const ZFP_DATA_ALL: u32 = 255;
pub const ZFP_MAGIC_BITS: u32 = 32;
pub const ZFP_META_BITS: u32 = 52;
pub const ZFP_MODE_SHORT_BITS: u32 = 12;
pub const ZFP_MODE_LONG_BITS: u32 = 64;
pub const ZFP_HEADER_MAX_BITS: u32 = 148;
pub const ZFP_MODE_SHORT_MAX: u32 = 4094;
pub const ZFP_ROUND_FIRST: i32 = -1;
pub const ZFP_ROUND_NEVER: u32 = 0;
pub const ZFP_ROUND_LAST: u32 = 1;
pub type wchar_t = ::std::os::raw::c_int;
pub type uchar = ::std::os::raw::c_uchar;
pub type ushort = ::std::os::raw::c_ushort;
pub type uint = ::std::os::raw::c_uint;
pub type ulong = ::std::os::raw::c_ulong;
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_schar;
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_longlong;
pub type __uint64_t = ::std::os::raw::c_ulonglong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_longlong;
pub type __u_quad_t = ::std::os::raw::c_ulonglong;
pub type __intmax_t = ::std::os::raw::c_longlong;
pub type __uintmax_t = ::std::os::raw::c_ulonglong;
pub type __dev_t = __uint64_t;
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 = __uint64_t;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_uint;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = __int64_t;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = __uint64_t;
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 __suseconds64_t = __int64_t;
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 = __int64_t;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = __uint64_t;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = __uint64_t;
pub type __fsword_t = ::std::os::raw::c_int;
pub type __ssize_t = ::std::os::raw::c_int;
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 __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_int;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type __time64_t = __int64_t;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_int;
pub type int_fast32_t = ::std::os::raw::c_int;
pub type int_fast64_t = ::std::os::raw::c_longlong;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_uint;
pub type uint_fast32_t = ::std::os::raw::c_uint;
pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type __gwchar_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct imaxdiv_t {
pub quot: ::std::os::raw::c_longlong,
pub rem: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_imaxdiv_t() {
const UNINIT: ::std::mem::MaybeUninit<imaxdiv_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<imaxdiv_t>(),
16usize,
concat!("Size of: ", stringify!(imaxdiv_t))
);
assert_eq!(
::std::mem::align_of::<imaxdiv_t>(),
4usize,
concat!("Alignment of ", stringify!(imaxdiv_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(imaxdiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(imaxdiv_t),
"::",
stringify!(rem)
)
);
}
extern "C" {
pub fn imaxabs(__n: intmax_t) -> intmax_t;
}
extern "C" {
pub fn imaxdiv(__numer: intmax_t, __denom: intmax_t) -> imaxdiv_t;
}
extern "C" {
pub fn strtoimax(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> intmax_t;
}
extern "C" {
pub fn strtoumax(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> uintmax_t;
}
extern "C" {
pub fn wcstoimax(
__nptr: *const __gwchar_t,
__endptr: *mut *mut __gwchar_t,
__base: ::std::os::raw::c_int,
) -> intmax_t;
}
extern "C" {
pub fn wcstoumax(
__nptr: *const __gwchar_t,
__endptr: *mut *mut __gwchar_t,
__base: ::std::os::raw::c_int,
) -> uintmax_t;
}
pub type int8 = i8;
pub type uint8 = u8;
pub type int16 = i16;
pub type uint16 = u16;
pub type int32 = i32;
pub type uint32 = u32;
pub type int64 = i64;
pub type uint64 = u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bitstream {
_unused: [u8; 0],
}
pub type bitstream_offset = uint64;
pub type bitstream_size = bitstream_offset;
pub type bitstream_count = usize;
extern "C" {
pub static stream_word_bits: usize;
}
extern "C" {
pub fn stream_open(buffer: *mut ::std::os::raw::c_void, bytes: usize) -> *mut bitstream;
}
extern "C" {
pub fn stream_close(stream: *mut bitstream);
}
extern "C" {
pub fn stream_clone(stream: *const bitstream) -> *mut bitstream;
}
extern "C" {
pub fn stream_alignment() -> bitstream_count;
}
extern "C" {
pub fn stream_data(stream: *const bitstream) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn stream_size(stream: *const bitstream) -> usize;
}
extern "C" {
pub fn stream_capacity(stream: *const bitstream) -> usize;
}
extern "C" {
pub fn stream_stride_block(stream: *const bitstream) -> usize;
}
extern "C" {
pub fn stream_stride_delta(stream: *const bitstream) -> isize;
}
extern "C" {
pub fn stream_read_bit(stream: *mut bitstream) -> uint;
}
extern "C" {
pub fn stream_write_bit(stream: *mut bitstream, bit: uint) -> uint;
}
extern "C" {
pub fn stream_read_bits(stream: *mut bitstream, n: bitstream_count) -> uint64;
}
extern "C" {
pub fn stream_write_bits(stream: *mut bitstream, value: uint64, n: bitstream_count) -> uint64;
}
extern "C" {
pub fn stream_rtell(stream: *const bitstream) -> bitstream_offset;
}
extern "C" {
pub fn stream_wtell(stream: *const bitstream) -> bitstream_offset;
}
extern "C" {
pub fn stream_rewind(stream: *mut bitstream);
}
extern "C" {
pub fn stream_rseek(stream: *mut bitstream, offset: bitstream_offset);
}
extern "C" {
pub fn stream_wseek(stream: *mut bitstream, offset: bitstream_offset);
}
extern "C" {
pub fn stream_skip(stream: *mut bitstream, n: bitstream_size);
}
extern "C" {
pub fn stream_pad(stream: *mut bitstream, n: bitstream_size);
}
extern "C" {
pub fn stream_align(stream: *mut bitstream) -> bitstream_count;
}
extern "C" {
pub fn stream_flush(stream: *mut bitstream) -> bitstream_count;
}
extern "C" {
pub fn stream_copy(dst: *mut bitstream, src: *mut bitstream, n: bitstream_size);
}
pub const zfp_false: _bindgen_ty_1 = 0;
pub const zfp_true: _bindgen_ty_1 = 1;
pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
pub type zfp_bool = ::std::os::raw::c_int;
pub const zfp_exec_policy_zfp_exec_serial: zfp_exec_policy = 0;
pub const zfp_exec_policy_zfp_exec_omp: zfp_exec_policy = 1;
pub const zfp_exec_policy_zfp_exec_cuda: zfp_exec_policy = 2;
pub type zfp_exec_policy = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zfp_exec_params_omp {
pub threads: uint,
pub chunk_size: uint,
}
#[test]
fn bindgen_test_layout_zfp_exec_params_omp() {
const UNINIT: ::std::mem::MaybeUninit<zfp_exec_params_omp> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<zfp_exec_params_omp>(),
8usize,
concat!("Size of: ", stringify!(zfp_exec_params_omp))
);
assert_eq!(
::std::mem::align_of::<zfp_exec_params_omp>(),
4usize,
concat!("Alignment of ", stringify!(zfp_exec_params_omp))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).threads) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_exec_params_omp),
"::",
stringify!(threads)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chunk_size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(zfp_exec_params_omp),
"::",
stringify!(chunk_size)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zfp_execution {
pub policy: zfp_exec_policy,
pub params: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_zfp_execution() {
const UNINIT: ::std::mem::MaybeUninit<zfp_execution> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<zfp_execution>(),
8usize,
concat!("Size of: ", stringify!(zfp_execution))
);
assert_eq!(
::std::mem::align_of::<zfp_execution>(),
4usize,
concat!("Alignment of ", stringify!(zfp_execution))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).policy) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_execution),
"::",
stringify!(policy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(zfp_execution),
"::",
stringify!(params)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zfp_stream {
pub minbits: uint,
pub maxbits: uint,
pub maxprec: uint,
pub minexp: ::std::os::raw::c_int,
pub stream: *mut bitstream,
pub exec: zfp_execution,
}
#[test]
fn bindgen_test_layout_zfp_stream() {
const UNINIT: ::std::mem::MaybeUninit<zfp_stream> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<zfp_stream>(),
28usize,
concat!("Size of: ", stringify!(zfp_stream))
);
assert_eq!(
::std::mem::align_of::<zfp_stream>(),
4usize,
concat!("Alignment of ", stringify!(zfp_stream))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minbits) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_stream),
"::",
stringify!(minbits)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxbits) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(zfp_stream),
"::",
stringify!(maxbits)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxprec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(zfp_stream),
"::",
stringify!(maxprec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minexp) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(zfp_stream),
"::",
stringify!(minexp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(zfp_stream),
"::",
stringify!(stream)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).exec) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(zfp_stream),
"::",
stringify!(exec)
)
);
}
pub const zfp_mode_zfp_mode_null: zfp_mode = 0;
pub const zfp_mode_zfp_mode_expert: zfp_mode = 1;
pub const zfp_mode_zfp_mode_fixed_rate: zfp_mode = 2;
pub const zfp_mode_zfp_mode_fixed_precision: zfp_mode = 3;
pub const zfp_mode_zfp_mode_fixed_accuracy: zfp_mode = 4;
pub const zfp_mode_zfp_mode_reversible: zfp_mode = 5;
pub type zfp_mode = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct zfp_config {
pub mode: zfp_mode,
pub arg: zfp_config__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union zfp_config__bindgen_ty_1 {
pub rate: f64,
pub precision: uint,
pub tolerance: f64,
pub expert: zfp_config__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zfp_config__bindgen_ty_1__bindgen_ty_1 {
pub minbits: uint,
pub maxbits: uint,
pub maxprec: uint,
pub minexp: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_zfp_config__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<zfp_config__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<zfp_config__bindgen_ty_1__bindgen_ty_1>(),
16usize,
concat!(
"Size of: ",
stringify!(zfp_config__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<zfp_config__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(zfp_config__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minbits) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_config__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(minbits)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxbits) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(zfp_config__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(maxbits)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxprec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(zfp_config__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(maxprec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minexp) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(zfp_config__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(minexp)
)
);
}
#[test]
fn bindgen_test_layout_zfp_config__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<zfp_config__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<zfp_config__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(zfp_config__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<zfp_config__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(zfp_config__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rate) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_config__bindgen_ty_1),
"::",
stringify!(rate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).precision) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_config__bindgen_ty_1),
"::",
stringify!(precision)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tolerance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_config__bindgen_ty_1),
"::",
stringify!(tolerance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).expert) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_config__bindgen_ty_1),
"::",
stringify!(expert)
)
);
}
#[test]
fn bindgen_test_layout_zfp_config() {
const UNINIT: ::std::mem::MaybeUninit<zfp_config> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<zfp_config>(),
20usize,
concat!("Size of: ", stringify!(zfp_config))
);
assert_eq!(
::std::mem::align_of::<zfp_config>(),
4usize,
concat!("Alignment of ", stringify!(zfp_config))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_config),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arg) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(zfp_config),
"::",
stringify!(arg)
)
);
}
pub const zfp_type_zfp_type_none: zfp_type = 0;
pub const zfp_type_zfp_type_int32: zfp_type = 1;
pub const zfp_type_zfp_type_int64: zfp_type = 2;
pub const zfp_type_zfp_type_float: zfp_type = 3;
pub const zfp_type_zfp_type_double: zfp_type = 4;
pub type zfp_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zfp_field {
pub type_: zfp_type,
pub nx: usize,
pub ny: usize,
pub nz: usize,
pub nw: usize,
pub sx: isize,
pub sy: isize,
pub sz: isize,
pub sw: isize,
pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_zfp_field() {
const UNINIT: ::std::mem::MaybeUninit<zfp_field> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<zfp_field>(),
40usize,
concat!("Size of: ", stringify!(zfp_field))
);
assert_eq!(
::std::mem::align_of::<zfp_field>(),
4usize,
concat!("Alignment of ", stringify!(zfp_field))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nx) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(nx)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ny) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(ny)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nz) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(nz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nw) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(nw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sx) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(sx)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sy) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(sy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sz) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(sz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(sw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(zfp_field),
"::",
stringify!(data)
)
);
}
extern "C" {
pub static zfp_codec_version: uint;
}
extern "C" {
pub static zfp_library_version: uint;
}
extern "C" {
pub static zfp_version_string: *const ::std::os::raw::c_char;
}
extern "C" {
pub fn zfp_type_size(type_: zfp_type) -> usize;
}
extern "C" {
pub fn zfp_stream_open(stream: *mut bitstream) -> *mut zfp_stream;
}
extern "C" {
pub fn zfp_stream_close(stream: *mut zfp_stream);
}
extern "C" {
pub fn zfp_stream_bit_stream(stream: *const zfp_stream) -> *mut bitstream;
}
extern "C" {
pub fn zfp_stream_compression_mode(stream: *const zfp_stream) -> zfp_mode;
}
extern "C" {
pub fn zfp_stream_rate(stream: *const zfp_stream, dims: uint) -> f64;
}
extern "C" {
pub fn zfp_stream_precision(stream: *const zfp_stream) -> uint;
}
extern "C" {
pub fn zfp_stream_accuracy(stream: *const zfp_stream) -> f64;
}
extern "C" {
pub fn zfp_stream_mode(stream: *const zfp_stream) -> uint64;
}
extern "C" {
pub fn zfp_stream_params(
stream: *const zfp_stream,
minbits: *mut uint,
maxbits: *mut uint,
maxprec: *mut uint,
minexp: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn zfp_stream_compressed_size(stream: *const zfp_stream) -> usize;
}
extern "C" {
pub fn zfp_stream_maximum_size(stream: *const zfp_stream, field: *const zfp_field) -> usize;
}
extern "C" {
pub fn zfp_stream_rewind(stream: *mut zfp_stream);
}
extern "C" {
pub fn zfp_stream_set_bit_stream(stream: *mut zfp_stream, bs: *mut bitstream);
}
extern "C" {
pub fn zfp_stream_set_reversible(stream: *mut zfp_stream);
}
extern "C" {
pub fn zfp_stream_set_rate(
stream: *mut zfp_stream,
rate: f64,
type_: zfp_type,
dims: uint,
align: zfp_bool,
) -> f64;
}
extern "C" {
pub fn zfp_stream_set_precision(stream: *mut zfp_stream, precision: uint) -> uint;
}
extern "C" {
pub fn zfp_stream_set_accuracy(stream: *mut zfp_stream, tolerance: f64) -> f64;
}
extern "C" {
pub fn zfp_stream_set_mode(stream: *mut zfp_stream, mode: uint64) -> zfp_mode;
}
extern "C" {
pub fn zfp_stream_set_params(
stream: *mut zfp_stream,
minbits: uint,
maxbits: uint,
maxprec: uint,
minexp: ::std::os::raw::c_int,
) -> zfp_bool;
}
extern "C" {
pub fn zfp_stream_execution(stream: *const zfp_stream) -> zfp_exec_policy;
}
extern "C" {
pub fn zfp_stream_omp_threads(stream: *const zfp_stream) -> uint;
}
extern "C" {
pub fn zfp_stream_omp_chunk_size(stream: *const zfp_stream) -> uint;
}
extern "C" {
pub fn zfp_stream_set_execution(stream: *mut zfp_stream, policy: zfp_exec_policy) -> zfp_bool;
}
extern "C" {
pub fn zfp_stream_set_omp_threads(stream: *mut zfp_stream, threads: uint) -> zfp_bool;
}
extern "C" {
pub fn zfp_stream_set_omp_chunk_size(stream: *mut zfp_stream, chunk_size: uint) -> zfp_bool;
}
extern "C" {
pub fn zfp_config_none() -> zfp_config;
}
extern "C" {
pub fn zfp_config_rate(rate: f64, align: zfp_bool) -> zfp_config;
}
extern "C" {
pub fn zfp_config_precision(precision: uint) -> zfp_config;
}
extern "C" {
pub fn zfp_config_accuracy(tolerance: f64) -> zfp_config;
}
extern "C" {
pub fn zfp_config_reversible() -> zfp_config;
}
extern "C" {
pub fn zfp_config_expert(
minbits: uint,
maxbits: uint,
maxprec: uint,
minexp: ::std::os::raw::c_int,
) -> zfp_config;
}
extern "C" {
pub fn zfp_field_alloc() -> *mut zfp_field;
}
extern "C" {
pub fn zfp_field_1d(
pointer: *mut ::std::os::raw::c_void,
type_: zfp_type,
nx: usize,
) -> *mut zfp_field;
}
extern "C" {
pub fn zfp_field_2d(
pointer: *mut ::std::os::raw::c_void,
type_: zfp_type,
nx: usize,
ny: usize,
) -> *mut zfp_field;
}
extern "C" {
pub fn zfp_field_3d(
pointer: *mut ::std::os::raw::c_void,
type_: zfp_type,
nx: usize,
ny: usize,
nz: usize,
) -> *mut zfp_field;
}
extern "C" {
pub fn zfp_field_4d(
pointer: *mut ::std::os::raw::c_void,
type_: zfp_type,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
) -> *mut zfp_field;
}
extern "C" {
pub fn zfp_field_free(field: *mut zfp_field);
}
extern "C" {
pub fn zfp_field_pointer(field: *const zfp_field) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn zfp_field_begin(field: *const zfp_field) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn zfp_field_type(field: *const zfp_field) -> zfp_type;
}
extern "C" {
pub fn zfp_field_precision(field: *const zfp_field) -> uint;
}
extern "C" {
pub fn zfp_field_dimensionality(field: *const zfp_field) -> uint;
}
extern "C" {
pub fn zfp_field_size(field: *const zfp_field, size: *mut usize) -> usize;
}
extern "C" {
pub fn zfp_field_size_bytes(field: *const zfp_field) -> usize;
}
extern "C" {
pub fn zfp_field_blocks(field: *const zfp_field) -> usize;
}
extern "C" {
pub fn zfp_field_stride(field: *const zfp_field, stride: *mut isize) -> zfp_bool;
}
extern "C" {
pub fn zfp_field_is_contiguous(field: *const zfp_field) -> zfp_bool;
}
extern "C" {
pub fn zfp_field_metadata(field: *const zfp_field) -> uint64;
}
extern "C" {
pub fn zfp_field_set_pointer(field: *mut zfp_field, pointer: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn zfp_field_set_type(field: *mut zfp_field, type_: zfp_type) -> zfp_type;
}
extern "C" {
pub fn zfp_field_set_size_1d(field: *mut zfp_field, nx: usize);
}
extern "C" {
pub fn zfp_field_set_size_2d(field: *mut zfp_field, nx: usize, ny: usize);
}
extern "C" {
pub fn zfp_field_set_size_3d(field: *mut zfp_field, nx: usize, ny: usize, nz: usize);
}
extern "C" {
pub fn zfp_field_set_size_4d(field: *mut zfp_field, nx: usize, ny: usize, nz: usize, nw: usize);
}
extern "C" {
pub fn zfp_field_set_stride_1d(field: *mut zfp_field, sx: isize);
}
extern "C" {
pub fn zfp_field_set_stride_2d(field: *mut zfp_field, sx: isize, sy: isize);
}
extern "C" {
pub fn zfp_field_set_stride_3d(field: *mut zfp_field, sx: isize, sy: isize, sz: isize);
}
extern "C" {
pub fn zfp_field_set_stride_4d(
field: *mut zfp_field,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
);
}
extern "C" {
pub fn zfp_field_set_metadata(field: *mut zfp_field, meta: uint64) -> zfp_bool;
}
extern "C" {
pub fn zfp_compress(stream: *mut zfp_stream, field: *const zfp_field) -> usize;
}
extern "C" {
pub fn zfp_decompress(stream: *mut zfp_stream, field: *mut zfp_field) -> usize;
}
extern "C" {
pub fn zfp_write_header(stream: *mut zfp_stream, field: *const zfp_field, mask: uint) -> usize;
}
extern "C" {
pub fn zfp_read_header(stream: *mut zfp_stream, field: *mut zfp_field, mask: uint) -> usize;
}
extern "C" {
pub fn zfp_stream_flush(stream: *mut zfp_stream) -> usize;
}
extern "C" {
pub fn zfp_stream_align(stream: *mut zfp_stream) -> usize;
}
extern "C" {
pub fn zfp_encode_block_int32_1(stream: *mut zfp_stream, block: *const int32) -> usize;
}
extern "C" {
pub fn zfp_encode_block_int64_1(stream: *mut zfp_stream, block: *const int64) -> usize;
}
extern "C" {
pub fn zfp_encode_block_float_1(stream: *mut zfp_stream, block: *const f32) -> usize;
}
extern "C" {
pub fn zfp_encode_block_double_1(stream: *mut zfp_stream, block: *const f64) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_int32_1(
stream: *mut zfp_stream,
p: *const int32,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_int64_1(
stream: *mut zfp_stream,
p: *const int64,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_float_1(
stream: *mut zfp_stream,
p: *const f32,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_double_1(
stream: *mut zfp_stream,
p: *const f64,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_int32_1(
stream: *mut zfp_stream,
p: *const int32,
nx: usize,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_int64_1(
stream: *mut zfp_stream,
p: *const int64,
nx: usize,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_float_1(
stream: *mut zfp_stream,
p: *const f32,
nx: usize,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_double_1(
stream: *mut zfp_stream,
p: *const f64,
nx: usize,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_int32_2(stream: *mut zfp_stream, block: *const int32) -> usize;
}
extern "C" {
pub fn zfp_encode_block_int64_2(stream: *mut zfp_stream, block: *const int64) -> usize;
}
extern "C" {
pub fn zfp_encode_block_float_2(stream: *mut zfp_stream, block: *const f32) -> usize;
}
extern "C" {
pub fn zfp_encode_block_double_2(stream: *mut zfp_stream, block: *const f64) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_int32_2(
stream: *mut zfp_stream,
p: *const int32,
nx: usize,
ny: usize,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_int64_2(
stream: *mut zfp_stream,
p: *const int64,
nx: usize,
ny: usize,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_float_2(
stream: *mut zfp_stream,
p: *const f32,
nx: usize,
ny: usize,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_double_2(
stream: *mut zfp_stream,
p: *const f64,
nx: usize,
ny: usize,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_int32_2(
stream: *mut zfp_stream,
p: *const int32,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_int64_2(
stream: *mut zfp_stream,
p: *const int64,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_float_2(
stream: *mut zfp_stream,
p: *const f32,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_double_2(
stream: *mut zfp_stream,
p: *const f64,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_int32_3(stream: *mut zfp_stream, block: *const int32) -> usize;
}
extern "C" {
pub fn zfp_encode_block_int64_3(stream: *mut zfp_stream, block: *const int64) -> usize;
}
extern "C" {
pub fn zfp_encode_block_float_3(stream: *mut zfp_stream, block: *const f32) -> usize;
}
extern "C" {
pub fn zfp_encode_block_double_3(stream: *mut zfp_stream, block: *const f64) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_int32_3(
stream: *mut zfp_stream,
p: *const int32,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_int64_3(
stream: *mut zfp_stream,
p: *const int64,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_float_3(
stream: *mut zfp_stream,
p: *const f32,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_double_3(
stream: *mut zfp_stream,
p: *const f64,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_int32_3(
stream: *mut zfp_stream,
p: *const int32,
nx: usize,
ny: usize,
nz: usize,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_int64_3(
stream: *mut zfp_stream,
p: *const int64,
nx: usize,
ny: usize,
nz: usize,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_float_3(
stream: *mut zfp_stream,
p: *const f32,
nx: usize,
ny: usize,
nz: usize,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_double_3(
stream: *mut zfp_stream,
p: *const f64,
nx: usize,
ny: usize,
nz: usize,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_int32_4(stream: *mut zfp_stream, block: *const int32) -> usize;
}
extern "C" {
pub fn zfp_encode_block_int64_4(stream: *mut zfp_stream, block: *const int64) -> usize;
}
extern "C" {
pub fn zfp_encode_block_float_4(stream: *mut zfp_stream, block: *const f32) -> usize;
}
extern "C" {
pub fn zfp_encode_block_double_4(stream: *mut zfp_stream, block: *const f64) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_int32_4(
stream: *mut zfp_stream,
p: *const int32,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_int64_4(
stream: *mut zfp_stream,
p: *const int64,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_float_4(
stream: *mut zfp_stream,
p: *const f32,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_block_strided_double_4(
stream: *mut zfp_stream,
p: *const f64,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_int32_4(
stream: *mut zfp_stream,
p: *const int32,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_int64_4(
stream: *mut zfp_stream,
p: *const int64,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_float_4(
stream: *mut zfp_stream,
p: *const f32,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_encode_partial_block_strided_double_4(
stream: *mut zfp_stream,
p: *const f64,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_int32_1(stream: *mut zfp_stream, block: *mut int32) -> usize;
}
extern "C" {
pub fn zfp_decode_block_int64_1(stream: *mut zfp_stream, block: *mut int64) -> usize;
}
extern "C" {
pub fn zfp_decode_block_float_1(stream: *mut zfp_stream, block: *mut f32) -> usize;
}
extern "C" {
pub fn zfp_decode_block_double_1(stream: *mut zfp_stream, block: *mut f64) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_int32_1(
stream: *mut zfp_stream,
p: *mut int32,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_int64_1(
stream: *mut zfp_stream,
p: *mut int64,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_float_1(
stream: *mut zfp_stream,
p: *mut f32,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_double_1(
stream: *mut zfp_stream,
p: *mut f64,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_int32_1(
stream: *mut zfp_stream,
p: *mut int32,
nx: usize,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_int64_1(
stream: *mut zfp_stream,
p: *mut int64,
nx: usize,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_float_1(
stream: *mut zfp_stream,
p: *mut f32,
nx: usize,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_double_1(
stream: *mut zfp_stream,
p: *mut f64,
nx: usize,
sx: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_int32_2(stream: *mut zfp_stream, block: *mut int32) -> usize;
}
extern "C" {
pub fn zfp_decode_block_int64_2(stream: *mut zfp_stream, block: *mut int64) -> usize;
}
extern "C" {
pub fn zfp_decode_block_float_2(stream: *mut zfp_stream, block: *mut f32) -> usize;
}
extern "C" {
pub fn zfp_decode_block_double_2(stream: *mut zfp_stream, block: *mut f64) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_int32_2(
stream: *mut zfp_stream,
p: *mut int32,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_int64_2(
stream: *mut zfp_stream,
p: *mut int64,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_float_2(
stream: *mut zfp_stream,
p: *mut f32,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_double_2(
stream: *mut zfp_stream,
p: *mut f64,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_int32_2(
stream: *mut zfp_stream,
p: *mut int32,
nx: usize,
ny: usize,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_int64_2(
stream: *mut zfp_stream,
p: *mut int64,
nx: usize,
ny: usize,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_float_2(
stream: *mut zfp_stream,
p: *mut f32,
nx: usize,
ny: usize,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_double_2(
stream: *mut zfp_stream,
p: *mut f64,
nx: usize,
ny: usize,
sx: isize,
sy: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_int32_3(stream: *mut zfp_stream, block: *mut int32) -> usize;
}
extern "C" {
pub fn zfp_decode_block_int64_3(stream: *mut zfp_stream, block: *mut int64) -> usize;
}
extern "C" {
pub fn zfp_decode_block_float_3(stream: *mut zfp_stream, block: *mut f32) -> usize;
}
extern "C" {
pub fn zfp_decode_block_double_3(stream: *mut zfp_stream, block: *mut f64) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_int32_3(
stream: *mut zfp_stream,
p: *mut int32,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_int64_3(
stream: *mut zfp_stream,
p: *mut int64,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_float_3(
stream: *mut zfp_stream,
p: *mut f32,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_double_3(
stream: *mut zfp_stream,
p: *mut f64,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_int32_3(
stream: *mut zfp_stream,
p: *mut int32,
nx: usize,
ny: usize,
nz: usize,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_int64_3(
stream: *mut zfp_stream,
p: *mut int64,
nx: usize,
ny: usize,
nz: usize,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_float_3(
stream: *mut zfp_stream,
p: *mut f32,
nx: usize,
ny: usize,
nz: usize,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_double_3(
stream: *mut zfp_stream,
p: *mut f64,
nx: usize,
ny: usize,
nz: usize,
sx: isize,
sy: isize,
sz: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_int32_4(stream: *mut zfp_stream, block: *mut int32) -> usize;
}
extern "C" {
pub fn zfp_decode_block_int64_4(stream: *mut zfp_stream, block: *mut int64) -> usize;
}
extern "C" {
pub fn zfp_decode_block_float_4(stream: *mut zfp_stream, block: *mut f32) -> usize;
}
extern "C" {
pub fn zfp_decode_block_double_4(stream: *mut zfp_stream, block: *mut f64) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_int32_4(
stream: *mut zfp_stream,
p: *mut int32,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_int64_4(
stream: *mut zfp_stream,
p: *mut int64,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_float_4(
stream: *mut zfp_stream,
p: *mut f32,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_block_strided_double_4(
stream: *mut zfp_stream,
p: *mut f64,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_int32_4(
stream: *mut zfp_stream,
p: *mut int32,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_int64_4(
stream: *mut zfp_stream,
p: *mut int64,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_float_4(
stream: *mut zfp_stream,
p: *mut f32,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_decode_partial_block_strided_double_4(
stream: *mut zfp_stream,
p: *mut f64,
nx: usize,
ny: usize,
nz: usize,
nw: usize,
sx: isize,
sy: isize,
sz: isize,
sw: isize,
) -> usize;
}
extern "C" {
pub fn zfp_promote_int8_to_int32(oblock: *mut int32, iblock: *const int8, dims: uint);
}
extern "C" {
pub fn zfp_promote_uint8_to_int32(oblock: *mut int32, iblock: *const uint8, dims: uint);
}
extern "C" {
pub fn zfp_promote_int16_to_int32(oblock: *mut int32, iblock: *const int16, dims: uint);
}
extern "C" {
pub fn zfp_promote_uint16_to_int32(oblock: *mut int32, iblock: *const uint16, dims: uint);
}
extern "C" {
pub fn zfp_demote_int32_to_int8(oblock: *mut int8, iblock: *const int32, dims: uint);
}
extern "C" {
pub fn zfp_demote_int32_to_uint8(oblock: *mut uint8, iblock: *const int32, dims: uint);
}
extern "C" {
pub fn zfp_demote_int32_to_int16(oblock: *mut int16, iblock: *const int32, dims: uint);
}
extern "C" {
pub fn zfp_demote_int32_to_uint16(oblock: *mut uint16, iblock: *const int32, dims: uint);
}