1#[repr(C)]
4#[derive(Default)]
5pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
6impl<T> __IncompleteArrayField<T> {
7 #[inline]
8 pub const fn new() -> Self {
9 __IncompleteArrayField(::std::marker::PhantomData, [])
10 }
11 #[inline]
12 pub fn as_ptr(&self) -> *const T {
13 self as *const _ as *const T
14 }
15 #[inline]
16 pub fn as_mut_ptr(&mut self) -> *mut T {
17 self as *mut _ as *mut T
18 }
19 #[inline]
20 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
21 ::std::slice::from_raw_parts(self.as_ptr(), len)
22 }
23 #[inline]
24 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
25 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
26 }
27}
28impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
29 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
30 fmt.write_str("__IncompleteArrayField")
31 }
32}
33pub const _GLIBCXX_CSTDINT: u32 = 1;
34pub const _CPP_CPPCONFIG_WRAPPER: u32 = 1;
35pub const __WORDSIZE: u32 = 64;
36pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
37pub const __SYSCALL_WORDSIZE: u32 = 64;
38pub const _GLIBCXX_CXX_CONFIG_H: u32 = 1;
39pub const _GLIBCXX_RELEASE: u32 = 15;
40pub const __GLIBCXX__: u32 = 20250521;
41pub const _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY: u32 = 1;
42pub const _GLIBCXX_USE_DEPRECATED: u32 = 1;
43pub const _GLIBCXX_EXTERN_TEMPLATE: u32 = 1;
44pub const _GLIBCXX_USE_DUAL_ABI: u32 = 1;
45pub const _GLIBCXX_USE_CXX11_ABI: u32 = 1;
46pub const _GLIBCXX_INLINE_VERSION: u32 = 0;
47pub const _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED: u32 = 1;
48pub const _GLIBCXX_ASSERTIONS: u32 = 1;
49pub const _GLIBCXX_VERBOSE_ASSERT: u32 = 1;
50pub const _GLIBCXX_USE_ALLOCATOR_NEW: u32 = 1;
51pub const _GLIBCXX_OS_DEFINES: u32 = 1;
52pub const __NO_CTYPE: u32 = 1;
53pub const _FEATURES_H: u32 = 1;
54pub const _ISOC95_SOURCE: u32 = 1;
55pub const _ISOC99_SOURCE: u32 = 1;
56pub const _ISOC11_SOURCE: u32 = 1;
57pub const _ISOC23_SOURCE: u32 = 1;
58pub const _ISOC2Y_SOURCE: u32 = 1;
59pub const _POSIX_SOURCE: u32 = 1;
60pub const _POSIX_C_SOURCE: u32 = 200809;
61pub const _XOPEN_SOURCE: u32 = 700;
62pub const _XOPEN_SOURCE_EXTENDED: u32 = 1;
63pub const _LARGEFILE64_SOURCE: u32 = 1;
64pub const _DEFAULT_SOURCE: u32 = 1;
65pub const _ATFILE_SOURCE: u32 = 1;
66pub const _DYNAMIC_STACK_SIZE_SOURCE: u32 = 1;
67pub const __GLIBC_USE_ISOC2Y: u32 = 1;
68pub const __GLIBC_USE_ISOC23: u32 = 1;
69pub const __USE_ISOC11: u32 = 1;
70pub const __USE_ISOC99: u32 = 1;
71pub const __USE_ISOC95: u32 = 1;
72pub const __USE_ISOCXX11: u32 = 1;
73pub const __USE_POSIX: u32 = 1;
74pub const __USE_POSIX2: u32 = 1;
75pub const __USE_POSIX199309: u32 = 1;
76pub const __USE_POSIX199506: u32 = 1;
77pub const __USE_XOPEN2K: u32 = 1;
78pub const __USE_XOPEN2K8: u32 = 1;
79pub const __USE_XOPEN: u32 = 1;
80pub const __USE_XOPEN_EXTENDED: u32 = 1;
81pub const __USE_UNIX98: u32 = 1;
82pub const _LARGEFILE_SOURCE: u32 = 1;
83pub const __USE_XOPEN2K8XSI: u32 = 1;
84pub const __USE_XOPEN2KXSI: u32 = 1;
85pub const __USE_LARGEFILE: u32 = 1;
86pub const __USE_LARGEFILE64: u32 = 1;
87pub const __TIMESIZE: u32 = 64;
88pub const __USE_TIME_BITS64: u32 = 1;
89pub const __USE_MISC: u32 = 1;
90pub const __USE_ATFILE: u32 = 1;
91pub const __USE_DYNAMIC_STACK_SIZE: u32 = 1;
92pub const __USE_GNU: u32 = 1;
93pub const __USE_FORTIFY_LEVEL: u32 = 0;
94pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
95pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
96pub const __GLIBC_USE_C23_STRTOL: u32 = 1;
97pub const _STDC_PREDEF_H: u32 = 1;
98pub const __STDC_IEC_559__: u32 = 1;
99pub const __STDC_IEC_60559_BFP__: u32 = 201404;
100pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
101pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
102pub const __STDC_ISO_10646__: u32 = 201706;
103pub const __GNU_LIBRARY__: u32 = 6;
104pub const __GLIBC__: u32 = 2;
105pub const __GLIBC_MINOR__: u32 = 41;
106pub const _SYS_CDEFS_H: u32 = 1;
107pub const __glibc_c99_flexarr_available: u32 = 1;
108pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
109pub const __HAVE_GENERIC_SELECTION: u32 = 0;
110pub const _GLIBCXX_HAVE_FLOAT128_MATH: u32 = 1;
111pub const _GLIBCXX_MAY_HAVE___CXA_THREAD_ATEXIT_IMPL: u32 = 1;
112pub const _GLIBCXX_GTHREAD_USE_WEAK: u32 = 0;
113pub const _GLIBCXX_CPU_DEFINES: u32 = 1;
114pub const _GLIBCXX_FAST_MATH: u32 = 0;
115pub const _GLIBCXX_USE_FLOAT128: u32 = 1;
116pub const _GLIBCXX_FLOAT_IS_IEEE_BINARY32: u32 = 1;
117pub const _GLIBCXX_DOUBLE_IS_IEEE_BINARY64: u32 = 1;
118pub const _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP: u32 = 1;
119pub const _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE: u32 = 1;
120pub const _GLIBCXX_HAVE_BUILTIN_LAUNDER: u32 = 1;
121pub const _GLIBCXX_HAVE_ACOSF: u32 = 1;
122pub const _GLIBCXX_HAVE_ACOSL: u32 = 1;
123pub const _GLIBCXX_HAVE_ALIGNED_ALLOC: u32 = 1;
124pub const _GLIBCXX_HAVE_ARC4RANDOM: u32 = 1;
125pub const _GLIBCXX_HAVE_ARPA_INET_H: u32 = 1;
126pub const _GLIBCXX_HAVE_ASINF: u32 = 1;
127pub const _GLIBCXX_HAVE_ASINL: u32 = 1;
128pub const _GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE: u32 = 1;
129pub const _GLIBCXX_HAVE_ATAN2F: u32 = 1;
130pub const _GLIBCXX_HAVE_ATAN2L: u32 = 1;
131pub const _GLIBCXX_HAVE_ATANF: u32 = 1;
132pub const _GLIBCXX_HAVE_ATANL: u32 = 1;
133pub const _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY: u32 = 1;
134pub const _GLIBCXX_HAVE_AT_QUICK_EXIT: u32 = 1;
135pub const _GLIBCXX_HAVE_C99_FLT_EVAL_TYPES: u32 = 1;
136pub const _GLIBCXX_HAVE_CEILF: u32 = 1;
137pub const _GLIBCXX_HAVE_CEILL: u32 = 1;
138pub const _GLIBCXX_HAVE_COMPLEX_H: u32 = 1;
139pub const _GLIBCXX_HAVE_COSF: u32 = 1;
140pub const _GLIBCXX_HAVE_COSHF: u32 = 1;
141pub const _GLIBCXX_HAVE_COSHL: u32 = 1;
142pub const _GLIBCXX_HAVE_COSL: u32 = 1;
143pub const _GLIBCXX_HAVE_DECL_STRNLEN: u32 = 1;
144pub const _GLIBCXX_HAVE_DIRENT_H: u32 = 1;
145pub const _GLIBCXX_HAVE_DIRFD: u32 = 1;
146pub const _GLIBCXX_HAVE_DLFCN_H: u32 = 1;
147pub const _GLIBCXX_HAVE_ENDIAN_H: u32 = 1;
148pub const _GLIBCXX_HAVE_EXCEPTION_PTR_SINCE_GCC46: u32 = 1;
149pub const _GLIBCXX_HAVE_EXECINFO_H: u32 = 1;
150pub const _GLIBCXX_HAVE_EXPF: u32 = 1;
151pub const _GLIBCXX_HAVE_EXPL: u32 = 1;
152pub const _GLIBCXX_HAVE_FABSF: u32 = 1;
153pub const _GLIBCXX_HAVE_FABSL: u32 = 1;
154pub const _GLIBCXX_HAVE_FCNTL_H: u32 = 1;
155pub const _GLIBCXX_HAVE_FDOPENDIR: u32 = 1;
156pub const _GLIBCXX_HAVE_FENV_H: u32 = 1;
157pub const _GLIBCXX_HAVE_FINITE: u32 = 1;
158pub const _GLIBCXX_HAVE_FINITEF: u32 = 1;
159pub const _GLIBCXX_HAVE_FINITEL: u32 = 1;
160pub const _GLIBCXX_HAVE_FLOAT_H: u32 = 1;
161pub const _GLIBCXX_HAVE_FLOORF: u32 = 1;
162pub const _GLIBCXX_HAVE_FLOORL: u32 = 1;
163pub const _GLIBCXX_HAVE_FMODF: u32 = 1;
164pub const _GLIBCXX_HAVE_FMODL: u32 = 1;
165pub const _GLIBCXX_HAVE_FREXPF: u32 = 1;
166pub const _GLIBCXX_HAVE_FREXPL: u32 = 1;
167pub const _GLIBCXX_HAVE_GETENTROPY: u32 = 1;
168pub const _GLIBCXX_HAVE_GETIPINFO: u32 = 1;
169pub const _GLIBCXX_HAVE_GETS: u32 = 1;
170pub const _GLIBCXX_HAVE_HYPOT: u32 = 1;
171pub const _GLIBCXX_HAVE_HYPOTF: u32 = 1;
172pub const _GLIBCXX_HAVE_HYPOTL: u32 = 1;
173pub const _GLIBCXX_HAVE_ICONV: u32 = 1;
174pub const _GLIBCXX_HAVE_INTTYPES_H: u32 = 1;
175pub const _GLIBCXX_HAVE_ISINFF: u32 = 1;
176pub const _GLIBCXX_HAVE_ISINFL: u32 = 1;
177pub const _GLIBCXX_HAVE_ISNANF: u32 = 1;
178pub const _GLIBCXX_HAVE_ISNANL: u32 = 1;
179pub const _GLIBCXX_HAVE_ISWBLANK: u32 = 1;
180pub const _GLIBCXX_HAVE_LC_MESSAGES: u32 = 1;
181pub const _GLIBCXX_HAVE_LDEXPF: u32 = 1;
182pub const _GLIBCXX_HAVE_LDEXPL: u32 = 1;
183pub const _GLIBCXX_HAVE_LIBINTL_H: u32 = 1;
184pub const _GLIBCXX_HAVE_LIMIT_AS: u32 = 1;
185pub const _GLIBCXX_HAVE_LIMIT_DATA: u32 = 1;
186pub const _GLIBCXX_HAVE_LIMIT_FSIZE: u32 = 1;
187pub const _GLIBCXX_HAVE_LIMIT_RSS: u32 = 1;
188pub const _GLIBCXX_HAVE_LIMIT_VMEM: u32 = 0;
189pub const _GLIBCXX_HAVE_LINK: u32 = 1;
190pub const _GLIBCXX_HAVE_LINK_H: u32 = 1;
191pub const _GLIBCXX_HAVE_LINUX_FUTEX: u32 = 1;
192pub const _GLIBCXX_HAVE_LINUX_RANDOM_H: u32 = 1;
193pub const _GLIBCXX_HAVE_LINUX_TYPES_H: u32 = 1;
194pub const _GLIBCXX_HAVE_LOCALE_H: u32 = 1;
195pub const _GLIBCXX_HAVE_LOG10F: u32 = 1;
196pub const _GLIBCXX_HAVE_LOG10L: u32 = 1;
197pub const _GLIBCXX_HAVE_LOGF: u32 = 1;
198pub const _GLIBCXX_HAVE_LOGL: u32 = 1;
199pub const _GLIBCXX_HAVE_LSEEK: u32 = 1;
200pub const _GLIBCXX_HAVE_MBSTATE_T: u32 = 1;
201pub const _GLIBCXX_HAVE_MEMALIGN: u32 = 1;
202pub const _GLIBCXX_HAVE_MEMORY_H: u32 = 1;
203pub const _GLIBCXX_HAVE_MODF: u32 = 1;
204pub const _GLIBCXX_HAVE_MODFF: u32 = 1;
205pub const _GLIBCXX_HAVE_MODFL: u32 = 1;
206pub const _GLIBCXX_HAVE_NETDB_H: u32 = 1;
207pub const _GLIBCXX_HAVE_NETINET_IN_H: u32 = 1;
208pub const _GLIBCXX_HAVE_NETINET_TCP_H: u32 = 1;
209pub const _GLIBCXX_HAVE_OPENAT: u32 = 1;
210pub const _GLIBCXX_HAVE_O_NONBLOCK: u32 = 1;
211pub const _GLIBCXX_HAVE_POLL: u32 = 1;
212pub const _GLIBCXX_HAVE_POLL_H: u32 = 1;
213pub const _GLIBCXX_HAVE_POSIX_MEMALIGN: u32 = 1;
214pub const _GLIBCXX_HAVE_POSIX_SEMAPHORE: u32 = 1;
215pub const _GLIBCXX_HAVE_POWF: u32 = 1;
216pub const _GLIBCXX_HAVE_POWL: u32 = 1;
217pub const _GLIBCXX_HAVE_QUICK_EXIT: u32 = 1;
218pub const _GLIBCXX_HAVE_READLINK: u32 = 1;
219pub const _GLIBCXX_HAVE_SECURE_GETENV: u32 = 1;
220pub const _GLIBCXX_HAVE_SETENV: u32 = 1;
221pub const _GLIBCXX_HAVE_SINCOS: u32 = 1;
222pub const _GLIBCXX_HAVE_SINCOSF: u32 = 1;
223pub const _GLIBCXX_HAVE_SINCOSL: u32 = 1;
224pub const _GLIBCXX_HAVE_SINF: u32 = 1;
225pub const _GLIBCXX_HAVE_SINHF: u32 = 1;
226pub const _GLIBCXX_HAVE_SINHL: u32 = 1;
227pub const _GLIBCXX_HAVE_SINL: u32 = 1;
228pub const _GLIBCXX_HAVE_SOCKATMARK: u32 = 1;
229pub const _GLIBCXX_HAVE_SQRTF: u32 = 1;
230pub const _GLIBCXX_HAVE_SQRTL: u32 = 1;
231pub const _GLIBCXX_HAVE_STACKTRACE: u32 = 1;
232pub const _GLIBCXX_HAVE_STDALIGN_H: u32 = 1;
233pub const _GLIBCXX_HAVE_STDBOOL_H: u32 = 1;
234pub const _GLIBCXX_HAVE_STDINT_H: u32 = 1;
235pub const _GLIBCXX_HAVE_STDLIB_H: u32 = 1;
236pub const _GLIBCXX_HAVE_STRERROR_L: u32 = 1;
237pub const _GLIBCXX_HAVE_STRERROR_R: u32 = 1;
238pub const _GLIBCXX_HAVE_STRINGS_H: u32 = 1;
239pub const _GLIBCXX_HAVE_STRING_H: u32 = 1;
240pub const _GLIBCXX_HAVE_STRTOF: u32 = 1;
241pub const _GLIBCXX_HAVE_STRTOLD: u32 = 1;
242pub const _GLIBCXX_HAVE_STRUCT_DIRENT_D_TYPE: u32 = 1;
243pub const _GLIBCXX_HAVE_STRXFRM_L: u32 = 1;
244pub const _GLIBCXX_HAVE_SYMLINK: u32 = 1;
245pub const _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT: u32 = 1;
246pub const _GLIBCXX_HAVE_SYS_IOCTL_H: u32 = 1;
247pub const _GLIBCXX_HAVE_SYS_IPC_H: u32 = 1;
248pub const _GLIBCXX_HAVE_SYS_MMAN_H: u32 = 1;
249pub const _GLIBCXX_HAVE_SYS_PARAM_H: u32 = 1;
250pub const _GLIBCXX_HAVE_SYS_RESOURCE_H: u32 = 1;
251pub const _GLIBCXX_HAVE_SYS_SDT_H: u32 = 1;
252pub const _GLIBCXX_HAVE_SYS_SEM_H: u32 = 1;
253pub const _GLIBCXX_HAVE_SYS_SOCKET_H: u32 = 1;
254pub const _GLIBCXX_HAVE_SYS_STATVFS_H: u32 = 1;
255pub const _GLIBCXX_HAVE_SYS_STAT_H: u32 = 1;
256pub const _GLIBCXX_HAVE_SYS_SYSINFO_H: u32 = 1;
257pub const _GLIBCXX_HAVE_SYS_TIME_H: u32 = 1;
258pub const _GLIBCXX_HAVE_SYS_TYPES_H: u32 = 1;
259pub const _GLIBCXX_HAVE_SYS_UIO_H: u32 = 1;
260pub const _GLIBCXX_HAVE_S_ISREG: u32 = 1;
261pub const _GLIBCXX_HAVE_TANF: u32 = 1;
262pub const _GLIBCXX_HAVE_TANHF: u32 = 1;
263pub const _GLIBCXX_HAVE_TANHL: u32 = 1;
264pub const _GLIBCXX_HAVE_TANL: u32 = 1;
265pub const _GLIBCXX_HAVE_TGMATH_H: u32 = 1;
266pub const _GLIBCXX_HAVE_TIMESPEC_GET: u32 = 1;
267pub const _GLIBCXX_HAVE_TLS: u32 = 1;
268pub const _GLIBCXX_HAVE_TRUNCATE: u32 = 1;
269pub const _GLIBCXX_HAVE_UCHAR_H: u32 = 1;
270pub const _GLIBCXX_HAVE_UNISTD_H: u32 = 1;
271pub const _GLIBCXX_HAVE_UNLINKAT: u32 = 1;
272pub const _GLIBCXX_HAVE_USELOCALE: u32 = 1;
273pub const _GLIBCXX_HAVE_UTIME_H: u32 = 1;
274pub const _GLIBCXX_HAVE_VFWSCANF: u32 = 1;
275pub const _GLIBCXX_HAVE_VSWSCANF: u32 = 1;
276pub const _GLIBCXX_HAVE_VWSCANF: u32 = 1;
277pub const _GLIBCXX_HAVE_WCHAR_H: u32 = 1;
278pub const _GLIBCXX_HAVE_WCSTOF: u32 = 1;
279pub const _GLIBCXX_HAVE_WCTYPE_H: u32 = 1;
280pub const _GLIBCXX_HAVE_WRITEV: u32 = 1;
281pub const _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL: u32 = 1;
282pub const _GLIBCXX_LT_OBJDIR: &[u8; 7] = b".libs/\0";
283pub const _GLIBCXX_PACKAGE_BUGREPORT: &[u8; 1] = b"\0";
284pub const _GLIBCXX_PACKAGE_NAME: &[u8; 15] = b"package-unused\0";
285pub const _GLIBCXX_PACKAGE_STRING: &[u8; 30] = b"package-unused version-unused\0";
286pub const _GLIBCXX_PACKAGE_TARNAME: &[u8; 10] = b"libstdc++\0";
287pub const _GLIBCXX_PACKAGE_URL: &[u8; 1] = b"\0";
288pub const _GLIBCXX_PACKAGE__GLIBCXX_VERSION: &[u8; 15] = b"version-unused\0";
289pub const _GLIBCXX_STDC_HEADERS: u32 = 1;
290pub const _GLIBCXX_DARWIN_USE_64_BIT_INODE: u32 = 1;
291pub const _GLIBCXX11_USE_C99_COMPLEX: u32 = 1;
292pub const _GLIBCXX11_USE_C99_MATH: u32 = 1;
293pub const _GLIBCXX11_USE_C99_STDIO: u32 = 1;
294pub const _GLIBCXX11_USE_C99_STDLIB: u32 = 1;
295pub const _GLIBCXX11_USE_C99_WCHAR: u32 = 1;
296pub const _GLIBCXX98_USE_C99_COMPLEX: u32 = 1;
297pub const _GLIBCXX98_USE_C99_MATH: u32 = 1;
298pub const _GLIBCXX98_USE_C99_STDIO: u32 = 1;
299pub const _GLIBCXX98_USE_C99_STDLIB: u32 = 1;
300pub const _GLIBCXX98_USE_C99_WCHAR: u32 = 1;
301pub const _GLIBCXX_ATOMIC_BUILTINS: u32 = 1;
302pub const _GLIBCXX_CAN_ALIGNAS_DESTRUCTIVE_SIZE: u32 = 1;
303pub const _GLIBCXX_FULLY_DYNAMIC_STRING: u32 = 0;
304pub const _GLIBCXX_HAS_GTHREADS: u32 = 1;
305pub const _GLIBCXX_RES_LIMITS: u32 = 1;
306pub const _GLIBCXX_STDIO_EOF: i32 = -1;
307pub const _GLIBCXX_STDIO_SEEK_CUR: u32 = 1;
308pub const _GLIBCXX_STDIO_SEEK_END: u32 = 2;
309pub const _GLIBCXX_SYMVER: u32 = 1;
310pub const _GLIBCXX_SYMVER_GNU: u32 = 1;
311pub const _GLIBCXX_USE_C11_UCHAR_CXX11: u32 = 1;
312pub const _GLIBCXX_USE_C99: u32 = 1;
313pub const _GLIBCXX_USE_C99_COMPLEX_ARC: u32 = 1;
314pub const _GLIBCXX_USE_C99_COMPLEX_TR1: u32 = 1;
315pub const _GLIBCXX_USE_C99_CTYPE: u32 = 1;
316pub const _GLIBCXX_USE_C99_CTYPE_TR1: u32 = 1;
317pub const _GLIBCXX_USE_C99_FENV: u32 = 1;
318pub const _GLIBCXX_USE_C99_FENV_TR1: u32 = 1;
319pub const _GLIBCXX_USE_C99_INTTYPES: u32 = 1;
320pub const _GLIBCXX_USE_C99_INTTYPES_TR1: u32 = 1;
321pub const _GLIBCXX_USE_C99_INTTYPES_WCHAR_T: u32 = 1;
322pub const _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1: u32 = 1;
323pub const _GLIBCXX_USE_C99_MATH_FUNCS: u32 = 1;
324pub const _GLIBCXX_USE_C99_MATH_TR1: u32 = 1;
325pub const _GLIBCXX_USE_C99_STDINT: u32 = 1;
326pub const _GLIBCXX_USE_C99_STDINT_TR1: u32 = 1;
327pub const _GLIBCXX_USE_CHDIR: u32 = 1;
328pub const _GLIBCXX_USE_CHMOD: u32 = 1;
329pub const _GLIBCXX_USE_CLOCK_MONOTONIC: u32 = 1;
330pub const _GLIBCXX_USE_CLOCK_REALTIME: u32 = 1;
331pub const _GLIBCXX_USE_DECIMAL_FLOAT: u32 = 1;
332pub const _GLIBCXX_USE_DEV_RANDOM: u32 = 1;
333pub const _GLIBCXX_USE_FCHMOD: u32 = 1;
334pub const _GLIBCXX_USE_FCHMODAT: u32 = 1;
335pub const _GLIBCXX_USE_FSEEKO_FTELLO: u32 = 1;
336pub const _GLIBCXX_USE_GETCWD: u32 = 1;
337pub const _GLIBCXX_USE_GETTIMEOFDAY: u32 = 1;
338pub const _GLIBCXX_USE_GET_NPROCS: u32 = 1;
339pub const _GLIBCXX_USE_INIT_PRIORITY_ATTRIBUTE: u32 = 1;
340pub const _GLIBCXX_USE_LFS: u32 = 1;
341pub const _GLIBCXX_USE_LONG_LONG: u32 = 1;
342pub const _GLIBCXX_USE_LSTAT: u32 = 1;
343pub const _GLIBCXX_USE_MKDIR: u32 = 1;
344pub const _GLIBCXX_USE_NANOSLEEP: u32 = 1;
345pub const _GLIBCXX_USE_NLS: u32 = 1;
346pub const _GLIBCXX_USE_NL_LANGINFO_L: u32 = 1;
347pub const _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT: u32 = 1;
348pub const _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK: u32 = 1;
349pub const _GLIBCXX_USE_PTHREAD_RWLOCK_T: u32 = 1;
350pub const _GLIBCXX_USE_RANDOM_TR1: u32 = 1;
351pub const _GLIBCXX_USE_REALPATH: u32 = 1;
352pub const _GLIBCXX_USE_SCHED_YIELD: u32 = 1;
353pub const _GLIBCXX_USE_SC_NPROCESSORS_ONLN: u32 = 1;
354pub const _GLIBCXX_USE_SENDFILE: u32 = 1;
355pub const _GLIBCXX_USE_STRUCT_TM_TM_ZONE: u32 = 1;
356pub const _GLIBCXX_USE_ST_MTIM: u32 = 1;
357pub const _GLIBCXX_USE_TMPNAM: u32 = 1;
358pub const _GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_CXX20: u32 = 1;
359pub const _GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_FCHAR8_T: u32 = 1;
360pub const _GLIBCXX_USE_UTIME: u32 = 1;
361pub const _GLIBCXX_USE_UTIMENSAT: u32 = 1;
362pub const _GLIBCXX_USE_WCHAR_T: u32 = 1;
363pub const _GLIBCXX_VERBOSE: u32 = 1;
364pub const _GLIBCXX_X86_RDRAND: u32 = 1;
365pub const _GLIBCXX_X86_RDSEED: u32 = 1;
366pub const _GLIBCXX_ZONEINFO_DIR: &[u8; 20] = b"/usr/share/zoneinfo\0";
367pub const _GTHREAD_USE_MUTEX_TIMEDLOCK: u32 = 1;
368pub const _STDINT_H: u32 = 1;
369pub const __GLIBC_USE_LIB_EXT2: u32 = 1;
370pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 1;
371pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23: u32 = 1;
372pub const __GLIBC_USE_IEC_60559_EXT: u32 = 1;
373pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 1;
374pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23: u32 = 1;
375pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 1;
376pub const _BITS_TYPES_H: u32 = 1;
377pub const _BITS_TYPESIZES_H: u32 = 1;
378pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
379pub const __INO_T_MATCHES_INO64_T: u32 = 1;
380pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
381pub const __STATFS_MATCHES_STATFS64: u32 = 1;
382pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
383pub const __FD_SETSIZE: u32 = 1024;
384pub const _BITS_TIME64_H: u32 = 1;
385pub const _BITS_WCHAR_H: u32 = 1;
386pub const _BITS_STDINT_INTN_H: u32 = 1;
387pub const _BITS_STDINT_UINTN_H: u32 = 1;
388pub const _BITS_STDINT_LEAST_H: u32 = 1;
389pub const INT8_MIN: i32 = -128;
390pub const INT16_MIN: i32 = -32768;
391pub const INT32_MIN: i32 = -2147483648;
392pub const INT8_MAX: u32 = 127;
393pub const INT16_MAX: u32 = 32767;
394pub const INT32_MAX: u32 = 2147483647;
395pub const UINT8_MAX: u32 = 255;
396pub const UINT16_MAX: u32 = 65535;
397pub const UINT32_MAX: u32 = 4294967295;
398pub const INT_LEAST8_MIN: i32 = -128;
399pub const INT_LEAST16_MIN: i32 = -32768;
400pub const INT_LEAST32_MIN: i32 = -2147483648;
401pub const INT_LEAST8_MAX: u32 = 127;
402pub const INT_LEAST16_MAX: u32 = 32767;
403pub const INT_LEAST32_MAX: u32 = 2147483647;
404pub const UINT_LEAST8_MAX: u32 = 255;
405pub const UINT_LEAST16_MAX: u32 = 65535;
406pub const UINT_LEAST32_MAX: u32 = 4294967295;
407pub const INT_FAST8_MIN: i32 = -128;
408pub const INT_FAST16_MIN: i64 = -9223372036854775808;
409pub const INT_FAST32_MIN: i64 = -9223372036854775808;
410pub const INT_FAST8_MAX: u32 = 127;
411pub const INT_FAST16_MAX: u64 = 9223372036854775807;
412pub const INT_FAST32_MAX: u64 = 9223372036854775807;
413pub const UINT_FAST8_MAX: u32 = 255;
414pub const UINT_FAST16_MAX: i32 = -1;
415pub const UINT_FAST32_MAX: i32 = -1;
416pub const INTPTR_MIN: i64 = -9223372036854775808;
417pub const INTPTR_MAX: u64 = 9223372036854775807;
418pub const UINTPTR_MAX: i32 = -1;
419pub const PTRDIFF_MIN: i64 = -9223372036854775808;
420pub const PTRDIFF_MAX: u64 = 9223372036854775807;
421pub const SIG_ATOMIC_MIN: i32 = -2147483648;
422pub const SIG_ATOMIC_MAX: u32 = 2147483647;
423pub const SIZE_MAX: i32 = -1;
424pub const WINT_MIN: u32 = 0;
425pub const WINT_MAX: u32 = 4294967295;
426pub const INT8_WIDTH: u32 = 8;
427pub const UINT8_WIDTH: u32 = 8;
428pub const INT16_WIDTH: u32 = 16;
429pub const UINT16_WIDTH: u32 = 16;
430pub const INT32_WIDTH: u32 = 32;
431pub const UINT32_WIDTH: u32 = 32;
432pub const INT64_WIDTH: u32 = 64;
433pub const UINT64_WIDTH: u32 = 64;
434pub const INT_LEAST8_WIDTH: u32 = 8;
435pub const UINT_LEAST8_WIDTH: u32 = 8;
436pub const INT_LEAST16_WIDTH: u32 = 16;
437pub const UINT_LEAST16_WIDTH: u32 = 16;
438pub const INT_LEAST32_WIDTH: u32 = 32;
439pub const UINT_LEAST32_WIDTH: u32 = 32;
440pub const INT_LEAST64_WIDTH: u32 = 64;
441pub const UINT_LEAST64_WIDTH: u32 = 64;
442pub const INT_FAST8_WIDTH: u32 = 8;
443pub const UINT_FAST8_WIDTH: u32 = 8;
444pub const INT_FAST16_WIDTH: u32 = 64;
445pub const UINT_FAST16_WIDTH: u32 = 64;
446pub const INT_FAST32_WIDTH: u32 = 64;
447pub const UINT_FAST32_WIDTH: u32 = 64;
448pub const INT_FAST64_WIDTH: u32 = 64;
449pub const UINT_FAST64_WIDTH: u32 = 64;
450pub const INTPTR_WIDTH: u32 = 64;
451pub const UINTPTR_WIDTH: u32 = 64;
452pub const INTMAX_WIDTH: u32 = 64;
453pub const UINTMAX_WIDTH: u32 = 64;
454pub const PTRDIFF_WIDTH: u32 = 64;
455pub const SIG_ATOMIC_WIDTH: u32 = 32;
456pub const SIZE_WIDTH: u32 = 64;
457pub const WCHAR_WIDTH: u32 = 32;
458pub const WINT_WIDTH: u32 = 32;
459pub type std_nullptr_t = *const ::std::os::raw::c_void;
460unsafe extern "C" {
461 #[link_name = "\u{1}_ZSt21__glibcxx_assert_failPKciS0_S0_"]
462 pub fn std___glibcxx_assert_fail(
463 __file: *const ::std::os::raw::c_char,
464 __line: ::std::os::raw::c_int,
465 __function: *const ::std::os::raw::c_char,
466 __condition: *const ::std::os::raw::c_char,
467 ) -> !;
468}
469pub type __u_char = ::std::os::raw::c_uchar;
470pub type __u_short = ::std::os::raw::c_ushort;
471pub type __u_int = ::std::os::raw::c_uint;
472pub type __u_long = ::std::os::raw::c_ulong;
473pub type __int8_t = ::std::os::raw::c_schar;
474pub type __uint8_t = ::std::os::raw::c_uchar;
475pub type __int16_t = ::std::os::raw::c_short;
476pub type __uint16_t = ::std::os::raw::c_ushort;
477pub type __int32_t = ::std::os::raw::c_int;
478pub type __uint32_t = ::std::os::raw::c_uint;
479pub type __int64_t = ::std::os::raw::c_long;
480pub type __uint64_t = ::std::os::raw::c_ulong;
481pub type __int_least8_t = __int8_t;
482pub type __uint_least8_t = __uint8_t;
483pub type __int_least16_t = __int16_t;
484pub type __uint_least16_t = __uint16_t;
485pub type __int_least32_t = __int32_t;
486pub type __uint_least32_t = __uint32_t;
487pub type __int_least64_t = __int64_t;
488pub type __uint_least64_t = __uint64_t;
489pub type __quad_t = ::std::os::raw::c_long;
490pub type __u_quad_t = ::std::os::raw::c_ulong;
491pub type __intmax_t = ::std::os::raw::c_long;
492pub type __uintmax_t = ::std::os::raw::c_ulong;
493pub type __dev_t = ::std::os::raw::c_ulong;
494pub type __uid_t = ::std::os::raw::c_uint;
495pub type __gid_t = ::std::os::raw::c_uint;
496pub type __ino_t = ::std::os::raw::c_ulong;
497pub type __ino64_t = ::std::os::raw::c_ulong;
498pub type __mode_t = ::std::os::raw::c_uint;
499pub type __nlink_t = ::std::os::raw::c_ulong;
500pub type __off_t = ::std::os::raw::c_long;
501pub type __off64_t = ::std::os::raw::c_long;
502pub type __pid_t = ::std::os::raw::c_int;
503#[repr(C)]
504#[derive(Debug, Copy, Clone)]
505pub struct __fsid_t {
506 pub __val: [::std::os::raw::c_int; 2usize],
507}
508#[allow(clippy::unnecessary_operation, clippy::identity_op)]
509const _: () = {
510 ["Size of __fsid_t"][::std::mem::size_of::<__fsid_t>() - 8usize];
511 ["Alignment of __fsid_t"][::std::mem::align_of::<__fsid_t>() - 4usize];
512 ["Offset of field: __fsid_t::__val"][::std::mem::offset_of!(__fsid_t, __val) - 0usize];
513};
514pub type __clock_t = ::std::os::raw::c_long;
515pub type __rlim_t = ::std::os::raw::c_ulong;
516pub type __rlim64_t = ::std::os::raw::c_ulong;
517pub type __id_t = ::std::os::raw::c_uint;
518pub type __time_t = ::std::os::raw::c_long;
519pub type __useconds_t = ::std::os::raw::c_uint;
520pub type __suseconds_t = ::std::os::raw::c_long;
521pub type __suseconds64_t = ::std::os::raw::c_long;
522pub type __daddr_t = ::std::os::raw::c_int;
523pub type __key_t = ::std::os::raw::c_int;
524pub type __clockid_t = ::std::os::raw::c_int;
525pub type __timer_t = *mut ::std::os::raw::c_void;
526pub type __blksize_t = ::std::os::raw::c_long;
527pub type __blkcnt_t = ::std::os::raw::c_long;
528pub type __blkcnt64_t = ::std::os::raw::c_long;
529pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
530pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
531pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
532pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
533pub type __fsword_t = ::std::os::raw::c_long;
534pub type __ssize_t = ::std::os::raw::c_long;
535pub type __syscall_slong_t = ::std::os::raw::c_long;
536pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
537pub type __loff_t = __off64_t;
538pub type __caddr_t = *mut ::std::os::raw::c_char;
539pub type __intptr_t = ::std::os::raw::c_long;
540pub type __socklen_t = ::std::os::raw::c_uint;
541pub type __sig_atomic_t = ::std::os::raw::c_int;
542pub type int_least8_t = __int_least8_t;
543pub type int_least16_t = __int_least16_t;
544pub type int_least32_t = __int_least32_t;
545pub type int_least64_t = __int_least64_t;
546pub type uint_least8_t = __uint_least8_t;
547pub type uint_least16_t = __uint_least16_t;
548pub type uint_least32_t = __uint_least32_t;
549pub type uint_least64_t = __uint_least64_t;
550pub type int_fast8_t = ::std::os::raw::c_schar;
551pub type int_fast16_t = ::std::os::raw::c_long;
552pub type int_fast32_t = ::std::os::raw::c_long;
553pub type int_fast64_t = ::std::os::raw::c_long;
554pub type uint_fast8_t = ::std::os::raw::c_uchar;
555pub type uint_fast16_t = ::std::os::raw::c_ulong;
556pub type uint_fast32_t = ::std::os::raw::c_ulong;
557pub type uint_fast64_t = ::std::os::raw::c_ulong;
558pub type intmax_t = __intmax_t;
559pub type uintmax_t = __uintmax_t;
560#[doc = " Defines an alias representing the error codes for the libCZIApi-module.\n In general, values greater than zero indicate an error condition; and values less\n or equal to zero indicate proper operation."]
561pub type LibCZIApiErrorCode = ::std::os::raw::c_int;
562unsafe extern "C" {
563 #[doc = " The operation completed successfully."]
564 #[link_name = "\u{1}_ZL22LibCZIApi_ErrorCode_OK"]
565 pub static LibCZIApi_ErrorCode_OK: LibCZIApiErrorCode;
566}
567unsafe extern "C" {
568 #[doc = " An invalid argument was supplied to the function."]
569 #[link_name = "\u{1}_ZL35LibCZIApi_ErrorCode_InvalidArgument"]
570 pub static LibCZIApi_ErrorCode_InvalidArgument: LibCZIApiErrorCode;
571}
572unsafe extern "C" {
573 #[doc = " An invalid handle was supplied to the function (i.e. a handle which is either a bogus value or a handle which has already been destroyed)."]
574 #[link_name = "\u{1}_ZL33LibCZIApi_ErrorCode_InvalidHandle"]
575 pub static LibCZIApi_ErrorCode_InvalidHandle: LibCZIApiErrorCode;
576}
577unsafe extern "C" {
578 #[doc = " The operation failed due to an out-of-memory condition."]
579 #[link_name = "\u{1}_ZL31LibCZIApi_ErrorCode_OutOfMemory"]
580 pub static LibCZIApi_ErrorCode_OutOfMemory: LibCZIApiErrorCode;
581}
582unsafe extern "C" {
583 #[doc = " A supplied index was out of range."]
584 #[link_name = "\u{1}_ZL35LibCZIApi_ErrorCode_IndexOutOfRange"]
585 pub static LibCZIApi_ErrorCode_IndexOutOfRange: LibCZIApiErrorCode;
586}
587unsafe extern "C" {
588 #[doc = " A semantic error in using Lock/Unlock methods (e.g. of the bitmap object) was detected. Reasons could be\n an unbalanced number of Lock/Unlock calls, or the object was destroyed with a lock still held."]
589 #[link_name = "\u{1}_ZL46LibCZIApi_ErrorCode_LockUnlockSemanticViolated"]
590 pub static LibCZIApi_ErrorCode_LockUnlockSemanticViolated: LibCZIApiErrorCode;
591}
592unsafe extern "C" {
593 #[doc = " An unspecified error occurred."]
594 #[link_name = "\u{1}_ZL36LibCZIApi_ErrorCode_UnspecifiedError"]
595 pub static LibCZIApi_ErrorCode_UnspecifiedError: LibCZIApiErrorCode;
596}
597#[doc = " Defines an alias representing a \"handle to some object (created and used by the libCZIApi)\"."]
598pub type ObjectHandle = ::std::os::raw::c_long;
599unsafe extern "C" {
600 #[doc = " (Immutable) Reserved value indicating an invalid object handle."]
601 #[link_name = "\u{1}_ZL20kInvalidObjectHandle"]
602 pub static kInvalidObjectHandle: ObjectHandle;
603}
604#[doc = " Defines an alias representing the handle of a CZI-reader object."]
605pub type CziReaderObjectHandle = ObjectHandle;
606#[doc = " Defines an alias representing the handle of a sub-block object."]
607pub type SubBlockObjectHandle = ObjectHandle;
608#[doc = " Defines an alias representing the handle of an input stream object."]
609pub type InputStreamObjectHandle = ObjectHandle;
610#[doc = " Defines an alias representing the handle of an output stream object."]
611pub type OutputStreamObjectHandle = ObjectHandle;
612#[doc = " Defines an alias representing the handle of a memory allocation object - which is \"a pointer to a memory block\", which must be\n freed with 'libCZI_Free'.\n TODO(JBL): this is not really used so far, should be removed I guess."]
613pub type MemoryAllocationObjectHandle = ObjectHandle;
614#[doc = " Defines an alias representing the handle of a bitmap object."]
615pub type BitmapObjectHandle = ObjectHandle;
616#[doc = " Defines an alias representing the handle of a metadata segment object."]
617pub type MetadataSegmentObjectHandle = ObjectHandle;
618#[doc = " Defines an alias representing the handle of an attachment object."]
619pub type AttachmentObjectHandle = ObjectHandle;
620#[doc = " Defines an alias representing the handle of a writer object."]
621pub type CziWriterObjectHandle = ObjectHandle;
622#[doc = " Defines an alias representing the handle of a single-channel-scaling-tile-accessor."]
623pub type SingleChannelScalingTileAccessorObjectHandle = ObjectHandle;
624#[doc = " Defines an alias representing the handle of a \"document info\" object."]
625pub type CziDocumentInfoHandle = ObjectHandle;
626#[doc = " Defines an alias representing the handle of a \"display settings\" object."]
627pub type DisplaySettingsHandle = ObjectHandle;
628#[doc = " Defines an alias representing the handle of a \"channel display settings\" object."]
629pub type ChannelDisplaySettingsHandle = ObjectHandle;
630#[doc = " This struct contains the version information of the libCZIApi-library. For versioning libCZI, SemVer2 (<https://semver.org/>) is used.\n Note that the value of the tweak version number does not have a meaning (as far as SemVer2 is concerned)."]
631#[repr(C)]
632#[derive(Debug, Copy, Clone)]
633pub struct LibCZIVersionInfoInterop {
634 #[doc = "< The major version number."]
635 pub major: i32,
636 #[doc = "< The minor version number."]
637 pub minor: i32,
638 #[doc = "< The patch version number."]
639 pub patch: i32,
640 #[doc = "< The tweak version number."]
641 pub tweak: i32,
642}
643#[allow(clippy::unnecessary_operation, clippy::identity_op)]
644const _: () = {
645 ["Size of LibCZIVersionInfoInterop"]
646 [::std::mem::size_of::<LibCZIVersionInfoInterop>() - 16usize];
647 ["Alignment of LibCZIVersionInfoInterop"]
648 [::std::mem::align_of::<LibCZIVersionInfoInterop>() - 4usize];
649 ["Offset of field: LibCZIVersionInfoInterop::major"]
650 [::std::mem::offset_of!(LibCZIVersionInfoInterop, major) - 0usize];
651 ["Offset of field: LibCZIVersionInfoInterop::minor"]
652 [::std::mem::offset_of!(LibCZIVersionInfoInterop, minor) - 4usize];
653 ["Offset of field: LibCZIVersionInfoInterop::patch"]
654 [::std::mem::offset_of!(LibCZIVersionInfoInterop, patch) - 8usize];
655 ["Offset of field: LibCZIVersionInfoInterop::tweak"]
656 [::std::mem::offset_of!(LibCZIVersionInfoInterop, tweak) - 12usize];
657};
658#[doc = " This struct gives information about the build of the libCZIApi-library.\n Note that all strings must be freed by the caller (using libCZI_Free)."]
659#[repr(C, packed(4))]
660#[derive(Debug, Copy, Clone)]
661pub struct LibCZIBuildInformationInterop {
662 #[doc = "< If non-null, the compiler identification. This is a free-form string. This string must be freed by the caller (using libCZI_Free)."]
663 pub compilerIdentification: *mut ::std::os::raw::c_char,
664 #[doc = "< If non-null, the URL of the repository. This string must be freed by the caller (using libCZI_Free)."]
665 pub repositoryUrl: *mut ::std::os::raw::c_char,
666 #[doc = "< If non-null, the branch of the repository. This string must be freed by the caller (using libCZI_Free)."]
667 pub repositoryBranch: *mut ::std::os::raw::c_char,
668 #[doc = "< If non-null, the tag of the repository. This string must be freed by the caller (using libCZI_Free)."]
669 pub repositoryTag: *mut ::std::os::raw::c_char,
670}
671#[allow(clippy::unnecessary_operation, clippy::identity_op)]
672const _: () = {
673 ["Size of LibCZIBuildInformationInterop"]
674 [::std::mem::size_of::<LibCZIBuildInformationInterop>() - 32usize];
675 ["Alignment of LibCZIBuildInformationInterop"]
676 [::std::mem::align_of::<LibCZIBuildInformationInterop>() - 4usize];
677 ["Offset of field: LibCZIBuildInformationInterop::compilerIdentification"]
678 [::std::mem::offset_of!(LibCZIBuildInformationInterop, compilerIdentification) - 0usize];
679 ["Offset of field: LibCZIBuildInformationInterop::repositoryUrl"]
680 [::std::mem::offset_of!(LibCZIBuildInformationInterop, repositoryUrl) - 8usize];
681 ["Offset of field: LibCZIBuildInformationInterop::repositoryBranch"]
682 [::std::mem::offset_of!(LibCZIBuildInformationInterop, repositoryBranch) - 16usize];
683 ["Offset of field: LibCZIBuildInformationInterop::repositoryTag"]
684 [::std::mem::offset_of!(LibCZIBuildInformationInterop, repositoryTag) - 24usize];
685};
686#[repr(C, packed(4))]
687#[derive(Debug, Copy, Clone)]
688pub struct InputStreamClassInfoInterop {
689 #[doc = "< The name of the input stream class. This is a free-form string. This string must be freed by the caller (using libCZI_Free)."]
690 pub name: *mut ::std::os::raw::c_char,
691 #[doc = "< The description of the input stream class. This is a free-form string. This string must be freed by the caller (using libCZI_Free)."]
692 pub description: *mut ::std::os::raw::c_char,
693}
694#[allow(clippy::unnecessary_operation, clippy::identity_op)]
695const _: () = {
696 ["Size of InputStreamClassInfoInterop"]
697 [::std::mem::size_of::<InputStreamClassInfoInterop>() - 16usize];
698 ["Alignment of InputStreamClassInfoInterop"]
699 [::std::mem::align_of::<InputStreamClassInfoInterop>() - 4usize];
700 ["Offset of field: InputStreamClassInfoInterop::name"]
701 [::std::mem::offset_of!(InputStreamClassInfoInterop, name) - 0usize];
702 ["Offset of field: InputStreamClassInfoInterop::description"]
703 [::std::mem::offset_of!(InputStreamClassInfoInterop, description) - 8usize];
704};
705#[doc = "< Error code for \"an unspecified error occurred\"."]
706pub const kStreamErrorCode_UnspecifiedError: ::std::os::raw::c_int = 1;
707#[doc = " This structure gives additional information about an error that occurred in the external stream."]
708#[repr(C, packed(4))]
709#[derive(Debug, Copy, Clone)]
710pub struct ExternalStreamErrorInfoInterop {
711 #[doc = "< The error code - possible values are the constants kStreamErrorCode_XXX."]
712 pub error_code: ::std::os::raw::c_int,
713 #[doc = "< The error message (zero-terminated UTF8-encoded string). This string must be allocated with 'libCZI_AllocateMemory'."]
714 pub error_message: MemoryAllocationObjectHandle,
715}
716#[allow(clippy::unnecessary_operation, clippy::identity_op)]
717const _: () = {
718 ["Size of ExternalStreamErrorInfoInterop"]
719 [::std::mem::size_of::<ExternalStreamErrorInfoInterop>() - 12usize];
720 ["Alignment of ExternalStreamErrorInfoInterop"]
721 [::std::mem::align_of::<ExternalStreamErrorInfoInterop>() - 4usize];
722 ["Offset of field: ExternalStreamErrorInfoInterop::error_code"]
723 [::std::mem::offset_of!(ExternalStreamErrorInfoInterop, error_code) - 0usize];
724 ["Offset of field: ExternalStreamErrorInfoInterop::error_message"]
725 [::std::mem::offset_of!(ExternalStreamErrorInfoInterop, error_message) - 4usize];
726};
727#[doc = " This structure contains information about externally provided functions for reading data from an input stream,\n and it is used to construct a stream-object to be used with libCZI.\n Note on lifetime: The function pointers must remain valid until the function 'close_function' is called. The lifetime\n may extend beyond calling the 'libCZI_ReleaseInputStream' function for the corresponding stream-object."]
728#[repr(C, packed(4))]
729#[derive(Debug, Copy, Clone)]
730pub struct ExternalInputStreamStructInterop {
731 #[doc = " A user parameter which is passed to the callback function."]
732 pub opaque_handle1: ::std::os::raw::c_ulong,
733 #[doc = " A user parameter which is passed to the callback function."]
734 pub opaque_handle2: ::std::os::raw::c_ulong,
735 #[doc = " Function pointer used to read data from the stream.\n This function might be called from an arbitrary thread, and it may be called concurrently from multiple threads.\n A 0 as return value indicates successful operation. A non-zero value indicates a non-recoverable error.\n In case of an error, the error_info parameter must be filled with the error information.\n\n \\param opaque_handle1 The value of the opaque_handle1 field of the ExternalInputStreamStructInterop.\n \\param opaque_handle2 The value of the opaque_handle2 field of the ExternalInputStreamStructInterop.\n \\param offset The offset in the stream where to start reading from.\n \\param [out] pv Pointer to the buffer where the data is to be stored.\n \\param size The size of the buffer (and the number of bytes to be read from the stream).\n \\param [out] ptrBytesRead If non-null, the number of bytes that actually could be read is to be put here.\n \\param [out] error_info If non-null, in case of an error (i.e. return value <>0), this parameter may be used to report additional error information."]
736 pub read_function: ::std::option::Option<
737 unsafe extern "C" fn(
738 opaque_handle1: ::std::os::raw::c_ulong,
739 opaque_handle2: ::std::os::raw::c_ulong,
740 offset: ::std::os::raw::c_ulong,
741 pv: *mut ::std::os::raw::c_void,
742 size: ::std::os::raw::c_ulong,
743 ptrBytesRead: *mut ::std::os::raw::c_ulong,
744 error_info: *mut ExternalStreamErrorInfoInterop,
745 ) -> ::std::os::raw::c_int,
746 >,
747 #[doc = " Function pointer used to close the stream. This function is called only once, and up until this function is called,\n the read_function pointer must remain valid and operational. No assumptions should be made about when this\n function is called, so the implementation must be prepared to handle this function being called at any time\n (but not concurrently with calls to the read_function).\n\n \\param opaque_handle1 The value of the opaque_handle1 field of the ExternalInputStreamStructInterop.\n \\param opaque_handle2 The value of the opaque_handle2 field of the ExternalInputStreamStructInterop."]
748 pub close_function: ::std::option::Option<
749 unsafe extern "C" fn(
750 opaque_handle1: ::std::os::raw::c_ulong,
751 opaque_handle2: ::std::os::raw::c_ulong,
752 ),
753 >,
754}
755#[allow(clippy::unnecessary_operation, clippy::identity_op)]
756const _: () = {
757 ["Size of ExternalInputStreamStructInterop"]
758 [::std::mem::size_of::<ExternalInputStreamStructInterop>() - 32usize];
759 ["Alignment of ExternalInputStreamStructInterop"]
760 [::std::mem::align_of::<ExternalInputStreamStructInterop>() - 4usize];
761 ["Offset of field: ExternalInputStreamStructInterop::opaque_handle1"]
762 [::std::mem::offset_of!(ExternalInputStreamStructInterop, opaque_handle1) - 0usize];
763 ["Offset of field: ExternalInputStreamStructInterop::opaque_handle2"]
764 [::std::mem::offset_of!(ExternalInputStreamStructInterop, opaque_handle2) - 8usize];
765 ["Offset of field: ExternalInputStreamStructInterop::read_function"]
766 [::std::mem::offset_of!(ExternalInputStreamStructInterop, read_function) - 16usize];
767 ["Offset of field: ExternalInputStreamStructInterop::close_function"]
768 [::std::mem::offset_of!(ExternalInputStreamStructInterop, close_function) - 24usize];
769};
770#[doc = " This structure contains information about externally provided functions for writing data to an output stream,\n and it is used to construct a stream-object to be used with libCZI.\n Note on lifetime: The function pointers must remain valid until the function 'close_function' is called. The lifetime\n may extend beyond calling the 'libCZI_ReleaseOutputStream' function for the corresponding stream-object."]
771#[repr(C, packed(4))]
772#[derive(Debug, Copy, Clone)]
773pub struct ExternalOutputStreamStructInterop {
774 #[doc = " A user parameter which is passed to the callback function."]
775 pub opaque_handle1: ::std::os::raw::c_ulong,
776 #[doc = " A user parameter which is passed to the callback function."]
777 pub opaque_handle2: ::std::os::raw::c_ulong,
778 #[doc = " Function pointer used to write data into the stream.\n This function might be called from an arbitrary thread, and it may be called concurrently from multiple threads.\n A 0 as return value indicates successful operation. A non-zero value indicates a non-recoverable error.\n In case of an error, the error_info parameter must be filled with the error information.\n\n \\param opaque_handle1 The value of the opaque_handle1 field of the ExternalOutputStreamStructInterop.\n \\param opaque_handle2 The value of the opaque_handle2 field of the ExternalOutputStreamStructInterop.\n \\param offset The offset in the stream where to start writing to.\n \\param [in] pv Pointer to the buffer with the data to be written.\n \\param size The size of the buffer (and the number of bytes to be written to the stream).\n \\param [out] out_bytes_written If non-null, the number of bytes that actually could be written is to be put here.\n \\param [out] error_info If non-null, in case of an error (i.e. return value <>0), this parameter may be used to report additional error information."]
779 pub write_function: ::std::option::Option<
780 unsafe extern "C" fn(
781 opaque_handle1: ::std::os::raw::c_ulong,
782 opaque_handle2: ::std::os::raw::c_ulong,
783 offset: ::std::os::raw::c_ulong,
784 pv: *const ::std::os::raw::c_void,
785 size: ::std::os::raw::c_ulong,
786 out_bytes_written: *mut ::std::os::raw::c_ulong,
787 error_info: *mut ExternalStreamErrorInfoInterop,
788 ) -> ::std::os::raw::c_int,
789 >,
790 #[doc = " Function pointer used to close the stream. This function is called only once, and up until this function is called,\n the write_function pointer must remain valid and operational. No assumptions should be made about when this\n function is called, so the implementation must be prepared to handle this function being called at any time\n (but not concurrently with calls to the read_function).\n\n \\param opaque_handle1 The value of the opaque_handle1 field of the ExternalOutputStreamStructInterop.\n \\param opaque_handle2 The value of the opaque_handle2 field of the ExternalOutputStreamStructInterop."]
791 pub close_function: ::std::option::Option<
792 unsafe extern "C" fn(
793 opaque_handle1: ::std::os::raw::c_ulong,
794 opaque_handle2: ::std::os::raw::c_ulong,
795 ),
796 >,
797}
798#[allow(clippy::unnecessary_operation, clippy::identity_op)]
799const _: () = {
800 ["Size of ExternalOutputStreamStructInterop"]
801 [::std::mem::size_of::<ExternalOutputStreamStructInterop>() - 32usize];
802 ["Alignment of ExternalOutputStreamStructInterop"]
803 [::std::mem::align_of::<ExternalOutputStreamStructInterop>() - 4usize];
804 ["Offset of field: ExternalOutputStreamStructInterop::opaque_handle1"]
805 [::std::mem::offset_of!(ExternalOutputStreamStructInterop, opaque_handle1) - 0usize];
806 ["Offset of field: ExternalOutputStreamStructInterop::opaque_handle2"]
807 [::std::mem::offset_of!(ExternalOutputStreamStructInterop, opaque_handle2) - 8usize];
808 ["Offset of field: ExternalOutputStreamStructInterop::write_function"]
809 [::std::mem::offset_of!(ExternalOutputStreamStructInterop, write_function) - 16usize];
810 ["Offset of field: ExternalOutputStreamStructInterop::close_function"]
811 [::std::mem::offset_of!(ExternalOutputStreamStructInterop, close_function) - 24usize];
812};
813#[doc = " This structure gather the information needed to create a reader object."]
814#[repr(C, packed(4))]
815#[derive(Debug, Copy, Clone)]
816pub struct ReaderOpenInfoInterop {
817 #[doc = "< The input stream object to use for opening the file."]
818 pub streamObject: InputStreamObjectHandle,
819}
820#[allow(clippy::unnecessary_operation, clippy::identity_op)]
821const _: () = {
822 ["Size of ReaderOpenInfoInterop"][::std::mem::size_of::<ReaderOpenInfoInterop>() - 8usize];
823 ["Alignment of ReaderOpenInfoInterop"]
824 [::std::mem::align_of::<ReaderOpenInfoInterop>() - 4usize];
825 ["Offset of field: ReaderOpenInfoInterop::streamObject"]
826 [::std::mem::offset_of!(ReaderOpenInfoInterop, streamObject) - 0usize];
827};
828#[doc = "< Invalid dimension index."]
829pub const kDimensionInvalid: ::std::os::raw::c_uint = 0;
830#[doc = "< The Z-dimension."]
831pub const kDimensionZ: ::std::os::raw::c_uint = 1;
832#[doc = "< The C-dimension (\"channel\")."]
833pub const kDimensionC: ::std::os::raw::c_uint = 2;
834#[doc = "< The T-dimension (\"time\")."]
835pub const kDimensionT: ::std::os::raw::c_uint = 3;
836#[doc = "< The R-dimension (\"rotation\")."]
837pub const kDimensionR: ::std::os::raw::c_uint = 4;
838#[doc = "< The S-dimension (\"scene\")."]
839pub const kDimensionS: ::std::os::raw::c_uint = 5;
840#[doc = "< The I-dimension (\"illumination\")."]
841pub const kDimensionI: ::std::os::raw::c_uint = 6;
842#[doc = "< The H-dimension (\"phase\")."]
843pub const kDimensionH: ::std::os::raw::c_uint = 7;
844#[doc = "< The V-dimension (\"view\")."]
845pub const kDimensionV: ::std::os::raw::c_uint = 8;
846#[doc = "< The B-dimension (\"block\") - its use is deprecated."]
847pub const kDimensionB: ::std::os::raw::c_uint = 9;
848#[doc = "< This enum must have the value of the lowest (valid) dimension index."]
849pub const kDimensionMinValue: ::std::os::raw::c_uint = 1;
850#[doc = "< This enum must have the value of the highest (valid) dimension index."]
851pub const kDimensionMaxValue: ::std::os::raw::c_uint = 9;
852pub const kMaxDimensionCount: ::std::os::raw::c_uchar = 9;
853#[doc = " This structure describes a rectangle, given by its top-left corner and its width and height."]
854#[repr(C)]
855#[derive(Debug, Copy, Clone)]
856pub struct IntRectInterop {
857 #[doc = "< The x-coordinate of the top-left corner."]
858 pub x: ::std::os::raw::c_int,
859 #[doc = "< The y-coordinate of the top-left corner."]
860 pub y: ::std::os::raw::c_int,
861 #[doc = "< The width of the rectangle."]
862 pub w: ::std::os::raw::c_int,
863 #[doc = "< The height of the rectangle."]
864 pub h: ::std::os::raw::c_int,
865}
866#[allow(clippy::unnecessary_operation, clippy::identity_op)]
867const _: () = {
868 ["Size of IntRectInterop"][::std::mem::size_of::<IntRectInterop>() - 16usize];
869 ["Alignment of IntRectInterop"][::std::mem::align_of::<IntRectInterop>() - 4usize];
870 ["Offset of field: IntRectInterop::x"][::std::mem::offset_of!(IntRectInterop, x) - 0usize];
871 ["Offset of field: IntRectInterop::y"][::std::mem::offset_of!(IntRectInterop, y) - 4usize];
872 ["Offset of field: IntRectInterop::w"][::std::mem::offset_of!(IntRectInterop, w) - 8usize];
873 ["Offset of field: IntRectInterop::h"][::std::mem::offset_of!(IntRectInterop, h) - 12usize];
874};
875#[doc = " This structure describes a size, given by its width and height."]
876#[repr(C)]
877#[derive(Debug, Copy, Clone)]
878pub struct IntSizeInterop {
879 #[doc = "< The width."]
880 pub w: ::std::os::raw::c_int,
881 #[doc = "< The height."]
882 pub h: ::std::os::raw::c_int,
883}
884#[allow(clippy::unnecessary_operation, clippy::identity_op)]
885const _: () = {
886 ["Size of IntSizeInterop"][::std::mem::size_of::<IntSizeInterop>() - 8usize];
887 ["Alignment of IntSizeInterop"][::std::mem::align_of::<IntSizeInterop>() - 4usize];
888 ["Offset of field: IntSizeInterop::w"][::std::mem::offset_of!(IntSizeInterop, w) - 0usize];
889 ["Offset of field: IntSizeInterop::h"][::std::mem::offset_of!(IntSizeInterop, h) - 4usize];
890};
891#[doc = " This structure gives the bounds for a set of dimensions.\n The bit at position `i` in `dimensions_valid` indicates whether the interval for dimension `i+1` is valid. So, bit 0\n is corresponding to dimension 1 (=Z), bit 1 to dimension 2 (=C), and so on.\n In the fixed-sized arrays `start` and `size`, the start and size values for the dimensions are stored. The elements at\n position 0 corresponds to the first valid dimension, the element at position 1 to the second valid dimension, and so on.\n An example would be: `dimensions_valid` = 0b00000011, `start` = { 0, 2 }, `size` = { 5, 6 }. This would mean that the\n dimension 'Z' is valid, and the interval is [0, 5], and the dimension 'C' is valid, and the interval is [2, 8]."]
892#[repr(C)]
893#[derive(Debug, Copy, Clone)]
894pub struct DimBoundsInterop {
895 #[doc = "< Bitfield indicating which dimensions are valid. Bit-position `i` corresponds to dimension `i+1`."]
896 pub dimensions_valid: ::std::os::raw::c_uint,
897 #[doc = "< The start values, the element 0 corresponds the first set flag in dimensions_valid and so on."]
898 pub start: [::std::os::raw::c_int; 9usize],
899 #[doc = "< The size values, the element 0 corresponds the first set flag in dimensions_valid and so on."]
900 pub size: [::std::os::raw::c_int; 9usize],
901}
902#[allow(clippy::unnecessary_operation, clippy::identity_op)]
903const _: () = {
904 ["Size of DimBoundsInterop"][::std::mem::size_of::<DimBoundsInterop>() - 76usize];
905 ["Alignment of DimBoundsInterop"][::std::mem::align_of::<DimBoundsInterop>() - 4usize];
906 ["Offset of field: DimBoundsInterop::dimensions_valid"]
907 [::std::mem::offset_of!(DimBoundsInterop, dimensions_valid) - 0usize];
908 ["Offset of field: DimBoundsInterop::start"]
909 [::std::mem::offset_of!(DimBoundsInterop, start) - 4usize];
910 ["Offset of field: DimBoundsInterop::size"]
911 [::std::mem::offset_of!(DimBoundsInterop, size) - 40usize];
912};
913#[doc = " This structure gives the coordinates (of a sub-block) for a set of dimension.\n The bit at position `i` in `dimensions_valid` indicates whether the coordinate for dimension `i+1` is valid. So, bit 0\n is corresponding to dimension 1 (=Z), bit 1 to dimension 2 (=C), and so on.\n In the fixed-sized array `value`, the coordinate for the dimensions is stored. The element at\n position 0 corresponds to the first valid dimension, the element at position 1 to the second valid dimension, and so on.\n An example would be: `dimensions_valid` = 0b00000011, `value` = { 0, 2 }. This would mean that the\n dimension 'Z' is valid, and the coordinate for 'Z' is 0, and the dimension 'C' is valid, and the coordinate for 'C' is 2."]
914#[repr(C)]
915#[derive(Debug, Copy, Clone)]
916pub struct CoordinateInterop {
917 #[doc = "< Bitfield indicating which dimensions are valid. Bit-position `i` corresponds to dimension `i+1`."]
918 pub dimensions_valid: ::std::os::raw::c_uint,
919 #[doc = "< The coordinate values, the element 0 corresponds the first set flag in dimensions_valid and so on."]
920 pub value: [::std::os::raw::c_int; 9usize],
921}
922#[allow(clippy::unnecessary_operation, clippy::identity_op)]
923const _: () = {
924 ["Size of CoordinateInterop"][::std::mem::size_of::<CoordinateInterop>() - 40usize];
925 ["Alignment of CoordinateInterop"][::std::mem::align_of::<CoordinateInterop>() - 4usize];
926 ["Offset of field: CoordinateInterop::dimensions_valid"]
927 [::std::mem::offset_of!(CoordinateInterop, dimensions_valid) - 0usize];
928 ["Offset of field: CoordinateInterop::value"]
929 [::std::mem::offset_of!(CoordinateInterop, value) - 4usize];
930};
931#[doc = " This structure contains the bounding boxes for a scene."]
932#[repr(C)]
933#[derive(Debug, Copy, Clone)]
934pub struct BoundingBoxesInterop {
935 #[doc = " Zero-based index of the scene (for which the following bounding boxes apply)."]
936 pub sceneIndex: ::std::os::raw::c_int,
937 #[doc = " The bounding box of the scene (calculated including pyramid-tiles)."]
938 pub bounding_box: IntRectInterop,
939 #[doc = " The bounding box of the scene (calculated excluding pyramid-tiles)."]
940 pub bounding_box_layer0_only: IntRectInterop,
941}
942#[allow(clippy::unnecessary_operation, clippy::identity_op)]
943const _: () = {
944 ["Size of BoundingBoxesInterop"][::std::mem::size_of::<BoundingBoxesInterop>() - 36usize];
945 ["Alignment of BoundingBoxesInterop"][::std::mem::align_of::<BoundingBoxesInterop>() - 4usize];
946 ["Offset of field: BoundingBoxesInterop::sceneIndex"]
947 [::std::mem::offset_of!(BoundingBoxesInterop, sceneIndex) - 0usize];
948 ["Offset of field: BoundingBoxesInterop::bounding_box"]
949 [::std::mem::offset_of!(BoundingBoxesInterop, bounding_box) - 4usize];
950 ["Offset of field: BoundingBoxesInterop::bounding_box_layer0_only"]
951 [::std::mem::offset_of!(BoundingBoxesInterop, bounding_box_layer0_only) - 20usize];
952};
953#[doc = " This structure contains basic statistics about an CZI-document."]
954#[repr(C)]
955#[derive(Debug, Copy, Clone)]
956pub struct SubBlockStatisticsInterop {
957 #[doc = "< The number of sub-blocks."]
958 pub sub_block_count: ::std::os::raw::c_int,
959 #[doc = "< The minimum M-index."]
960 pub min_m_index: ::std::os::raw::c_int,
961 #[doc = "< The maximum M-index."]
962 pub max_m_index: ::std::os::raw::c_int,
963 #[doc = "< The bounding-box determined from all sub-blocks."]
964 pub bounding_box: IntRectInterop,
965 #[doc = "< The minimal axis-aligned-bounding box determined only from the logical coordinates of the sub-blocks on pyramid-layer0 in the document."]
966 pub bounding_box_layer0: IntRectInterop,
967 #[doc = "< The dimension bounds."]
968 pub dim_bounds: DimBoundsInterop,
969}
970#[allow(clippy::unnecessary_operation, clippy::identity_op)]
971const _: () = {
972 ["Size of SubBlockStatisticsInterop"]
973 [::std::mem::size_of::<SubBlockStatisticsInterop>() - 120usize];
974 ["Alignment of SubBlockStatisticsInterop"]
975 [::std::mem::align_of::<SubBlockStatisticsInterop>() - 4usize];
976 ["Offset of field: SubBlockStatisticsInterop::sub_block_count"]
977 [::std::mem::offset_of!(SubBlockStatisticsInterop, sub_block_count) - 0usize];
978 ["Offset of field: SubBlockStatisticsInterop::min_m_index"]
979 [::std::mem::offset_of!(SubBlockStatisticsInterop, min_m_index) - 4usize];
980 ["Offset of field: SubBlockStatisticsInterop::max_m_index"]
981 [::std::mem::offset_of!(SubBlockStatisticsInterop, max_m_index) - 8usize];
982 ["Offset of field: SubBlockStatisticsInterop::bounding_box"]
983 [::std::mem::offset_of!(SubBlockStatisticsInterop, bounding_box) - 12usize];
984 ["Offset of field: SubBlockStatisticsInterop::bounding_box_layer0"]
985 [::std::mem::offset_of!(SubBlockStatisticsInterop, bounding_box_layer0) - 28usize];
986 ["Offset of field: SubBlockStatisticsInterop::dim_bounds"]
987 [::std::mem::offset_of!(SubBlockStatisticsInterop, dim_bounds) - 44usize];
988};
989#[doc = " This structure extends on the basic statistics about an CZI-document, and includes per-scene statistics."]
990#[repr(C)]
991#[derive(Debug)]
992pub struct SubBlockStatisticsInteropEx {
993 #[doc = "< The number of sub-blocks."]
994 pub sub_block_count: ::std::os::raw::c_int,
995 #[doc = "< The minimum M-index."]
996 pub min_m_index: ::std::os::raw::c_int,
997 #[doc = "< The maximum M-index."]
998 pub max_m_index: ::std::os::raw::c_int,
999 #[doc = "< The bounding-box determined from all sub-blocks."]
1000 pub bounding_box: IntRectInterop,
1001 #[doc = "< The minimal axis-aligned-bounding box determined only from the logical coordinates of the sub-blocks on pyramid-layer0 in the document."]
1002 pub bounding_box_layer0: IntRectInterop,
1003 #[doc = "< The dimension bounds."]
1004 pub dim_bounds: DimBoundsInterop,
1005 #[doc = "< The number of per-scene bounding boxes that are following here."]
1006 pub number_of_per_scenes_bounding_boxes: ::std::os::raw::c_int,
1007 #[doc = "< The per-scene bounding boxes. The number of elements in this array is given by 'number_of_per_scenes_bounding_boxes'."]
1008 pub per_scenes_bounding_boxes: __IncompleteArrayField<BoundingBoxesInterop>,
1009}
1010#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1011const _: () = {
1012 ["Size of SubBlockStatisticsInteropEx"]
1013 [::std::mem::size_of::<SubBlockStatisticsInteropEx>() - 124usize];
1014 ["Alignment of SubBlockStatisticsInteropEx"]
1015 [::std::mem::align_of::<SubBlockStatisticsInteropEx>() - 4usize];
1016 ["Offset of field: SubBlockStatisticsInteropEx::sub_block_count"]
1017 [::std::mem::offset_of!(SubBlockStatisticsInteropEx, sub_block_count) - 0usize];
1018 ["Offset of field: SubBlockStatisticsInteropEx::min_m_index"]
1019 [::std::mem::offset_of!(SubBlockStatisticsInteropEx, min_m_index) - 4usize];
1020 ["Offset of field: SubBlockStatisticsInteropEx::max_m_index"]
1021 [::std::mem::offset_of!(SubBlockStatisticsInteropEx, max_m_index) - 8usize];
1022 ["Offset of field: SubBlockStatisticsInteropEx::bounding_box"]
1023 [::std::mem::offset_of!(SubBlockStatisticsInteropEx, bounding_box) - 12usize];
1024 ["Offset of field: SubBlockStatisticsInteropEx::bounding_box_layer0"]
1025 [::std::mem::offset_of!(SubBlockStatisticsInteropEx, bounding_box_layer0) - 28usize];
1026 ["Offset of field: SubBlockStatisticsInteropEx::dim_bounds"]
1027 [::std::mem::offset_of!(SubBlockStatisticsInteropEx, dim_bounds) - 44usize];
1028 ["Offset of field: SubBlockStatisticsInteropEx::number_of_per_scenes_bounding_boxes"][::std::mem::offset_of!(
1029 SubBlockStatisticsInteropEx,
1030 number_of_per_scenes_bounding_boxes
1031 )
1032 - 120usize];
1033 ["Offset of field: SubBlockStatisticsInteropEx::per_scenes_bounding_boxes"]
1034 [::std::mem::offset_of!(SubBlockStatisticsInteropEx, per_scenes_bounding_boxes) - 124usize];
1035};
1036#[repr(C, packed(4))]
1037#[derive(Debug, Copy, Clone)]
1038pub struct MetadataAsXmlInterop {
1039 #[doc = "< The XML-metadata. The data is an UTF8-encoded string. Note that this string is NOT guaranteed to be null-terminated.\n< This is a pointer to the data. This data must be freed by the caller (using libCZI_Free)."]
1040 pub data: *mut ::std::os::raw::c_void,
1041 #[doc = "< The size of the XML-metadata in bytes."]
1042 pub size: ::std::os::raw::c_ulong,
1043}
1044#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1045const _: () = {
1046 ["Size of MetadataAsXmlInterop"][::std::mem::size_of::<MetadataAsXmlInterop>() - 16usize];
1047 ["Alignment of MetadataAsXmlInterop"][::std::mem::align_of::<MetadataAsXmlInterop>() - 4usize];
1048 ["Offset of field: MetadataAsXmlInterop::data"]
1049 [::std::mem::offset_of!(MetadataAsXmlInterop, data) - 0usize];
1050 ["Offset of field: MetadataAsXmlInterop::size"]
1051 [::std::mem::offset_of!(MetadataAsXmlInterop, size) - 8usize];
1052};
1053#[doc = " Information about the bitmap represented by a bitmap-object."]
1054#[repr(C)]
1055#[derive(Debug, Copy, Clone)]
1056pub struct BitmapInfoInterop {
1057 #[doc = "< The width of the bitmap in pixels."]
1058 pub width: ::std::os::raw::c_uint,
1059 #[doc = "< The height of the bitmap in pixels."]
1060 pub height: ::std::os::raw::c_uint,
1061 #[doc = "< The pixel type of the bitmap."]
1062 pub pixelType: ::std::os::raw::c_int,
1063}
1064#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1065const _: () = {
1066 ["Size of BitmapInfoInterop"][::std::mem::size_of::<BitmapInfoInterop>() - 12usize];
1067 ["Alignment of BitmapInfoInterop"][::std::mem::align_of::<BitmapInfoInterop>() - 4usize];
1068 ["Offset of field: BitmapInfoInterop::width"]
1069 [::std::mem::offset_of!(BitmapInfoInterop, width) - 0usize];
1070 ["Offset of field: BitmapInfoInterop::height"]
1071 [::std::mem::offset_of!(BitmapInfoInterop, height) - 4usize];
1072 ["Offset of field: BitmapInfoInterop::pixelType"]
1073 [::std::mem::offset_of!(BitmapInfoInterop, pixelType) - 8usize];
1074};
1075#[doc = " This structure contains information about a locked bitmap-object, allowing direct\n access to the pixel data."]
1076#[repr(C, packed(4))]
1077#[derive(Debug, Copy, Clone)]
1078pub struct BitmapLockInfoInterop {
1079 #[doc = "< Not currently used, to be ignored."]
1080 pub ptrData: *mut ::std::os::raw::c_void,
1081 #[doc = "< The pointer to the first (top-left) pixel of the bitmap."]
1082 pub ptrDataRoi: *mut ::std::os::raw::c_void,
1083 #[doc = "< The stride of the bitmap data (pointed to by `ptrDataRoi`)."]
1084 pub stride: ::std::os::raw::c_uint,
1085 #[doc = "< The size of the bitmap data (pointed to by `ptrDataRoi`) in bytes."]
1086 pub size: ::std::os::raw::c_ulong,
1087}
1088#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1089const _: () = {
1090 ["Size of BitmapLockInfoInterop"][::std::mem::size_of::<BitmapLockInfoInterop>() - 28usize];
1091 ["Alignment of BitmapLockInfoInterop"]
1092 [::std::mem::align_of::<BitmapLockInfoInterop>() - 4usize];
1093 ["Offset of field: BitmapLockInfoInterop::ptrData"]
1094 [::std::mem::offset_of!(BitmapLockInfoInterop, ptrData) - 0usize];
1095 ["Offset of field: BitmapLockInfoInterop::ptrDataRoi"]
1096 [::std::mem::offset_of!(BitmapLockInfoInterop, ptrDataRoi) - 8usize];
1097 ["Offset of field: BitmapLockInfoInterop::stride"]
1098 [::std::mem::offset_of!(BitmapLockInfoInterop, stride) - 16usize];
1099 ["Offset of field: BitmapLockInfoInterop::size"]
1100 [::std::mem::offset_of!(BitmapLockInfoInterop, size) - 20usize];
1101};
1102#[doc = " This structure contains the information about a sub-block."]
1103#[repr(C)]
1104#[derive(Debug, Copy, Clone)]
1105pub struct SubBlockInfoInterop {
1106 #[doc = "< The (raw) compression mode identification of the sub-block. This value is not interpreted, use \"GetCompressionMode\" to have it\n< converted to the CompressionMode-enumeration."]
1107 pub compression_mode_raw: ::std::os::raw::c_int,
1108 #[doc = "< The pixel type of the bitmap contained in the sub-block."]
1109 pub pixel_type: ::std::os::raw::c_int,
1110 #[doc = "< The coordinate of the sub-block."]
1111 pub coordinate: CoordinateInterop,
1112 #[doc = "< The rectangle where the bitmap (in this sub-block) is located (in the CZI-pixel-coordinate system)."]
1113 pub logical_rect: IntRectInterop,
1114 #[doc = "< The physical size of the bitmap of the sub-block (which may be different to the size of logicalRect)."]
1115 pub physical_size: IntSizeInterop,
1116 #[doc = "< The M-index. If this has the value of 'numeric_limits<int32_t>::min()', then the M-index is not valid."]
1117 pub m_index: ::std::os::raw::c_int,
1118}
1119#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1120const _: () = {
1121 ["Size of SubBlockInfoInterop"][::std::mem::size_of::<SubBlockInfoInterop>() - 76usize];
1122 ["Alignment of SubBlockInfoInterop"][::std::mem::align_of::<SubBlockInfoInterop>() - 4usize];
1123 ["Offset of field: SubBlockInfoInterop::compression_mode_raw"]
1124 [::std::mem::offset_of!(SubBlockInfoInterop, compression_mode_raw) - 0usize];
1125 ["Offset of field: SubBlockInfoInterop::pixel_type"]
1126 [::std::mem::offset_of!(SubBlockInfoInterop, pixel_type) - 4usize];
1127 ["Offset of field: SubBlockInfoInterop::coordinate"]
1128 [::std::mem::offset_of!(SubBlockInfoInterop, coordinate) - 8usize];
1129 ["Offset of field: SubBlockInfoInterop::logical_rect"]
1130 [::std::mem::offset_of!(SubBlockInfoInterop, logical_rect) - 48usize];
1131 ["Offset of field: SubBlockInfoInterop::physical_size"]
1132 [::std::mem::offset_of!(SubBlockInfoInterop, physical_size) - 64usize];
1133 ["Offset of field: SubBlockInfoInterop::m_index"]
1134 [::std::mem::offset_of!(SubBlockInfoInterop, m_index) - 72usize];
1135};
1136#[doc = " This structure contains the information about an attachment.\n Note that performance reasons we use a fixed-size array for the name. In the rare case that the name is too long to fit into the\n fixed-size array, the 'overflow' field is set to true. In this case, the name is truncated and the 'overflow' field is set to true.\n In addition, the field 'name_in_case_of_overflow' then contains the full text, allocated with 'libCZI_AllocateString' (and responsibility\n for releasing the memory is with the caller)."]
1137#[repr(C, packed(4))]
1138#[derive(Debug, Copy, Clone)]
1139pub struct AttachmentInfoInterop {
1140 #[doc = "< The GUID of the attachment."]
1141 pub guid: [::std::os::raw::c_uchar; 16usize],
1142 #[doc = "< A null-terminated character array identifying the content of the attachment."]
1143 pub content_file_type: [::std::os::raw::c_uchar; 9usize],
1144 #[doc = "< A zero-terminated string (in UTF8-encoding) identifying the content of the attachment."]
1145 pub name: [::std::os::raw::c_char; 255usize],
1146 #[doc = "< True if the name is too long to fit into the 'name' field."]
1147 pub name_overflow: bool,
1148 #[doc = "< If 'name_overflow' is true, then this field contains the name (in UTF8-encoding and zero terminated) of the attachment. This memory must be freed using 'libCZI_Free'."]
1149 pub name_in_case_of_overflow: *mut ::std::os::raw::c_void,
1150}
1151#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1152const _: () = {
1153 ["Size of AttachmentInfoInterop"][::std::mem::size_of::<AttachmentInfoInterop>() - 292usize];
1154 ["Alignment of AttachmentInfoInterop"]
1155 [::std::mem::align_of::<AttachmentInfoInterop>() - 4usize];
1156 ["Offset of field: AttachmentInfoInterop::guid"]
1157 [::std::mem::offset_of!(AttachmentInfoInterop, guid) - 0usize];
1158 ["Offset of field: AttachmentInfoInterop::content_file_type"]
1159 [::std::mem::offset_of!(AttachmentInfoInterop, content_file_type) - 16usize];
1160 ["Offset of field: AttachmentInfoInterop::name"]
1161 [::std::mem::offset_of!(AttachmentInfoInterop, name) - 25usize];
1162 ["Offset of field: AttachmentInfoInterop::name_overflow"]
1163 [::std::mem::offset_of!(AttachmentInfoInterop, name_overflow) - 280usize];
1164 ["Offset of field: AttachmentInfoInterop::name_in_case_of_overflow"]
1165 [::std::mem::offset_of!(AttachmentInfoInterop, name_in_case_of_overflow) - 284usize];
1166};
1167#[doc = " This structure contains the information about file-header."]
1168#[repr(C)]
1169#[derive(Debug, Copy, Clone)]
1170pub struct FileHeaderInfoInterop {
1171 #[doc = "< The file-GUID of the CZI. Note: CZI defines two GUIDs, this is the \"FileGuid\". Multi-file containers\n< (for which the other GUID \"PrimaryFileGuid\" is used) are not supported by libCZI currently."]
1172 pub guid: [::std::os::raw::c_uchar; 16usize],
1173 #[doc = "< The major version."]
1174 pub majorVersion: ::std::os::raw::c_int,
1175 #[doc = "< The minor version."]
1176 pub minorVersion: ::std::os::raw::c_int,
1177}
1178#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1179const _: () = {
1180 ["Size of FileHeaderInfoInterop"][::std::mem::size_of::<FileHeaderInfoInterop>() - 24usize];
1181 ["Alignment of FileHeaderInfoInterop"]
1182 [::std::mem::align_of::<FileHeaderInfoInterop>() - 4usize];
1183 ["Offset of field: FileHeaderInfoInterop::guid"]
1184 [::std::mem::offset_of!(FileHeaderInfoInterop, guid) - 0usize];
1185 ["Offset of field: FileHeaderInfoInterop::majorVersion"]
1186 [::std::mem::offset_of!(FileHeaderInfoInterop, majorVersion) - 16usize];
1187 ["Offset of field: FileHeaderInfoInterop::minorVersion"]
1188 [::std::mem::offset_of!(FileHeaderInfoInterop, minorVersion) - 20usize];
1189};
1190#[doc = " This structure is used to pass the subblock information to libCZIAPI, describing a subblock to be added to a CZI-file."]
1191#[repr(C, packed(4))]
1192#[derive(Debug, Copy, Clone)]
1193pub struct AddSubBlockInfoInterop {
1194 #[doc = "< The subblock's coordinate."]
1195 pub coordinate: CoordinateInterop,
1196 #[doc = "< Whether the field 'mIndex' is valid;"]
1197 pub m_index_valid: ::std::os::raw::c_uchar,
1198 #[doc = "< The M-index of the subblock."]
1199 pub m_index: ::std::os::raw::c_int,
1200 #[doc = "< The x-coordinate of the subblock."]
1201 pub x: ::std::os::raw::c_int,
1202 #[doc = "< The y-coordinate of the subblock."]
1203 pub y: ::std::os::raw::c_int,
1204 #[doc = "< The logical with of the subblock (in pixels)."]
1205 pub logical_width: ::std::os::raw::c_int,
1206 #[doc = "< The logical height of the subblock (in pixels)."]
1207 pub logical_height: ::std::os::raw::c_int,
1208 #[doc = "< The physical with of the subblock (in pixels)."]
1209 pub physical_width: ::std::os::raw::c_int,
1210 #[doc = "< The physical height of the subblock (in pixels)."]
1211 pub physical_height: ::std::os::raw::c_int,
1212 #[doc = "< The pixel type of the subblock."]
1213 pub pixel_type: ::std::os::raw::c_int,
1214 #[doc = " The compression-mode (applying to the subblock-data). If using a compressed format, the data\n passed in must be already compressed - the writer does _not_ perform the compression."]
1215 pub compression_mode_raw: ::std::os::raw::c_int,
1216 #[doc = "< The size of the subblock's data in bytes."]
1217 pub size_data: ::std::os::raw::c_uint,
1218 #[doc = "< Pointer to the data to be put into the subblock."]
1219 pub data: *const ::std::os::raw::c_void,
1220 #[doc = " If the compression mode is set to 'Uncompressed', then this is valid and the stride of the bitmap.\n In this case, the line-size of the bitmap is determined by the pixel-type and the physical_width.\n And size_data must be large enough to hold the bitmap-data, and is validated.\n In other cases (compression-mode is not 'Uncompressed'), this field is ignored."]
1221 pub stride: ::std::os::raw::c_uint,
1222 #[doc = "< The size of the subblock-metadata in bytes. If this is 0, then ptrSbBlkMetadata is not used (and no sub-block-metadata written)."]
1223 pub size_metadata: ::std::os::raw::c_uint,
1224 #[doc = "< Pointer to the subblock-metadata."]
1225 pub metadata: *const ::std::os::raw::c_void,
1226 #[doc = "< The size of the subblock-attachment in bytes. If this is 0, then attachment is not used (and no sub-block-metadata written)."]
1227 pub size_attachment: ::std::os::raw::c_uint,
1228 #[doc = "< Pointer to the subblock-attachment."]
1229 pub attachment: *const ::std::os::raw::c_void,
1230}
1231#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1232const _: () = {
1233 ["Size of AddSubBlockInfoInterop"][::std::mem::size_of::<AddSubBlockInfoInterop>() - 120usize];
1234 ["Alignment of AddSubBlockInfoInterop"]
1235 [::std::mem::align_of::<AddSubBlockInfoInterop>() - 4usize];
1236 ["Offset of field: AddSubBlockInfoInterop::coordinate"]
1237 [::std::mem::offset_of!(AddSubBlockInfoInterop, coordinate) - 0usize];
1238 ["Offset of field: AddSubBlockInfoInterop::m_index_valid"]
1239 [::std::mem::offset_of!(AddSubBlockInfoInterop, m_index_valid) - 40usize];
1240 ["Offset of field: AddSubBlockInfoInterop::m_index"]
1241 [::std::mem::offset_of!(AddSubBlockInfoInterop, m_index) - 44usize];
1242 ["Offset of field: AddSubBlockInfoInterop::x"]
1243 [::std::mem::offset_of!(AddSubBlockInfoInterop, x) - 48usize];
1244 ["Offset of field: AddSubBlockInfoInterop::y"]
1245 [::std::mem::offset_of!(AddSubBlockInfoInterop, y) - 52usize];
1246 ["Offset of field: AddSubBlockInfoInterop::logical_width"]
1247 [::std::mem::offset_of!(AddSubBlockInfoInterop, logical_width) - 56usize];
1248 ["Offset of field: AddSubBlockInfoInterop::logical_height"]
1249 [::std::mem::offset_of!(AddSubBlockInfoInterop, logical_height) - 60usize];
1250 ["Offset of field: AddSubBlockInfoInterop::physical_width"]
1251 [::std::mem::offset_of!(AddSubBlockInfoInterop, physical_width) - 64usize];
1252 ["Offset of field: AddSubBlockInfoInterop::physical_height"]
1253 [::std::mem::offset_of!(AddSubBlockInfoInterop, physical_height) - 68usize];
1254 ["Offset of field: AddSubBlockInfoInterop::pixel_type"]
1255 [::std::mem::offset_of!(AddSubBlockInfoInterop, pixel_type) - 72usize];
1256 ["Offset of field: AddSubBlockInfoInterop::compression_mode_raw"]
1257 [::std::mem::offset_of!(AddSubBlockInfoInterop, compression_mode_raw) - 76usize];
1258 ["Offset of field: AddSubBlockInfoInterop::size_data"]
1259 [::std::mem::offset_of!(AddSubBlockInfoInterop, size_data) - 80usize];
1260 ["Offset of field: AddSubBlockInfoInterop::data"]
1261 [::std::mem::offset_of!(AddSubBlockInfoInterop, data) - 84usize];
1262 ["Offset of field: AddSubBlockInfoInterop::stride"]
1263 [::std::mem::offset_of!(AddSubBlockInfoInterop, stride) - 92usize];
1264 ["Offset of field: AddSubBlockInfoInterop::size_metadata"]
1265 [::std::mem::offset_of!(AddSubBlockInfoInterop, size_metadata) - 96usize];
1266 ["Offset of field: AddSubBlockInfoInterop::metadata"]
1267 [::std::mem::offset_of!(AddSubBlockInfoInterop, metadata) - 100usize];
1268 ["Offset of field: AddSubBlockInfoInterop::size_attachment"]
1269 [::std::mem::offset_of!(AddSubBlockInfoInterop, size_attachment) - 108usize];
1270 ["Offset of field: AddSubBlockInfoInterop::attachment"]
1271 [::std::mem::offset_of!(AddSubBlockInfoInterop, attachment) - 112usize];
1272};
1273#[doc = " This structure is used to pass the attachment information to libCZIAPI, describing an attachment to be added to a CZI-file."]
1274#[repr(C, packed(4))]
1275#[derive(Debug, Copy, Clone)]
1276pub struct AddAttachmentInfoInterop {
1277 #[doc = "< The GUID of the attachment."]
1278 pub guid: [::std::os::raw::c_uchar; 16usize],
1279 #[doc = "< The content file type."]
1280 pub contentFileType: [::std::os::raw::c_uchar; 8usize],
1281 #[doc = "< The name of the attachment."]
1282 pub name: [::std::os::raw::c_uchar; 80usize],
1283 #[doc = "< The size of the attachment data (in bytes)."]
1284 pub size_attachment_data: ::std::os::raw::c_uint,
1285 #[doc = "< Pointer to the attachment data."]
1286 pub attachment_data: *const ::std::os::raw::c_void,
1287}
1288#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1289const _: () = {
1290 ["Size of AddAttachmentInfoInterop"]
1291 [::std::mem::size_of::<AddAttachmentInfoInterop>() - 116usize];
1292 ["Alignment of AddAttachmentInfoInterop"]
1293 [::std::mem::align_of::<AddAttachmentInfoInterop>() - 4usize];
1294 ["Offset of field: AddAttachmentInfoInterop::guid"]
1295 [::std::mem::offset_of!(AddAttachmentInfoInterop, guid) - 0usize];
1296 ["Offset of field: AddAttachmentInfoInterop::contentFileType"]
1297 [::std::mem::offset_of!(AddAttachmentInfoInterop, contentFileType) - 16usize];
1298 ["Offset of field: AddAttachmentInfoInterop::name"]
1299 [::std::mem::offset_of!(AddAttachmentInfoInterop, name) - 24usize];
1300 ["Offset of field: AddAttachmentInfoInterop::size_attachment_data"]
1301 [::std::mem::offset_of!(AddAttachmentInfoInterop, size_attachment_data) - 104usize];
1302 ["Offset of field: AddAttachmentInfoInterop::attachment_data"]
1303 [::std::mem::offset_of!(AddAttachmentInfoInterop, attachment_data) - 108usize];
1304};
1305#[doc = " This structure is used to pass the metadata information to libCZIAPI."]
1306#[repr(C, packed(4))]
1307#[derive(Debug, Copy, Clone)]
1308pub struct WriteMetadataInfoInterop {
1309 #[doc = "< The size of the data pointed to by metadata."]
1310 pub size_metadata: ::std::os::raw::c_uint,
1311 #[doc = "< Pointer to the metadata. This data is expected to be XML in UTF8-encoding."]
1312 pub metadata: *const ::std::os::raw::c_void,
1313}
1314#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1315const _: () = {
1316 ["Size of WriteMetadataInfoInterop"]
1317 [::std::mem::size_of::<WriteMetadataInfoInterop>() - 12usize];
1318 ["Alignment of WriteMetadataInfoInterop"]
1319 [::std::mem::align_of::<WriteMetadataInfoInterop>() - 4usize];
1320 ["Offset of field: WriteMetadataInfoInterop::size_metadata"]
1321 [::std::mem::offset_of!(WriteMetadataInfoInterop, size_metadata) - 0usize];
1322 ["Offset of field: WriteMetadataInfoInterop::metadata"]
1323 [::std::mem::offset_of!(WriteMetadataInfoInterop, metadata) - 4usize];
1324};
1325#[doc = " This structure is used to pass the accessor options to libCZIAPI."]
1326#[repr(C, packed(4))]
1327#[derive(Debug, Copy, Clone)]
1328pub struct AccessorOptionsInterop {
1329 #[doc = " The red component of the background color. If the destination bitmap is a grayscale-type, then the mean from R, G and B is calculated and multiplied\n with the maximum pixel value (of the specific pixeltype). If it is an RGB-color type, then R, G and B are separately multiplied with\n the maximum pixel value.\n If any of R, G or B is NaN, then the background is not cleared."]
1330 pub back_ground_color_r: f32,
1331 #[doc = " The green component of the background color. If the destination bitmap is a grayscale-type, then the mean from R, G and B is calculated and multiplied\n with the maximum pixel value (of the specific pixeltype). If it is an RGB-color type, then R, G and B are separately multiplied with\n the maximum pixel value.\n If any of R, G or B is NaN, then the background is not cleared."]
1332 pub back_ground_color_g: f32,
1333 #[doc = " The blue component of the background color. If the destination bitmap is a grayscale-type, then the mean from R, G and B is calculated and multiplied\n with the maximum pixel value (of the specific pixeltype). If it is an RGB-color type, then R, G and B are separately multiplied with\n the maximum pixel value.\n If any of R, G or B is NaN, then the background is not cleared."]
1334 pub back_ground_color_b: f32,
1335 #[doc = " If true, then the tiles are sorted by their M-index (tile with highest M-index will be 'on top').\n Otherwise, the Z-order is arbitrary."]
1336 pub sort_by_m: bool,
1337 #[doc = " If true, then the tile-visibility-check-optimization is used. When doing the multi-tile composition,\n all relevant tiles are checked whether they are visible in the destination bitmap. If a tile is not visible, then\n the corresponding sub-block is not read. This can speed up the operation considerably. The result is the same as\n without this optimization - i.e. there should be no reason to turn it off besides potential bugs."]
1338 pub use_visibility_check_optimization: bool,
1339 #[doc = " Additional parameters for the accessor."]
1340 pub additional_parameters: *const ::std::os::raw::c_char,
1341}
1342#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1343const _: () = {
1344 ["Size of AccessorOptionsInterop"][::std::mem::size_of::<AccessorOptionsInterop>() - 24usize];
1345 ["Alignment of AccessorOptionsInterop"]
1346 [::std::mem::align_of::<AccessorOptionsInterop>() - 4usize];
1347 ["Offset of field: AccessorOptionsInterop::back_ground_color_r"]
1348 [::std::mem::offset_of!(AccessorOptionsInterop, back_ground_color_r) - 0usize];
1349 ["Offset of field: AccessorOptionsInterop::back_ground_color_g"]
1350 [::std::mem::offset_of!(AccessorOptionsInterop, back_ground_color_g) - 4usize];
1351 ["Offset of field: AccessorOptionsInterop::back_ground_color_b"]
1352 [::std::mem::offset_of!(AccessorOptionsInterop, back_ground_color_b) - 8usize];
1353 ["Offset of field: AccessorOptionsInterop::sort_by_m"]
1354 [::std::mem::offset_of!(AccessorOptionsInterop, sort_by_m) - 12usize];
1355 ["Offset of field: AccessorOptionsInterop::use_visibility_check_optimization"][::std::mem::offset_of!(
1356 AccessorOptionsInterop,
1357 use_visibility_check_optimization
1358 ) - 13usize];
1359 ["Offset of field: AccessorOptionsInterop::additional_parameters"]
1360 [::std::mem::offset_of!(AccessorOptionsInterop, additional_parameters) - 16usize];
1361};
1362#[doc = " This structure gathers all information about a channel for the purpose of multi-channel-composition."]
1363#[repr(C, packed(4))]
1364#[derive(Debug, Copy, Clone)]
1365pub struct CompositionChannelInfoInterop {
1366 #[doc = "< The weight of the channel in the composition."]
1367 pub weight: f32,
1368 #[doc = " True if tinting is enabled for this channel (in which case the tinting member is to be\n examined), false if no tinting is to be applied (the tinting member is then not used)."]
1369 pub enable_tinting: ::std::os::raw::c_uchar,
1370 #[doc = " The tinting color (only examined if enableTinting is true). This is the red-component."]
1371 pub tinting_color_r: ::std::os::raw::c_uchar,
1372 #[doc = " The tinting color (only examined if enableTinting is true). This is the green-component."]
1373 pub tinting_color_g: ::std::os::raw::c_uchar,
1374 #[doc = " The tinting color (only examined if enableTinting is true). This is the blue-component."]
1375 pub tinting_color_b: ::std::os::raw::c_uchar,
1376 #[doc = " The black point - it is a float between 0 and 1, where 0 corresponds to the lowest pixel value\n (of the pixel-type for the channel) and 1 to the highest pixel value (of the pixel-type of this channel).\n All pixel values below the black point are mapped to 0."]
1377 pub black_point: f32,
1378 #[doc = " The white point - it is a float between 0 and 1, where 0 corresponds to the lowest pixel value\n (of the pixel-type for the channel) and 1 to the highest pixel value (of the pixel-type of this channel).\n All pixel value above the white pointer are mapped to the highest pixel value."]
1379 pub white_point: f32,
1380 #[doc = " Number of elements in the look-up table. If 0, then the look-up table\n is not used. If this channelInfo applies to a Gray8/Bgr24-channel, then the size\n of the look-up table must be 256. In case of a Gray16/Bgr48-channel, the size must be\n 65536.\n \\remark\n If a look-up table is provided, then \\c blackPoint and \\c whitePoint are not used anymore ."]
1381 pub look_up_table_element_count: ::std::os::raw::c_int,
1382 #[doc = " The pointer to the look-up table. If the property 'look_up_table_element_count' is <> 0, then this pointer\n must be valid."]
1383 pub ptr_look_up_table: *mut ::std::os::raw::c_uchar,
1384}
1385#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1386const _: () = {
1387 ["Size of CompositionChannelInfoInterop"]
1388 [::std::mem::size_of::<CompositionChannelInfoInterop>() - 28usize];
1389 ["Alignment of CompositionChannelInfoInterop"]
1390 [::std::mem::align_of::<CompositionChannelInfoInterop>() - 4usize];
1391 ["Offset of field: CompositionChannelInfoInterop::weight"]
1392 [::std::mem::offset_of!(CompositionChannelInfoInterop, weight) - 0usize];
1393 ["Offset of field: CompositionChannelInfoInterop::enable_tinting"]
1394 [::std::mem::offset_of!(CompositionChannelInfoInterop, enable_tinting) - 4usize];
1395 ["Offset of field: CompositionChannelInfoInterop::tinting_color_r"]
1396 [::std::mem::offset_of!(CompositionChannelInfoInterop, tinting_color_r) - 5usize];
1397 ["Offset of field: CompositionChannelInfoInterop::tinting_color_g"]
1398 [::std::mem::offset_of!(CompositionChannelInfoInterop, tinting_color_g) - 6usize];
1399 ["Offset of field: CompositionChannelInfoInterop::tinting_color_b"]
1400 [::std::mem::offset_of!(CompositionChannelInfoInterop, tinting_color_b) - 7usize];
1401 ["Offset of field: CompositionChannelInfoInterop::black_point"]
1402 [::std::mem::offset_of!(CompositionChannelInfoInterop, black_point) - 8usize];
1403 ["Offset of field: CompositionChannelInfoInterop::white_point"]
1404 [::std::mem::offset_of!(CompositionChannelInfoInterop, white_point) - 12usize];
1405 ["Offset of field: CompositionChannelInfoInterop::look_up_table_element_count"][::std::mem::offset_of!(
1406 CompositionChannelInfoInterop,
1407 look_up_table_element_count
1408 ) - 16usize];
1409 ["Offset of field: CompositionChannelInfoInterop::ptr_look_up_table"]
1410 [::std::mem::offset_of!(CompositionChannelInfoInterop, ptr_look_up_table) - 20usize];
1411};
1412#[doc = " This structure gathers the information about the scaling."]
1413#[repr(C, packed(4))]
1414#[derive(Debug, Copy, Clone)]
1415pub struct ScalingInfoInterop {
1416 #[doc = "< The length of a pixel in x-direction in the unit meters. If unknown/invalid, this value is numeric_limits<double>::quiet_NaN()."]
1417 pub scale_x: f64,
1418 #[doc = "< The length of a pixel in y-direction in the unit meters. If unknown/invalid, this value is numeric_limits<double>::quiet_NaN()."]
1419 pub scale_y: f64,
1420 #[doc = "< The length of a pixel in z-direction in the unit meters. If unknown/invalid, this value is numeric_limits<double>::quiet_NaN()."]
1421 pub scale_z: f64,
1422}
1423#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1424const _: () = {
1425 ["Size of ScalingInfoInterop"][::std::mem::size_of::<ScalingInfoInterop>() - 24usize];
1426 ["Alignment of ScalingInfoInterop"][::std::mem::align_of::<ScalingInfoInterop>() - 4usize];
1427 ["Offset of field: ScalingInfoInterop::scale_x"]
1428 [::std::mem::offset_of!(ScalingInfoInterop, scale_x) - 0usize];
1429 ["Offset of field: ScalingInfoInterop::scale_y"]
1430 [::std::mem::offset_of!(ScalingInfoInterop, scale_y) - 8usize];
1431 ["Offset of field: ScalingInfoInterop::scale_z"]
1432 [::std::mem::offset_of!(ScalingInfoInterop, scale_z) - 16usize];
1433};
1434unsafe extern "C" {
1435 #[doc = " Release the memory - this function is to be used for freeing memory allocated by the libCZIApi-library\n (and returned to the caller).\n\n \\param data Pointer to the memory to be freed."]
1436 pub fn libCZI_Free(data: *mut ::std::os::raw::c_void);
1437}
1438unsafe extern "C" {
1439 #[doc = " Allocate memory of the specified size.\n\n \\param size The size of the memory block to be allocated in bytes.\n \\param [out] data If successful, a pointer to the allocated memory is put here. The memory must be freed using 'libCZI_Free'.\n\n \\returns An error-code indicating success or failure of the operation."]
1440 pub fn libCZI_AllocateMemory(
1441 size: ::std::os::raw::c_ulong,
1442 data: *mut *mut ::std::os::raw::c_void,
1443 ) -> LibCZIApiErrorCode;
1444}
1445unsafe extern "C" {
1446 #[doc = " Get version information about the libCZIApi-library.\n\n \\param [out] version_info If successful, the version information is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1447 pub fn libCZI_GetLibCZIVersionInfo(
1448 version_info: *mut LibCZIVersionInfoInterop,
1449 ) -> LibCZIApiErrorCode;
1450}
1451unsafe extern "C" {
1452 #[doc = " Get information about the build of the libCZIApi-library.\n\n \\param [out] build_info If successful, the build information is put here. Note that all strings must be freed by the caller (using 'libCZI_Free').\n\n \\returns An error-code indicating success or failure of the operation."]
1453 pub fn libCZI_GetLibCZIBuildInformation(
1454 build_info: *mut LibCZIBuildInformationInterop,
1455 ) -> LibCZIApiErrorCode;
1456}
1457unsafe extern "C" {
1458 #[doc = " Create a new CZI-reader object.\n\n \\param [out] reader_object If the operation is successful, a handle to the newly created reader object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1459 pub fn libCZI_CreateReader(reader_object: *mut CziReaderObjectHandle) -> LibCZIApiErrorCode;
1460}
1461unsafe extern "C" {
1462 #[doc = " Instruct the specified reader-object to open a CZI-document. The 'open_info' parameter contains\n a handle to a stream-object which is used to read the document.\n\n \\param reader_object A handle representing the reader-object.\n \\param open_info Parameters controlling the operation.\n\n \\returns An error-code indicating success or failure of the operation."]
1463 pub fn libCZI_ReaderOpen(
1464 reader_object: CziReaderObjectHandle,
1465 open_info: *const ReaderOpenInfoInterop,
1466 ) -> LibCZIApiErrorCode;
1467}
1468unsafe extern "C" {
1469 #[doc = " Get information about the file-header of the CZI document. The information is put into the 'file_header_info_interop' structure.\n This file_header_info_interop structure contains the GUID of the CZI document and the version levels of CZI.\n\n \\param reader_object The reader object.\n \\param [out] file_header_info_interop If successful, the retrieved information is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1470 pub fn libCZI_ReaderGetFileHeaderInfo(
1471 reader_object: CziReaderObjectHandle,
1472 file_header_info_interop: *mut FileHeaderInfoInterop,
1473 ) -> LibCZIApiErrorCode;
1474}
1475unsafe extern "C" {
1476 #[doc = " Reads the sub-block identified by the specified index. If there is no sub-block present (for the\n specified index) then the function returns 'LibCZIApi_ErrorCode_OK', but the 'sub_block_object'\n is set to 'kInvalidObjectHandle'.\n\n \\param reader_object The reader object.\n \\param index Index of the sub-block.\n \\param [out] sub_block_object If successful, a handle to the sub-block object is put here; otherwise 'kInvalidObjectHandle'.\n\n \\returns An error-code indicating success or failure of the operation."]
1477 pub fn libCZI_ReaderReadSubBlock(
1478 reader_object: CziReaderObjectHandle,
1479 index: ::std::os::raw::c_int,
1480 sub_block_object: *mut SubBlockObjectHandle,
1481 ) -> LibCZIApiErrorCode;
1482}
1483unsafe extern "C" {
1484 #[doc = " Get statistics about the sub-blocks in the CZI-document. This function provides a simple version of the statistics, the\n information retrieved does not include the per-scene statistics.\n\n \\param reader_object The reader object.\n \\param [out] statistics If non-null, the simple statistics will be put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1485 pub fn libCZI_ReaderGetStatisticsSimple(
1486 reader_object: CziReaderObjectHandle,
1487 statistics: *mut SubBlockStatisticsInterop,
1488 ) -> LibCZIApiErrorCode;
1489}
1490unsafe extern "C" {
1491 #[doc = " Get extended statistics about the sub-blocks in the CZI-document. This function provides a more detailed version of the statistics,\n including the per-scene statistics. Note that the statistics is of variable size, and the semantic is as follows:\n - On input, the argument 'number_of_per_channel_bounding_boxes' must point to an integer which describes the size of the argument 'statistics'.\n This number gives how many elements the array 'per_scenes_bounding_boxes' in 'SubBlockStatisticsInteropEx' can hold. Only that number of\n per-scene information elements will be put into the 'statistics' structure at most, in any case.\n - On output, the argument 'number_of_per_channel_bounding_boxes' will be set to the number of per-channel bounding boxes that were actually\n available.\n - In the returned 'SubBlockStatisticsInteropEx' structure, the 'number_of_per_scenes_bounding_boxes' field will be set to the number of per-scene\n information that is put into this struct (which may be less than number of scenes that are available).\n So, the caller is expected to check the returned 'number_of_per_channel_bounding_boxes' to see how many per-channel bounding boxes are available.\n If this number is greater than the number of elements (given with the 'number_of_per_scenes_bounding_boxes' value in the 'statistics' structure),\n then the caller should allocate a larger 'statistics' structure and call this function again (with an increased 'number_of_per_scenes_bounding_boxes').\n\n \\param reader_object The reader object.\n \\param [out] statistics If non-null, the statistics will be put here.\n \\param [in,out] number_of_per_channel_bounding_boxes On input, it gives the number of elements that can be put into the 'per_scenes_bounding_boxes' array.\n On output, it gives the number of elements which are available.\n\n \\returns An error-code indicating success or failure of the operation."]
1492 pub fn libCZI_ReaderGetStatisticsEx(
1493 reader_object: CziReaderObjectHandle,
1494 statistics: *mut SubBlockStatisticsInteropEx,
1495 number_of_per_channel_bounding_boxes: *mut ::std::os::raw::c_int,
1496 ) -> LibCZIApiErrorCode;
1497}
1498unsafe extern "C" {
1499 #[doc = " Get \"pyramid-statistics\" about the CZI-document. This function provides a JSON-formatted string which contains information about the pyramid.\n The JSON-schema is as follows:\n \\code\n {\n \"scenePyramidStatistics\": {\n \"<sceneIndex>\": [\n {\n \"layerInfo\": {\n \"minificationFactor\": <number>,\n \"pyramidLayerNo\" : <number>\n },\n \"count\" : <number>\n }\n ]}\n }\n \\endcode\n It resembles the corresponding C++-structure 'PyramidStatistics' in the libCZI-library.\n\n \\param reader_object The reader object.\n \\param [out] pyramid_statistics_as_json If successful, a pointer to a JSON-formatted string is placed here. The caller\n is responsible for freeing this memory (by calling libCZI_Free).\n\n \\returns An error-code indicating success or failure of the operation."]
1500 pub fn libCZI_ReaderGetPyramidStatistics(
1501 reader_object: CziReaderObjectHandle,
1502 pyramid_statistics_as_json: *mut *mut ::std::os::raw::c_char,
1503 ) -> LibCZIApiErrorCode;
1504}
1505unsafe extern "C" {
1506 #[doc = " Create a metadata-segment object from the reader-object. The metadata-segment object can be used to retrieve the XML-metadata of the CZI-document.\n\n \\param reader_object The reader object.\n \\param [out] metadata_segment_object If successful, a handle to the metadata-segment object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1507 pub fn libCZI_ReaderGetMetadataSegment(
1508 reader_object: CziReaderObjectHandle,
1509 metadata_segment_object: *mut MetadataSegmentObjectHandle,
1510 ) -> LibCZIApiErrorCode;
1511}
1512unsafe extern "C" {
1513 #[doc = " Get the number of attachments available.\n\n \\param reader_object The reader object.\n \\param [out] count The number of available attachments is put here.\n \\returns An error-code indicating success or failure of the operation."]
1514 pub fn libCZI_ReaderGetAttachmentCount(
1515 reader_object: CziReaderObjectHandle,
1516 count: *mut ::std::os::raw::c_int,
1517 ) -> LibCZIApiErrorCode;
1518}
1519unsafe extern "C" {
1520 #[doc = " Get information about the attachment at the specified index. The information is put into the 'attachment_info_interop' structure.\n If the index is not valid, then the function returns 'LibCZIApi_ErrorCode_IndexOutOfRange'.\n\n \\param reader_object The reader object.\n \\param index The index of the attachment to query information for.\n \\param [out] attachment_info_interop If successful, the retrieved information is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1521 pub fn libCZI_ReaderGetAttachmentInfoFromDirectory(
1522 reader_object: CziReaderObjectHandle,
1523 index: ::std::os::raw::c_int,
1524 attachment_info_interop: *mut AttachmentInfoInterop,
1525 ) -> LibCZIApiErrorCode;
1526}
1527unsafe extern "C" {
1528 #[doc = " Read the attachment with the specified index and create an attachment object representing it. If the specified index\n is invalid, then the returned attachment-object handle will have the value 'kInvalidObjectHandle'.\n \\param reader_object The reader object.\n \\param index The index of the attachment to get.\n \\param [out] attachment_object If successful and index is valid, a handle representing the attachment object is put here. If the index is\n invalid, then the handle will have the value 'kInvalidObjectHandle'.\n \\returns An error-code indicating success or failure of the operation."]
1529 pub fn libCZI_ReaderReadAttachment(
1530 reader_object: CziReaderObjectHandle,
1531 index: ::std::os::raw::c_int,
1532 attachment_object: *mut AttachmentObjectHandle,
1533 ) -> LibCZIApiErrorCode;
1534}
1535unsafe extern "C" {
1536 #[doc = " Release the specified reader-object. After this function is called, the handle is no\n longer valid.\n\n \\param reader_object The reader object.\n\n \\returns An error-code indicating success or failure of the operation."]
1537 pub fn libCZI_ReleaseReader(reader_object: CziReaderObjectHandle) -> LibCZIApiErrorCode;
1538}
1539unsafe extern "C" {
1540 #[doc = " Get the number of available stream classes.\n\n \\param [out] count The number of available stream classes it put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1541 pub fn libCZI_GetStreamClassesCount(count: *mut ::std::os::raw::c_int) -> LibCZIApiErrorCode;
1542}
1543unsafe extern "C" {
1544 #[doc = " Get information about the stream class at the specified index.\n\n \\param index Zero-based index of the stream class to query information about.\n \\param [out] input_stream_class_info If successful, information about the stream class is put here. Note that the strings in the structure\n must be freed (by the caller) using 'libCZI_Free'.\n\n \\returns An error-code indicating success or failure of the operation."]
1545 pub fn libCZI_GetStreamClassInfo(
1546 index: ::std::os::raw::c_int,
1547 input_stream_class_info: *mut InputStreamClassInfoInterop,
1548 ) -> LibCZIApiErrorCode;
1549}
1550unsafe extern "C" {
1551 #[doc = " Create an input stream object of the specified type, using the specified JSON-formatted property bag and\n the specified file identifier as input.\n\n \\param stream_class_name Name of the stream class to be instantiated.\n \\param creation_property_bag JSON formatted string (containing additional parameters for the stream creation) in UTF8-encoding.\n \\param stream_identifier The filename (or, more generally, a URI of some sort) identifying the file to be opened in UTF8-encoding.\n \\param [out] stream_object If successful, a handle representing the newly created stream object is put here.\n\n \\returns An error-code that indicates whether the operation is successful or not."]
1552 pub fn libCZI_CreateInputStream(
1553 stream_class_name: *const ::std::os::raw::c_char,
1554 creation_property_bag: *const ::std::os::raw::c_char,
1555 stream_identifier: *const ::std::os::raw::c_char,
1556 stream_object: *mut InputStreamObjectHandle,
1557 ) -> LibCZIApiErrorCode;
1558}
1559unsafe extern "C" {
1560 #[doc = " Create an input stream object for a file identified by its filename, which is given as a wide string. Note that wchar_t on\n Windows is 16-bit wide, and on Unix-like systems it is 32-bit wide.\n\n \\param [in] filename Filename of the file which is to be opened (zero terminated wide string). Note that on Windows, this\n is a string with 16-bit code units, and on Unix-like systems it is typically a string with 32-bit code units.\n\n \\param [out] stream_object The output stream object that will hold the created stream.\n \\return An error-code that indicates whether the operation is successful or not. Non-positive values indicates successful, positive values\n indicates unsuccessful operation."]
1561 pub fn libCZI_CreateInputStreamFromFileWide(
1562 filename: *const u32,
1563 stream_object: *mut InputStreamObjectHandle,
1564 ) -> LibCZIApiErrorCode;
1565}
1566unsafe extern "C" {
1567 #[doc = " Create an input stream object for a file identified by its filename, which is given as an UTF8-encoded string.\n\n \\param [in] filename Filename of the file which is to be opened (in UTF8 encoding).\n \\param [out] stream_object The output stream object that will hold the created stream.\n \\return An error-code that indicates whether the operation is successful or not. Non-positive values indicates successful, positive values\n indicates unsuccessful operation."]
1568 pub fn libCZI_CreateInputStreamFromFileUTF8(
1569 filename: *const ::std::os::raw::c_char,
1570 stream_object: *mut InputStreamObjectHandle,
1571 ) -> LibCZIApiErrorCode;
1572}
1573unsafe extern "C" {
1574 #[doc = " Create an input stream object which is using externally provided functions for operation\n and reading the data. Please refer to the documentation of\n 'ExternalInputStreamStructInterop' for more information.\n\n \\param external_input_stream_struct Structure containing the information about the externally provided functions.\n \\param [out] stream_object If successful, the handle to the newly created input stream object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1575 pub fn libCZI_CreateInputStreamFromExternal(
1576 external_input_stream_struct: *const ExternalInputStreamStructInterop,
1577 stream_object: *mut InputStreamObjectHandle,
1578 ) -> LibCZIApiErrorCode;
1579}
1580unsafe extern "C" {
1581 #[doc = " Release the specified input stream object. After this function is called, the handle is no\n longer valid. Note that calling this function will only decrement the usage count of the\n underlying object; whereas the object itself (and the resources it holds) will only be\n released when the usage count reaches zero.\n\n \\param stream_object The input stream object.\n\n \\returns An error-code indicating success or failure of the operation."]
1582 pub fn libCZI_ReleaseInputStream(stream_object: InputStreamObjectHandle) -> LibCZIApiErrorCode;
1583}
1584unsafe extern "C" {
1585 #[doc = " Create a bitmap object from the specified sub-block object. The bitmap object can be used to access the pixel\n data contained in the sub-block. If the subblock contains compressed data, then decompression will be performed\n in this call.\n\n \\param sub_block_object The sub-block object.\n \\param [out] bitmap_object If successful, the handle to the newly created bitmap object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1586 pub fn libCZI_SubBlockCreateBitmap(
1587 sub_block_object: SubBlockObjectHandle,
1588 bitmap_object: *mut BitmapObjectHandle,
1589 ) -> LibCZIApiErrorCode;
1590}
1591unsafe extern "C" {
1592 #[doc = " Get Information about the sub-block.\n\n \\param sub_block_object The sub-block object.\n \\param [out] sub_block_info If successful, information about the sub-block object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1593 pub fn libCZI_SubBlockGetInfo(
1594 sub_block_object: SubBlockObjectHandle,
1595 sub_block_info: *mut SubBlockInfoInterop,
1596 ) -> LibCZIApiErrorCode;
1597}
1598unsafe extern "C" {
1599 #[doc = " Copy the raw data from the specified sub-block object to the specified memory buffer. The value of the 'size' parameter\n on input is the size of the buffer pointed to by 'data'. On output, the value of 'size' is the actual size of the data. At most\n the initial value of 'size' bytes are copied to the buffer. If the initial value of 'size' is zero (0) or 'data' is null, then\n no data is copied.\n For the 'type' parameter, the following values are valid: 0 (data) and 1 (metadata).\n For 0 (data), the data is the raw pixel data of the bitmap. This data may be compressed.\n For 1 (metadata), the data is the raw metadata in XML-format (UTF8-encoded).\n\n \\param sub_block_object The sub block object.\n \\param type The type - 0 for \"pixel-data\", 1 for \"sub-block metadata\".\n \\param [in,out] size On input, the size of the memory block pointed to by 'data', on output the actual size of the available data.\n \\param [out] data Pointer where the data is to be copied to. At most the initial content of 'size' bytes are copied.\n\n \\returns An error-code indicating success or failure of the operation."]
1600 pub fn libCZI_SubBlockGetRawData(
1601 sub_block_object: SubBlockObjectHandle,
1602 type_: ::std::os::raw::c_int,
1603 size: *mut ::std::os::raw::c_ulong,
1604 data: *mut ::std::os::raw::c_void,
1605 ) -> LibCZIApiErrorCode;
1606}
1607unsafe extern "C" {
1608 #[doc = " Release the specified sub-block object.\n\n \\param sub_block_object The sub block object to be released.\n\n \\returns An error-code indicating success or failure of the operation."]
1609 pub fn libCZI_ReleaseSubBlock(sub_block_object: SubBlockObjectHandle) -> LibCZIApiErrorCode;
1610}
1611unsafe extern "C" {
1612 #[doc = " Get information about the sub-block with the specified index. The information is put into the 'sub_block_info_interop' structure.\n If the index is not valid, then the function returns 'LibCZIApi_ErrorCode_IndexOutOfRange'.\n\n \\param reader_object The reader object.\n \\param index The index of the attachment to query information for.\n \\param [out] sub_block_info_interop If successful, the retrieved information is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1613 pub fn libCZI_TryGetSubBlockInfoForIndex(
1614 reader_object: CziReaderObjectHandle,
1615 index: ::std::os::raw::c_int,
1616 sub_block_info_interop: *mut SubBlockInfoInterop,
1617 ) -> LibCZIApiErrorCode;
1618}
1619unsafe extern "C" {
1620 #[doc = " Get information about the specified attachment object.\n \\param attachment_object The attachment object.\n \\param [out] attachment_info Information about the attachment.\n \\returns An error-code indicating success or failure of the operation."]
1621 pub fn libCZI_AttachmentGetInfo(
1622 attachment_object: AttachmentObjectHandle,
1623 attachment_info: *mut AttachmentInfoInterop,
1624 ) -> LibCZIApiErrorCode;
1625}
1626unsafe extern "C" {
1627 #[doc = " Copy the raw data from the specified attachment object to the specified memory buffer. The value of the 'size' parameter\n on input is the size of the buffer pointed to by 'data'. On output, the value of 'size' is the actual size of the data. At most\n the initial value of 'size' bytes are copied to the buffer. If the initial value of 'size' is zero (0) or 'data' is null, then\n no data is copied.\n \\param attachment_object The attachment object.\n \\param [in,out] size On input, the size of the memory block pointed to by 'data', on output the actual size of the available data.\n \\param [out] data Pointer where the data is to be copied to. At most the initial content of 'size' bytes are copied.\n\n \\returns An error-code indicating success or failure of the operation."]
1628 pub fn libCZI_AttachmentGetRawData(
1629 attachment_object: AttachmentObjectHandle,
1630 size: *mut ::std::os::raw::c_ulong,
1631 data: *mut ::std::os::raw::c_void,
1632 ) -> LibCZIApiErrorCode;
1633}
1634unsafe extern "C" {
1635 #[doc = " Release the specified attachment object.\n\n \\param attachment_object The attachment object to be released.\n\n \\returns An error-code indicating success or failure of the operation."]
1636 pub fn libCZI_ReleaseAttachment(
1637 attachment_object: AttachmentObjectHandle,
1638 ) -> LibCZIApiErrorCode;
1639}
1640unsafe extern "C" {
1641 #[doc = " Get information about the specified bitmap object.\n\n \\param bitmap_object The bitmap object.\n \\param [out] bitmap_info If successful, information about the bitmap object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1642 pub fn libCZI_BitmapGetInfo(
1643 bitmap_object: BitmapObjectHandle,
1644 bitmap_info: *mut BitmapInfoInterop,
1645 ) -> LibCZIApiErrorCode;
1646}
1647unsafe extern "C" {
1648 #[doc = " Locks the bitmap object. Once the bitmap is locked, the pixel data can be accessed. Memory access to the\n pixel data must only occur while the bitmap is locked. The lock must be released by calling 'libCZI_BitmapUnlock'.\n It is a fatal error if the bitmap is destroyed while still being locked. Calls to Lock and Unlock are counted, and\n they must be balanced.\n\n \\param bitmap_object The bitmap object.\n \\param [out] lockInfo If successful, information about how to access the pixel data is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1649 pub fn libCZI_BitmapLock(
1650 bitmap_object: BitmapObjectHandle,
1651 lockInfo: *mut BitmapLockInfoInterop,
1652 ) -> LibCZIApiErrorCode;
1653}
1654unsafe extern "C" {
1655 #[doc = " Unlock the bitmap object. Once the bitmap is unlocked, the pixel data must not be accessed anymore.\n\n \\param bitmap_object The bitmap object.\n\n \\returns An error-code indicating success or failure of the operation."]
1656 pub fn libCZI_BitmapUnlock(bitmap_object: BitmapObjectHandle) -> LibCZIApiErrorCode;
1657}
1658unsafe extern "C" {
1659 #[doc = " Copy the pixel data from the specified bitmap object to the specified memory buffer. The specified\n destination bitmap must have same width, height and pixel type as the source bitmap.\n\n \\param bitmap_object The bitmap object.\n \\param width The width of the destination bitmap.\n \\param height The height of the destination bitmap.\n \\param pixel_type The pixel type.\n \\param stride The stride (given in bytes).\n \\param [out] ptr Pointer to the memory location where the bitmap is to be copied to.\n\n \\returns A LibCZIApiErrorCode."]
1660 pub fn libCZI_BitmapCopyTo(
1661 bitmap_object: BitmapObjectHandle,
1662 width: ::std::os::raw::c_uint,
1663 height: ::std::os::raw::c_uint,
1664 pixel_type: ::std::os::raw::c_int,
1665 stride: ::std::os::raw::c_uint,
1666 ptr: *mut ::std::os::raw::c_void,
1667 ) -> LibCZIApiErrorCode;
1668}
1669unsafe extern "C" {
1670 #[doc = " Release the specified bitmap object.\n It is a fatal error trying to release a bitmap object that is still locked.\n\n \\param bitmap_object The bitmap object.\n\n \\returns An error-code indicating success or failure of the operation."]
1671 pub fn libCZI_ReleaseBitmap(bitmap_object: BitmapObjectHandle) -> LibCZIApiErrorCode;
1672}
1673unsafe extern "C" {
1674 #[doc = " Get the XML-metadata information from the specified metadata-segment object.\n Note that the XML-metadata is returned as a pointer to the data (in the 'data' field of the 'MetadataAsXmlInterop' structure), which\n must be freed by the caller using 'libCZI_Free'.\n\n \\param metadata_segment_object The metadata segment object.\n \\param [out] metadata_as_xml_interop If successful, the XML-metadata information is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1675 pub fn libCZI_MetadataSegmentGetMetadataAsXml(
1676 metadata_segment_object: MetadataSegmentObjectHandle,
1677 metadata_as_xml_interop: *mut MetadataAsXmlInterop,
1678 ) -> LibCZIApiErrorCode;
1679}
1680unsafe extern "C" {
1681 #[doc = " Create a CZI-document-information object from the specified metadata-segment object.\n\n \\param metadata_segment_object The metadata segment object.\n \\param [in,out] czi_document_info If successful, a handle to the newly created CZI-document-info object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1682 pub fn libCZI_MetadataSegmentGetCziDocumentInfo(
1683 metadata_segment_object: MetadataSegmentObjectHandle,
1684 czi_document_info: *mut CziDocumentInfoHandle,
1685 ) -> LibCZIApiErrorCode;
1686}
1687unsafe extern "C" {
1688 #[doc = " Release the specified metadata-segment object.\n\n \\param metadata_segment_object The metadata-segment object to be released.\n\n \\returns An error-code indicating success or failure of the operation."]
1689 pub fn libCZI_ReleaseMetadataSegment(
1690 metadata_segment_object: MetadataSegmentObjectHandle,
1691 ) -> LibCZIApiErrorCode;
1692}
1693unsafe extern "C" {
1694 #[doc = " Get \"general document information\" from the specified czi-document information object. The information is returned as a JSON-formatted string.\n The JSON returned is an object, with the following possible key-value pairs:\n \"name\" : \"<name of the document>\", type string\n \"title\" : \"<title of the document>\", type string\n \"user_name\" : \"<user name>\", type string\n \"description\" : \"<description>\", type string\n \"comment\" : \"<comment>\", type string\n \"keywords\" : \"<keyword1>,<keyword2>,...\", type string\n \"rating\" : \"<rating>\", type integer\n \"creation_date\" : \"<creation date>\", type string, conforming to ISO 8601\n\n \\param czi_document_info The CZI-document-info object.\n \\param [out] general_document_info_json If successful, the general document information is put here. Note that the data must be freed using 'libCZI_Free' by the caller.\n\n \\returns An error-code indicating success or failure of the operation."]
1695 pub fn libCZI_CziDocumentInfoGetGeneralDocumentInfo(
1696 czi_document_info: CziDocumentInfoHandle,
1697 general_document_info_json: *mut *mut ::std::os::raw::c_void,
1698 ) -> LibCZIApiErrorCode;
1699}
1700unsafe extern "C" {
1701 #[doc = " Get scaling information from the specified czi-document information object. The information gives the size of an image pixels.\n\n \\param czi_document_info Handle to the CZI-document-info object from which the scaling information will be retrieved.\n \\param [out] scaling_info_interop If successful, the scaling information is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1702 pub fn libCZI_CziDocumentInfoGetScalingInfo(
1703 czi_document_info: CziDocumentInfoHandle,
1704 scaling_info_interop: *mut ScalingInfoInterop,
1705 ) -> LibCZIApiErrorCode;
1706}
1707unsafe extern "C" {
1708 #[doc = " Retrieve the set of dimensions for which \"dimension info\" data is available. The argument 'available_dimensions_count' indicates the number of\n elements available, and this should be 'kMaxDimensionCount+1' at least. If the number of available dimensions is insufficient, the function will\n return an error (LibCZIApi_ErrorCode_InvalidArgument). The 'available_dimensions' array is filled with the available dimensions, and the list is\n terminated with a value of 'kInvalidDimensionIndex'.\n\n \\param czi_document_info The CZI-document-info object.\n \\param available_dimensions_count Number of elements available in the 'available_dimensions' array.\n \\param [in,out] available_dimensions If successful, the available dimensions are put here. The list is terminated with a value of 'kInvalidDimensionIndex'.\n\n \\returns An error-code indicating success or failure of the operation."]
1709 pub fn libCZI_CziDocumentInfoGetAvailableDimension(
1710 czi_document_info: CziDocumentInfoHandle,
1711 available_dimensions_count: ::std::os::raw::c_uint,
1712 available_dimensions: *mut ::std::os::raw::c_uint,
1713 ) -> LibCZIApiErrorCode;
1714}
1715unsafe extern "C" {
1716 #[doc = " Get the display-settings from the document's XML-metadata. The display-settings are returned in the form of an object,\n for which a handle is returned.\n\n \\param czi_document_info The CZI-document-info object.\n \\param [in,out] display_settings_handle If successful, a handle to the display-settings object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1717 pub fn libCZI_CziDocumentInfoGetDisplaySettings(
1718 czi_document_info: CziDocumentInfoHandle,
1719 display_settings_handle: *mut DisplaySettingsHandle,
1720 ) -> LibCZIApiErrorCode;
1721}
1722unsafe extern "C" {
1723 #[doc = " Get the dimension information from the document's XML-metadata. The information is returned as a JSON-formatted string.\n\n \\param czi_document_info Handle to the CZI-document-info object from which the dimension information will be retrieved.\n \\param dimension_index Index of the dimension.\n \\param [out] dimension_info_json If successful, the information is put here as JSON format. Note that the data must be freed using 'libCZI_Free' by the caller.\n\n \\returns An error-code indicating success or failure of the operation."]
1724 pub fn libCZI_CziDocumentInfoGetDimensionInfo(
1725 czi_document_info: CziDocumentInfoHandle,
1726 dimension_index: ::std::os::raw::c_uint,
1727 dimension_info_json: *mut *mut ::std::os::raw::c_void,
1728 ) -> LibCZIApiErrorCode;
1729}
1730unsafe extern "C" {
1731 #[doc = " Release the specified CZI-document-info object.\n\n \\param czi_document_info The CZI-document-info object.\n\n \\returns An error-code indicating success or failure of the operation."]
1732 pub fn libCZI_ReleaseCziDocumentInfo(
1733 czi_document_info: CziDocumentInfoHandle,
1734 ) -> LibCZIApiErrorCode;
1735}
1736unsafe extern "C" {
1737 #[doc = " Create an output stream object for a file identified by its filename, which is given as a wide string. Note that wchar_t on\n Windows is 16-bit wide, and on Unix-like systems it is 32-bit wide.\n\n \\param filename Filename of the file which is to be opened (zero terminated wide string). Note that on Windows, this\n is a string with 16-bit code units, and on Unix-like systems it is typically a string with 32-bit code units.\n \\param overwrite Indicates whether the file should be overwritten.\n \\param [out] output_stream_object The output stream object that will hold the created stream.\n\n \\return An error-code that indicates whether the operation is successful or not. Non-positive values indicates successful, positive values\n indicates unsuccessful operation."]
1738 pub fn libCZI_CreateOutputStreamForFileWide(
1739 filename: *const u32,
1740 overwrite: bool,
1741 output_stream_object: *mut OutputStreamObjectHandle,
1742 ) -> LibCZIApiErrorCode;
1743}
1744unsafe extern "C" {
1745 #[doc = " Create an input stream object for a file identified by its filename, which is given as an UTF8 - encoded string.\n\n \\param filename Filename of the file which is to be opened (in UTF8 encoding).\n \\param overwrite Indicates whether the file should be overwritten.\n \\param [out] output_stream_object The output stream object that will hold the created stream.\n\n \\return An error-code that indicates whether the operation is successful or not. Non-positive values indicates successful, positive values\n indicates unsuccessful operation."]
1746 pub fn libCZI_CreateOutputStreamForFileUTF8(
1747 filename: *const ::std::os::raw::c_char,
1748 overwrite: bool,
1749 output_stream_object: *mut OutputStreamObjectHandle,
1750 ) -> LibCZIApiErrorCode;
1751}
1752unsafe extern "C" {
1753 #[doc = " Release the specified output stream object. After this function is called, the handle is no\n longer valid. Note that calling this function will only decrement the usage count of the\n underlying object; whereas the object itself (and the resources it holds) will only be\n released when the usage count reaches zero.\n\n \\param output_stream_object The output stream object.\n\n \\returns An error-code indicating success or failure of the operation."]
1754 pub fn libCZI_ReleaseOutputStream(
1755 output_stream_object: OutputStreamObjectHandle,
1756 ) -> LibCZIApiErrorCode;
1757}
1758unsafe extern "C" {
1759 #[doc = " Create an output stream object which is using externally provided functions for operation\n and writing the data. Please refer to the documentation of\n 'ExternalOutputStreamStructInterop' for more information.\n\n \\param external_output_stream_struct Structure containing the information about the externally provided functions.\n \\param [out] output_stream_object If successful, the handle to the newly created output stream object is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1760 pub fn libCZI_CreateOutputStreamFromExternal(
1761 external_output_stream_struct: *const ExternalOutputStreamStructInterop,
1762 output_stream_object: *mut OutputStreamObjectHandle,
1763 ) -> LibCZIApiErrorCode;
1764}
1765unsafe extern "C" {
1766 #[doc = " Create a writer object for authoring a document in CZI-format. The options string is a JSON-formatted string, here\n is an example:\n \\code\n {\n \"allow_duplicate_subblocks\" : true\n }\n \\endcode\n\n \\param [out] writer_object If the operation is successful, a handle to the newly created writer object is put here.\n \\param options A JSON-formatted zero-terminated string (in UTF8-encoding) containing options for the writer creation.\n\n \\returns An error-code indicating success or failure of the operation."]
1767 pub fn libCZI_CreateWriter(
1768 writer_object: *mut CziWriterObjectHandle,
1769 options: *const ::std::os::raw::c_char,
1770 ) -> LibCZIApiErrorCode;
1771}
1772unsafe extern "C" {
1773 #[doc = " Initializes the writer object with the specified output stream object. The options string is a JSON-formatted string, here\n is an example:\n \\code\n {\n \"file_guid\" : \"123e4567-e89b-12d3-a456-426614174000\",\n \"reserved_size_attachments_directory\" : 4096,\n \"reserved_size_metadata_segment\" : 50000,\n \"minimum_m_index\" : 0,\n \"maximum_m_index\" : 100\n }\n \\endcode\n\n \\param [out] writer_object If the operation is successful, a handle to the newly created writer object is put here.\n \\param output_stream_object The output stream object to be used for writing the CZI data.\n \\param parameters A JSON-formatted zero-terminated string (in UTF8-encoding) containing options for the writer initialization.\n\n \\returns An error-code indicating success or failure of the operation."]
1774 pub fn libCZI_WriterCreate(
1775 writer_object: CziWriterObjectHandle,
1776 output_stream_object: OutputStreamObjectHandle,
1777 parameters: *const ::std::os::raw::c_char,
1778 ) -> LibCZIApiErrorCode;
1779}
1780unsafe extern "C" {
1781 #[doc = " Add the specified sub-block to the writer object. The sub-block information is provided in the 'add_sub_block_info_interop' structure.\n\n \\param writer_object The writer object.\n \\param add_sub_block_info_interop Information describing the sub-block to be added.\n\n \\returns An error-code indicating success or failure of the operation."]
1782 pub fn libCZI_WriterAddSubBlock(
1783 writer_object: CziWriterObjectHandle,
1784 add_sub_block_info_interop: *const AddSubBlockInfoInterop,
1785 ) -> LibCZIApiErrorCode;
1786}
1787unsafe extern "C" {
1788 #[doc = " Add the specified attachment to the writer object. The attachment is provided in the 'add_attachment_info_interop' structure.\n\n \\param writer_object The writer object.\n \\param add_attachment_info_interop Information describing the attachment to be added.\n\n \\returns An error-code indicating success or failure of the operation."]
1789 pub fn libCZI_WriterAddAttachment(
1790 writer_object: CziWriterObjectHandle,
1791 add_attachment_info_interop: *const AddAttachmentInfoInterop,
1792 ) -> LibCZIApiErrorCode;
1793}
1794unsafe extern "C" {
1795 #[doc = " Add the specified metadata to the writer object. The metadata is provided in the 'write_metadata_info_interop' structure.\n\n \\param writer_object Handle to the writer object to which the metadata will be added.\n \\param write_metadata_info_interop Information describing the metadata to be added.\n\n \\returns An error-code indicating success or failure of the operation."]
1796 pub fn libCZI_WriterWriteMetadata(
1797 writer_object: CziWriterObjectHandle,
1798 write_metadata_info_interop: *const WriteMetadataInfoInterop,
1799 ) -> LibCZIApiErrorCode;
1800}
1801unsafe extern "C" {
1802 #[doc = " Finalizes the CZI (i.e. writes out the final directory-segments) and closes the file.\n Note that this method must be called explicitly in order to get a valid CZI - calling 'libCZI_ReleaseWriter' without\n a prior call to this method will close the file immediately without finalization.\n\n \\param writer_object Handle to the writer object that is to be closed.\n\n \\returns An error-code indicating success or failure of the operation."]
1803 pub fn libCZI_WriterClose(writer_object: CziWriterObjectHandle) -> LibCZIApiErrorCode;
1804}
1805unsafe extern "C" {
1806 #[doc = " Release the specified writer object.\n\n \\param writer_object Handle to the writer object that is to be released.\n\n \\returns An error-code indicating success or failure of the operation."]
1807 pub fn libCZI_ReleaseWriter(writer_object: CziWriterObjectHandle) -> LibCZIApiErrorCode;
1808}
1809unsafe extern "C" {
1810 #[doc = " Create a single channel scaling tile accessor.\n\n \\param reader_object A handle representing the reader-object.\n \\param accessor_object [out] If the operation is successful, a handle to the newly created single-channel-scaling-tile-accessor is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1811 pub fn libCZI_CreateSingleChannelTileAccessor(
1812 reader_object: CziReaderObjectHandle,
1813 accessor_object: *mut SingleChannelScalingTileAccessorObjectHandle,
1814 ) -> LibCZIApiErrorCode;
1815}
1816unsafe extern "C" {
1817 #[doc = " Gets the size information of the specified tile accessor based on the region of interest and zoom factor.\n\n \\param accessor_object Handle to the tile accessor object for which the size is to be calculated. This object is responsible for managing the access to the tiles within the specified plane.\n \\param roi The region of interest that defines the region of interest within the plane for which the size is to be calculated.\n \\param zoom A floating-point value representing the zoom factor.\n \\param size [out] The size of the tile accessor. It contains width and height information.\n\n \\returns An error-code indicating success or failure of the operation."]
1818 pub fn libCZI_SingleChannelTileAccessorCalcSize(
1819 accessor_object: SingleChannelScalingTileAccessorObjectHandle,
1820 roi: *const IntRectInterop,
1821 zoom: f32,
1822 size: *mut IntSizeInterop,
1823 ) -> LibCZIApiErrorCode;
1824}
1825unsafe extern "C" {
1826 #[doc = " Gets the tile bitmap of the specified plane and the specified roi with the specified zoom factor.\n\n \\param accessor_object Handle to the tile accessor object. This object is responsible for managing the access to the tiles within the specified plane.\n \\param coordinate Pointer to a `CoordinateInterop` structure that specifies the coordinates within the plane from which the tile bitmap is to be retrieved.\n \\param roi The region of interest that defines within the plane for which the tile bitmap is requested.\n \\param zoom A floating-point value representing the zoom factor.\n \\param options A pointer to an AccessorOptionsInterop structure that may contain additional options for accessing the tile bitmap.\n \\param bitmap_object [out] If the operation is successful, the created bitmap object will be put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1827 pub fn libCZI_SingleChannelTileAccessorGet(
1828 accessor_object: SingleChannelScalingTileAccessorObjectHandle,
1829 coordinate: *const CoordinateInterop,
1830 roi: *const IntRectInterop,
1831 zoom: f32,
1832 options: *const AccessorOptionsInterop,
1833 bitmap_object: *mut BitmapObjectHandle,
1834 ) -> LibCZIApiErrorCode;
1835}
1836unsafe extern "C" {
1837 #[doc = " Release the specified accessor object.\n\n \\param accessor_object The accessor object.\n\n \\returns An error-code indicating success or failure of the operation."]
1838 pub fn libCZI_ReleaseCreateSingleChannelTileAccessor(
1839 accessor_object: SingleChannelScalingTileAccessorObjectHandle,
1840 ) -> LibCZIApiErrorCode;
1841}
1842unsafe extern "C" {
1843 #[doc = " Given a display-settings object and the channel-number, this function fills out the\n composition-channel-information which is needed for the multi-channel-composition.\n Note that in the returned 'CompositionChannelInfoInterop' structure, the 'lut' field is a pointer to the LUT-data,\n which must be freed with 'libCZI_Free' by the caller.\n\n \\param display_settings_handle The display settings handle.\n \\param channel_index The channel-index (referring to the display settings object) we are concerned with.\n \\param sixteen_or_eight_bits_lut True for generating a 16-bit LUT; if false, then an 8-bit LUT is generated.\n \\param [out] composition_channel_info_interop The composition channel information is put here.\n\n \\returns An error-code indicating success or failure of the operation."]
1844 pub fn libCZI_CompositorFillOutCompositionChannelInfoInterop(
1845 display_settings_handle: DisplaySettingsHandle,
1846 channel_index: ::std::os::raw::c_int,
1847 sixteen_or_eight_bits_lut: bool,
1848 composition_channel_info_interop: *mut CompositionChannelInfoInterop,
1849 ) -> LibCZIApiErrorCode;
1850}
1851unsafe extern "C" {
1852 #[doc = " Perform a multi-channel-composition operation. The source bitmaps are provided in the 'source_bitmaps' array, and the\n array of 'CompositionChannelInfoInterop' structures provide the information needed for the composition. The resulting bitmap\n is then put into the 'bitmap_object' handle.\n\n \\param channelCount The number of channels - this defines the size of the 'source_bitmaps' and 'channel_info' arrays.\n \\param source_bitmaps The array of source bitmaps.\n \\param channel_info The array of channel information.\n \\param [out] bitmap_object The resulting bitmap is put here.\n\n \\return An error-code indicating success or failure of the operation."]
1853 pub fn libCZI_CompositorDoMultiChannelComposition(
1854 channelCount: ::std::os::raw::c_int,
1855 source_bitmaps: *const BitmapObjectHandle,
1856 channel_info: *const CompositionChannelInfoInterop,
1857 bitmap_object: *mut BitmapObjectHandle,
1858 ) -> LibCZIApiErrorCode;
1859}
1860unsafe extern "C" {
1861 pub fn libCZI_DisplaySettingsGetChannelDisplaySettings(
1862 display_settings_handle: DisplaySettingsHandle,
1863 channel_id: ::std::os::raw::c_int,
1864 channel_display_setting: *mut ChannelDisplaySettingsHandle,
1865 ) -> LibCZIApiErrorCode;
1866}
1867unsafe extern "C" {
1868 #[doc = " Release the specified display settings object.\n\n \\param display_settings_handle The display settings object.\n\n \\returns An error-code indicating success or failure of the operation."]
1869 pub fn libCZI_ReleaseDisplaySettings(
1870 display_settings_handle: DisplaySettingsHandle,
1871 ) -> LibCZIApiErrorCode;
1872}
1873unsafe extern "C" {
1874 #[doc = " Release the specified channel-display settings object.\n\n \\param channel_display_settings_handle The channel-display settings object.\n\n \\returns An error-code indicating success or failure of the operation."]
1875 pub fn libCZI_ReleaseChannelDisplaySettings(
1876 channel_display_settings_handle: ChannelDisplaySettingsHandle,
1877 ) -> LibCZIApiErrorCode;
1878}