1#![allow(non_upper_case_globals)]
2#![allow(non_camel_case_types)]
3#![allow(non_snake_case)]
4pub const __DARWIN_ONLY_64_BIT_INO_T: u32 = 0;
7pub const __DARWIN_ONLY_VERS_1050: u32 = 0;
8pub const __DARWIN_ONLY_UNIX_CONFORMANCE: u32 = 1;
9pub const __DARWIN_UNIX03: u32 = 1;
10pub const __DARWIN_64_BIT_INO_T: u32 = 1;
11pub const __DARWIN_VERS_1050: u32 = 1;
12pub const __DARWIN_NON_CANCELABLE: u32 = 0;
13pub const __DARWIN_SUF_64_BIT_INO_T: &'static [u8; 9usize] = b"$INODE64\0";
14pub const __DARWIN_SUF_1050: &'static [u8; 6usize] = b"$1050\0";
15pub const __DARWIN_SUF_EXTSN: &'static [u8; 14usize] = b"$DARWIN_EXTSN\0";
16pub const __DARWIN_C_ANSI: u32 = 4096;
17pub const __DARWIN_C_FULL: u32 = 900000;
18pub const __DARWIN_C_LEVEL: u32 = 900000;
19pub const __STDC_WANT_LIB_EXT1__: u32 = 1;
20pub const __DARWIN_NO_LONG_LONG: u32 = 0;
21pub const _DARWIN_FEATURE_64_BIT_INODE: u32 = 1;
22pub const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE: u32 = 1;
23pub const _DARWIN_FEATURE_UNIX_CONFORMANCE: u32 = 3;
24pub const __API_TO_BE_DEPRECATED: u32 = 100000;
25pub const __MAC_10_0: u32 = 1000;
26pub const __MAC_10_1: u32 = 1010;
27pub const __MAC_10_2: u32 = 1020;
28pub const __MAC_10_3: u32 = 1030;
29pub const __MAC_10_4: u32 = 1040;
30pub const __MAC_10_5: u32 = 1050;
31pub const __MAC_10_6: u32 = 1060;
32pub const __MAC_10_7: u32 = 1070;
33pub const __MAC_10_8: u32 = 1080;
34pub const __MAC_10_9: u32 = 1090;
35pub const __MAC_10_10: u32 = 101000;
36pub const __MAC_10_10_2: u32 = 101002;
37pub const __MAC_10_10_3: u32 = 101003;
38pub const __MAC_10_11: u32 = 101100;
39pub const __MAC_10_11_2: u32 = 101102;
40pub const __MAC_10_11_3: u32 = 101103;
41pub const __MAC_10_11_4: u32 = 101104;
42pub const __MAC_10_12: u32 = 101200;
43pub const __MAC_10_12_1: u32 = 101201;
44pub const __MAC_10_12_2: u32 = 101202;
45pub const __MAC_10_12_4: u32 = 101204;
46pub const __MAC_10_13: u32 = 101300;
47pub const __MAC_10_13_1: u32 = 101301;
48pub const __MAC_10_13_2: u32 = 101302;
49pub const __MAC_10_13_4: u32 = 101304;
50pub const __MAC_10_14: u32 = 101400;
51pub const __MAC_10_14_1: u32 = 101401;
52pub const __MAC_10_14_4: u32 = 101404;
53pub const __MAC_10_15: u32 = 101500;
54pub const __MAC_10_15_1: u32 = 101501;
55pub const __MAC_10_15_4: u32 = 101504;
56pub const __IPHONE_2_0: u32 = 20000;
57pub const __IPHONE_2_1: u32 = 20100;
58pub const __IPHONE_2_2: u32 = 20200;
59pub const __IPHONE_3_0: u32 = 30000;
60pub const __IPHONE_3_1: u32 = 30100;
61pub const __IPHONE_3_2: u32 = 30200;
62pub const __IPHONE_4_0: u32 = 40000;
63pub const __IPHONE_4_1: u32 = 40100;
64pub const __IPHONE_4_2: u32 = 40200;
65pub const __IPHONE_4_3: u32 = 40300;
66pub const __IPHONE_5_0: u32 = 50000;
67pub const __IPHONE_5_1: u32 = 50100;
68pub const __IPHONE_6_0: u32 = 60000;
69pub const __IPHONE_6_1: u32 = 60100;
70pub const __IPHONE_7_0: u32 = 70000;
71pub const __IPHONE_7_1: u32 = 70100;
72pub const __IPHONE_8_0: u32 = 80000;
73pub const __IPHONE_8_1: u32 = 80100;
74pub const __IPHONE_8_2: u32 = 80200;
75pub const __IPHONE_8_3: u32 = 80300;
76pub const __IPHONE_8_4: u32 = 80400;
77pub const __IPHONE_9_0: u32 = 90000;
78pub const __IPHONE_9_1: u32 = 90100;
79pub const __IPHONE_9_2: u32 = 90200;
80pub const __IPHONE_9_3: u32 = 90300;
81pub const __IPHONE_10_0: u32 = 100000;
82pub const __IPHONE_10_1: u32 = 100100;
83pub const __IPHONE_10_2: u32 = 100200;
84pub const __IPHONE_10_3: u32 = 100300;
85pub const __IPHONE_11_0: u32 = 110000;
86pub const __IPHONE_11_1: u32 = 110100;
87pub const __IPHONE_11_2: u32 = 110200;
88pub const __IPHONE_11_3: u32 = 110300;
89pub const __IPHONE_11_4: u32 = 110400;
90pub const __IPHONE_12_0: u32 = 120000;
91pub const __IPHONE_12_1: u32 = 120100;
92pub const __IPHONE_12_2: u32 = 120200;
93pub const __IPHONE_12_3: u32 = 120300;
94pub const __IPHONE_13_0: u32 = 130000;
95pub const __IPHONE_13_1: u32 = 130100;
96pub const __IPHONE_13_2: u32 = 130200;
97pub const __IPHONE_13_3: u32 = 130300;
98pub const __IPHONE_13_4: u32 = 130400;
99pub const __TVOS_9_0: u32 = 90000;
100pub const __TVOS_9_1: u32 = 90100;
101pub const __TVOS_9_2: u32 = 90200;
102pub const __TVOS_10_0: u32 = 100000;
103pub const __TVOS_10_0_1: u32 = 100001;
104pub const __TVOS_10_1: u32 = 100100;
105pub const __TVOS_10_2: u32 = 100200;
106pub const __TVOS_11_0: u32 = 110000;
107pub const __TVOS_11_1: u32 = 110100;
108pub const __TVOS_11_2: u32 = 110200;
109pub const __TVOS_11_3: u32 = 110300;
110pub const __TVOS_11_4: u32 = 110400;
111pub const __TVOS_12_0: u32 = 120000;
112pub const __TVOS_12_1: u32 = 120100;
113pub const __TVOS_12_2: u32 = 120200;
114pub const __TVOS_12_3: u32 = 120300;
115pub const __TVOS_13_0: u32 = 130000;
116pub const __TVOS_13_2: u32 = 130200;
117pub const __TVOS_13_3: u32 = 130300;
118pub const __TVOS_13_4: u32 = 130400;
119pub const __WATCHOS_1_0: u32 = 10000;
120pub const __WATCHOS_2_0: u32 = 20000;
121pub const __WATCHOS_2_1: u32 = 20100;
122pub const __WATCHOS_2_2: u32 = 20200;
123pub const __WATCHOS_3_0: u32 = 30000;
124pub const __WATCHOS_3_1: u32 = 30100;
125pub const __WATCHOS_3_1_1: u32 = 30101;
126pub const __WATCHOS_3_2: u32 = 30200;
127pub const __WATCHOS_4_0: u32 = 40000;
128pub const __WATCHOS_4_1: u32 = 40100;
129pub const __WATCHOS_4_2: u32 = 40200;
130pub const __WATCHOS_4_3: u32 = 40300;
131pub const __WATCHOS_5_0: u32 = 50000;
132pub const __WATCHOS_5_1: u32 = 50100;
133pub const __WATCHOS_5_2: u32 = 50200;
134pub const __WATCHOS_6_0: u32 = 60000;
135pub const __WATCHOS_6_1: u32 = 60100;
136pub const __WATCHOS_6_2: u32 = 60200;
137pub const __DRIVERKIT_19_0: u32 = 190000;
138pub const __MAC_OS_X_VERSION_MAX_ALLOWED: u32 = 101500;
139pub const __ENABLE_LEGACY_MAC_AVAILABILITY: u32 = 1;
140pub const __PTHREAD_SIZE__: u32 = 8176;
141pub const __PTHREAD_ATTR_SIZE__: u32 = 56;
142pub const __PTHREAD_MUTEXATTR_SIZE__: u32 = 8;
143pub const __PTHREAD_MUTEX_SIZE__: u32 = 56;
144pub const __PTHREAD_CONDATTR_SIZE__: u32 = 8;
145pub const __PTHREAD_COND_SIZE__: u32 = 40;
146pub const __PTHREAD_ONCE_SIZE__: u32 = 8;
147pub const __PTHREAD_RWLOCK_SIZE__: u32 = 192;
148pub const __PTHREAD_RWLOCKATTR_SIZE__: u32 = 16;
149pub const __DARWIN_WCHAR_MIN: i32 = -2147483648;
150pub const _FORTIFY_SOURCE: u32 = 2;
151pub const RENAME_SECLUDE: u32 = 1;
152pub const RENAME_SWAP: u32 = 2;
153pub const RENAME_EXCL: u32 = 4;
154pub const __SLBF: u32 = 1;
155pub const __SNBF: u32 = 2;
156pub const __SRD: u32 = 4;
157pub const __SWR: u32 = 8;
158pub const __SRW: u32 = 16;
159pub const __SEOF: u32 = 32;
160pub const __SERR: u32 = 64;
161pub const __SMBF: u32 = 128;
162pub const __SAPP: u32 = 256;
163pub const __SSTR: u32 = 512;
164pub const __SOPT: u32 = 1024;
165pub const __SNPT: u32 = 2048;
166pub const __SOFF: u32 = 4096;
167pub const __SMOD: u32 = 8192;
168pub const __SALC: u32 = 16384;
169pub const __SIGN: u32 = 32768;
170pub const _IOFBF: u32 = 0;
171pub const _IOLBF: u32 = 1;
172pub const _IONBF: u32 = 2;
173pub const BUFSIZ: u32 = 1024;
174pub const EOF: i32 = -1;
175pub const FOPEN_MAX: u32 = 20;
176pub const FILENAME_MAX: u32 = 1024;
177pub const P_tmpdir: &'static [u8; 10usize] = b"/var/tmp/\0";
178pub const L_tmpnam: u32 = 1024;
179pub const TMP_MAX: u32 = 308915776;
180pub const SEEK_SET: u32 = 0;
181pub const SEEK_CUR: u32 = 1;
182pub const SEEK_END: u32 = 2;
183pub const L_ctermid: u32 = 1024;
184pub const _USE_FORTIFY_LEVEL: u32 = 2;
185pub const JPEG_LIB_VERSION: u32 = 62;
186pub const LIBJPEG_TURBO_VERSION_NUMBER: u32 = 2000004;
187pub const C_ARITH_CODING_SUPPORTED: u32 = 1;
188pub const D_ARITH_CODING_SUPPORTED: u32 = 1;
189pub const MEM_SRCDST_SUPPORTED: u32 = 1;
190pub const WITH_SIMD: u32 = 1;
191pub const BITS_IN_JSAMPLE: u32 = 8;
192pub const HAVE_LOCALE_H: u32 = 1;
193pub const HAVE_STDDEF_H: u32 = 1;
194pub const HAVE_STDLIB_H: u32 = 1;
195pub const NEED_SYS_TYPES_H: u32 = 1;
196pub const HAVE_UNSIGNED_CHAR: u32 = 1;
197pub const HAVE_UNSIGNED_SHORT: u32 = 1;
198pub const MAX_COMPONENTS: u32 = 10;
199pub const MAXJSAMPLE: u32 = 255;
200pub const CENTERJSAMPLE: u32 = 128;
201pub const JPEG_MAX_DIMENSION: u32 = 65500;
202pub const FALSE: u32 = 0;
203pub const TRUE: u32 = 1;
204pub const DCTSIZE: u32 = 8;
205pub const DCTSIZE2: u32 = 64;
206pub const NUM_QUANT_TBLS: u32 = 4;
207pub const NUM_HUFF_TBLS: u32 = 4;
208pub const NUM_ARITH_TBLS: u32 = 16;
209pub const MAX_COMPS_IN_SCAN: u32 = 4;
210pub const MAX_SAMP_FACTOR: u32 = 4;
211pub const C_MAX_BLOCKS_IN_MCU: u32 = 10;
212pub const D_MAX_BLOCKS_IN_MCU: u32 = 10;
213pub const JCS_EXTENSIONS: u32 = 1;
214pub const JCS_ALPHA_EXTENSIONS: u32 = 1;
215pub const JMSG_LENGTH_MAX: u32 = 200;
216pub const JMSG_STR_PARM_MAX: u32 = 80;
217pub const JPOOL_PERMANENT: u32 = 0;
218pub const JPOOL_IMAGE: u32 = 1;
219pub const JPOOL_NUMPOOLS: u32 = 2;
220pub const JPEG_SUSPENDED: u32 = 0;
221pub const JPEG_HEADER_OK: u32 = 1;
222pub const JPEG_HEADER_TABLES_ONLY: u32 = 2;
223pub const JPEG_REACHED_SOS: u32 = 1;
224pub const JPEG_REACHED_EOI: u32 = 2;
225pub const JPEG_ROW_COMPLETED: u32 = 3;
226pub const JPEG_SCAN_COMPLETED: u32 = 4;
227pub const JPEG_RST0: u32 = 208;
228pub const JPEG_EOI: u32 = 217;
229pub const JPEG_APP0: u32 = 224;
230pub const JPEG_COM: u32 = 254;
231pub type size_t = ::std::os::raw::c_ulong;
232pub type wchar_t = ::std::os::raw::c_int;
233pub type max_align_t = u128;
234pub type __int8_t = ::std::os::raw::c_schar;
235pub type __uint8_t = ::std::os::raw::c_uchar;
236pub type __int16_t = ::std::os::raw::c_short;
237pub type __uint16_t = ::std::os::raw::c_ushort;
238pub type __int32_t = ::std::os::raw::c_int;
239pub type __uint32_t = ::std::os::raw::c_uint;
240pub type __int64_t = ::std::os::raw::c_longlong;
241pub type __uint64_t = ::std::os::raw::c_ulonglong;
242pub type __darwin_intptr_t = ::std::os::raw::c_long;
243pub type __darwin_natural_t = ::std::os::raw::c_uint;
244pub type __darwin_ct_rune_t = ::std::os::raw::c_int;
245#[repr(C)]
246#[derive(Copy, Clone)]
247pub union __mbstate_t {
248 pub __mbstate8: [::std::os::raw::c_char; 128usize],
249 pub _mbstateL: ::std::os::raw::c_longlong,
250 _bindgen_union_align: [u64; 16usize],
251}
252#[test]
253fn bindgen_test_layout___mbstate_t() {
254 assert_eq!(
255 ::std::mem::size_of::<__mbstate_t>(),
256 128usize,
257 concat!("Size of: ", stringify!(__mbstate_t))
258 );
259 assert_eq!(
260 ::std::mem::align_of::<__mbstate_t>(),
261 8usize,
262 concat!("Alignment of ", stringify!(__mbstate_t))
263 );
264 assert_eq!(
265 unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__mbstate8 as *const _ as usize },
266 0usize,
267 concat!(
268 "Offset of field: ",
269 stringify!(__mbstate_t),
270 "::",
271 stringify!(__mbstate8)
272 )
273 );
274 assert_eq!(
275 unsafe { &(*(::std::ptr::null::<__mbstate_t>()))._mbstateL as *const _ as usize },
276 0usize,
277 concat!(
278 "Offset of field: ",
279 stringify!(__mbstate_t),
280 "::",
281 stringify!(_mbstateL)
282 )
283 );
284}
285pub type __darwin_mbstate_t = __mbstate_t;
286pub type __darwin_ptrdiff_t = ::std::os::raw::c_long;
287pub type __darwin_size_t = ::std::os::raw::c_ulong;
288pub type __darwin_va_list = __builtin_va_list;
289pub type __darwin_wchar_t = ::std::os::raw::c_int;
290pub type __darwin_rune_t = __darwin_wchar_t;
291pub type __darwin_wint_t = ::std::os::raw::c_int;
292pub type __darwin_clock_t = ::std::os::raw::c_ulong;
293pub type __darwin_socklen_t = __uint32_t;
294pub type __darwin_ssize_t = ::std::os::raw::c_long;
295pub type __darwin_time_t = ::std::os::raw::c_long;
296pub type __darwin_blkcnt_t = __int64_t;
297pub type __darwin_blksize_t = __int32_t;
298pub type __darwin_dev_t = __int32_t;
299pub type __darwin_fsblkcnt_t = ::std::os::raw::c_uint;
300pub type __darwin_fsfilcnt_t = ::std::os::raw::c_uint;
301pub type __darwin_gid_t = __uint32_t;
302pub type __darwin_id_t = __uint32_t;
303pub type __darwin_ino64_t = __uint64_t;
304pub type __darwin_ino_t = __darwin_ino64_t;
305pub type __darwin_mach_port_name_t = __darwin_natural_t;
306pub type __darwin_mach_port_t = __darwin_mach_port_name_t;
307pub type __darwin_mode_t = __uint16_t;
308pub type __darwin_off_t = __int64_t;
309pub type __darwin_pid_t = __int32_t;
310pub type __darwin_sigset_t = __uint32_t;
311pub type __darwin_suseconds_t = __int32_t;
312pub type __darwin_uid_t = __uint32_t;
313pub type __darwin_useconds_t = __uint32_t;
314pub type __darwin_uuid_t = [::std::os::raw::c_uchar; 16usize];
315pub type __darwin_uuid_string_t = [::std::os::raw::c_char; 37usize];
316#[repr(C)]
317#[derive(Debug, Copy, Clone)]
318pub struct __darwin_pthread_handler_rec {
319 pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
320 pub __arg: *mut ::std::os::raw::c_void,
321 pub __next: *mut __darwin_pthread_handler_rec,
322}
323#[test]
324fn bindgen_test_layout___darwin_pthread_handler_rec() {
325 assert_eq!(
326 ::std::mem::size_of::<__darwin_pthread_handler_rec>(),
327 24usize,
328 concat!("Size of: ", stringify!(__darwin_pthread_handler_rec))
329 );
330 assert_eq!(
331 ::std::mem::align_of::<__darwin_pthread_handler_rec>(),
332 8usize,
333 concat!("Alignment of ", stringify!(__darwin_pthread_handler_rec))
334 );
335 assert_eq!(
336 unsafe {
337 &(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__routine as *const _ as usize
338 },
339 0usize,
340 concat!(
341 "Offset of field: ",
342 stringify!(__darwin_pthread_handler_rec),
343 "::",
344 stringify!(__routine)
345 )
346 );
347 assert_eq!(
348 unsafe {
349 &(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__arg as *const _ as usize
350 },
351 8usize,
352 concat!(
353 "Offset of field: ",
354 stringify!(__darwin_pthread_handler_rec),
355 "::",
356 stringify!(__arg)
357 )
358 );
359 assert_eq!(
360 unsafe {
361 &(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__next as *const _ as usize
362 },
363 16usize,
364 concat!(
365 "Offset of field: ",
366 stringify!(__darwin_pthread_handler_rec),
367 "::",
368 stringify!(__next)
369 )
370 );
371}
372#[repr(C)]
373#[derive(Copy, Clone)]
374pub struct _opaque_pthread_attr_t {
375 pub __sig: ::std::os::raw::c_long,
376 pub __opaque: [::std::os::raw::c_char; 56usize],
377}
378#[test]
379fn bindgen_test_layout__opaque_pthread_attr_t() {
380 assert_eq!(
381 ::std::mem::size_of::<_opaque_pthread_attr_t>(),
382 64usize,
383 concat!("Size of: ", stringify!(_opaque_pthread_attr_t))
384 );
385 assert_eq!(
386 ::std::mem::align_of::<_opaque_pthread_attr_t>(),
387 8usize,
388 concat!("Alignment of ", stringify!(_opaque_pthread_attr_t))
389 );
390 assert_eq!(
391 unsafe { &(*(::std::ptr::null::<_opaque_pthread_attr_t>())).__sig as *const _ as usize },
392 0usize,
393 concat!(
394 "Offset of field: ",
395 stringify!(_opaque_pthread_attr_t),
396 "::",
397 stringify!(__sig)
398 )
399 );
400 assert_eq!(
401 unsafe { &(*(::std::ptr::null::<_opaque_pthread_attr_t>())).__opaque as *const _ as usize },
402 8usize,
403 concat!(
404 "Offset of field: ",
405 stringify!(_opaque_pthread_attr_t),
406 "::",
407 stringify!(__opaque)
408 )
409 );
410}
411#[repr(C)]
412#[derive(Copy, Clone)]
413pub struct _opaque_pthread_cond_t {
414 pub __sig: ::std::os::raw::c_long,
415 pub __opaque: [::std::os::raw::c_char; 40usize],
416}
417#[test]
418fn bindgen_test_layout__opaque_pthread_cond_t() {
419 assert_eq!(
420 ::std::mem::size_of::<_opaque_pthread_cond_t>(),
421 48usize,
422 concat!("Size of: ", stringify!(_opaque_pthread_cond_t))
423 );
424 assert_eq!(
425 ::std::mem::align_of::<_opaque_pthread_cond_t>(),
426 8usize,
427 concat!("Alignment of ", stringify!(_opaque_pthread_cond_t))
428 );
429 assert_eq!(
430 unsafe { &(*(::std::ptr::null::<_opaque_pthread_cond_t>())).__sig as *const _ as usize },
431 0usize,
432 concat!(
433 "Offset of field: ",
434 stringify!(_opaque_pthread_cond_t),
435 "::",
436 stringify!(__sig)
437 )
438 );
439 assert_eq!(
440 unsafe { &(*(::std::ptr::null::<_opaque_pthread_cond_t>())).__opaque as *const _ as usize },
441 8usize,
442 concat!(
443 "Offset of field: ",
444 stringify!(_opaque_pthread_cond_t),
445 "::",
446 stringify!(__opaque)
447 )
448 );
449}
450#[repr(C)]
451#[derive(Debug, Copy, Clone)]
452pub struct _opaque_pthread_condattr_t {
453 pub __sig: ::std::os::raw::c_long,
454 pub __opaque: [::std::os::raw::c_char; 8usize],
455}
456#[test]
457fn bindgen_test_layout__opaque_pthread_condattr_t() {
458 assert_eq!(
459 ::std::mem::size_of::<_opaque_pthread_condattr_t>(),
460 16usize,
461 concat!("Size of: ", stringify!(_opaque_pthread_condattr_t))
462 );
463 assert_eq!(
464 ::std::mem::align_of::<_opaque_pthread_condattr_t>(),
465 8usize,
466 concat!("Alignment of ", stringify!(_opaque_pthread_condattr_t))
467 );
468 assert_eq!(
469 unsafe {
470 &(*(::std::ptr::null::<_opaque_pthread_condattr_t>())).__sig as *const _ as usize
471 },
472 0usize,
473 concat!(
474 "Offset of field: ",
475 stringify!(_opaque_pthread_condattr_t),
476 "::",
477 stringify!(__sig)
478 )
479 );
480 assert_eq!(
481 unsafe {
482 &(*(::std::ptr::null::<_opaque_pthread_condattr_t>())).__opaque as *const _ as usize
483 },
484 8usize,
485 concat!(
486 "Offset of field: ",
487 stringify!(_opaque_pthread_condattr_t),
488 "::",
489 stringify!(__opaque)
490 )
491 );
492}
493#[repr(C)]
494#[derive(Copy, Clone)]
495pub struct _opaque_pthread_mutex_t {
496 pub __sig: ::std::os::raw::c_long,
497 pub __opaque: [::std::os::raw::c_char; 56usize],
498}
499#[test]
500fn bindgen_test_layout__opaque_pthread_mutex_t() {
501 assert_eq!(
502 ::std::mem::size_of::<_opaque_pthread_mutex_t>(),
503 64usize,
504 concat!("Size of: ", stringify!(_opaque_pthread_mutex_t))
505 );
506 assert_eq!(
507 ::std::mem::align_of::<_opaque_pthread_mutex_t>(),
508 8usize,
509 concat!("Alignment of ", stringify!(_opaque_pthread_mutex_t))
510 );
511 assert_eq!(
512 unsafe { &(*(::std::ptr::null::<_opaque_pthread_mutex_t>())).__sig as *const _ as usize },
513 0usize,
514 concat!(
515 "Offset of field: ",
516 stringify!(_opaque_pthread_mutex_t),
517 "::",
518 stringify!(__sig)
519 )
520 );
521 assert_eq!(
522 unsafe {
523 &(*(::std::ptr::null::<_opaque_pthread_mutex_t>())).__opaque as *const _ as usize
524 },
525 8usize,
526 concat!(
527 "Offset of field: ",
528 stringify!(_opaque_pthread_mutex_t),
529 "::",
530 stringify!(__opaque)
531 )
532 );
533}
534#[repr(C)]
535#[derive(Debug, Copy, Clone)]
536pub struct _opaque_pthread_mutexattr_t {
537 pub __sig: ::std::os::raw::c_long,
538 pub __opaque: [::std::os::raw::c_char; 8usize],
539}
540#[test]
541fn bindgen_test_layout__opaque_pthread_mutexattr_t() {
542 assert_eq!(
543 ::std::mem::size_of::<_opaque_pthread_mutexattr_t>(),
544 16usize,
545 concat!("Size of: ", stringify!(_opaque_pthread_mutexattr_t))
546 );
547 assert_eq!(
548 ::std::mem::align_of::<_opaque_pthread_mutexattr_t>(),
549 8usize,
550 concat!("Alignment of ", stringify!(_opaque_pthread_mutexattr_t))
551 );
552 assert_eq!(
553 unsafe {
554 &(*(::std::ptr::null::<_opaque_pthread_mutexattr_t>())).__sig as *const _ as usize
555 },
556 0usize,
557 concat!(
558 "Offset of field: ",
559 stringify!(_opaque_pthread_mutexattr_t),
560 "::",
561 stringify!(__sig)
562 )
563 );
564 assert_eq!(
565 unsafe {
566 &(*(::std::ptr::null::<_opaque_pthread_mutexattr_t>())).__opaque as *const _ as usize
567 },
568 8usize,
569 concat!(
570 "Offset of field: ",
571 stringify!(_opaque_pthread_mutexattr_t),
572 "::",
573 stringify!(__opaque)
574 )
575 );
576}
577#[repr(C)]
578#[derive(Debug, Copy, Clone)]
579pub struct _opaque_pthread_once_t {
580 pub __sig: ::std::os::raw::c_long,
581 pub __opaque: [::std::os::raw::c_char; 8usize],
582}
583#[test]
584fn bindgen_test_layout__opaque_pthread_once_t() {
585 assert_eq!(
586 ::std::mem::size_of::<_opaque_pthread_once_t>(),
587 16usize,
588 concat!("Size of: ", stringify!(_opaque_pthread_once_t))
589 );
590 assert_eq!(
591 ::std::mem::align_of::<_opaque_pthread_once_t>(),
592 8usize,
593 concat!("Alignment of ", stringify!(_opaque_pthread_once_t))
594 );
595 assert_eq!(
596 unsafe { &(*(::std::ptr::null::<_opaque_pthread_once_t>())).__sig as *const _ as usize },
597 0usize,
598 concat!(
599 "Offset of field: ",
600 stringify!(_opaque_pthread_once_t),
601 "::",
602 stringify!(__sig)
603 )
604 );
605 assert_eq!(
606 unsafe { &(*(::std::ptr::null::<_opaque_pthread_once_t>())).__opaque as *const _ as usize },
607 8usize,
608 concat!(
609 "Offset of field: ",
610 stringify!(_opaque_pthread_once_t),
611 "::",
612 stringify!(__opaque)
613 )
614 );
615}
616#[repr(C)]
617#[derive(Copy, Clone)]
618pub struct _opaque_pthread_rwlock_t {
619 pub __sig: ::std::os::raw::c_long,
620 pub __opaque: [::std::os::raw::c_char; 192usize],
621}
622#[test]
623fn bindgen_test_layout__opaque_pthread_rwlock_t() {
624 assert_eq!(
625 ::std::mem::size_of::<_opaque_pthread_rwlock_t>(),
626 200usize,
627 concat!("Size of: ", stringify!(_opaque_pthread_rwlock_t))
628 );
629 assert_eq!(
630 ::std::mem::align_of::<_opaque_pthread_rwlock_t>(),
631 8usize,
632 concat!("Alignment of ", stringify!(_opaque_pthread_rwlock_t))
633 );
634 assert_eq!(
635 unsafe { &(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__sig as *const _ as usize },
636 0usize,
637 concat!(
638 "Offset of field: ",
639 stringify!(_opaque_pthread_rwlock_t),
640 "::",
641 stringify!(__sig)
642 )
643 );
644 assert_eq!(
645 unsafe {
646 &(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__opaque as *const _ as usize
647 },
648 8usize,
649 concat!(
650 "Offset of field: ",
651 stringify!(_opaque_pthread_rwlock_t),
652 "::",
653 stringify!(__opaque)
654 )
655 );
656}
657#[repr(C)]
658#[derive(Debug, Copy, Clone)]
659pub struct _opaque_pthread_rwlockattr_t {
660 pub __sig: ::std::os::raw::c_long,
661 pub __opaque: [::std::os::raw::c_char; 16usize],
662}
663#[test]
664fn bindgen_test_layout__opaque_pthread_rwlockattr_t() {
665 assert_eq!(
666 ::std::mem::size_of::<_opaque_pthread_rwlockattr_t>(),
667 24usize,
668 concat!("Size of: ", stringify!(_opaque_pthread_rwlockattr_t))
669 );
670 assert_eq!(
671 ::std::mem::align_of::<_opaque_pthread_rwlockattr_t>(),
672 8usize,
673 concat!("Alignment of ", stringify!(_opaque_pthread_rwlockattr_t))
674 );
675 assert_eq!(
676 unsafe {
677 &(*(::std::ptr::null::<_opaque_pthread_rwlockattr_t>())).__sig as *const _ as usize
678 },
679 0usize,
680 concat!(
681 "Offset of field: ",
682 stringify!(_opaque_pthread_rwlockattr_t),
683 "::",
684 stringify!(__sig)
685 )
686 );
687 assert_eq!(
688 unsafe {
689 &(*(::std::ptr::null::<_opaque_pthread_rwlockattr_t>())).__opaque as *const _ as usize
690 },
691 8usize,
692 concat!(
693 "Offset of field: ",
694 stringify!(_opaque_pthread_rwlockattr_t),
695 "::",
696 stringify!(__opaque)
697 )
698 );
699}
700#[repr(C)]
701#[derive(Copy, Clone)]
702pub struct _opaque_pthread_t {
703 pub __sig: ::std::os::raw::c_long,
704 pub __cleanup_stack: *mut __darwin_pthread_handler_rec,
705 pub __opaque: [::std::os::raw::c_char; 8176usize],
706}
707#[test]
708fn bindgen_test_layout__opaque_pthread_t() {
709 assert_eq!(
710 ::std::mem::size_of::<_opaque_pthread_t>(),
711 8192usize,
712 concat!("Size of: ", stringify!(_opaque_pthread_t))
713 );
714 assert_eq!(
715 ::std::mem::align_of::<_opaque_pthread_t>(),
716 8usize,
717 concat!("Alignment of ", stringify!(_opaque_pthread_t))
718 );
719 assert_eq!(
720 unsafe { &(*(::std::ptr::null::<_opaque_pthread_t>())).__sig as *const _ as usize },
721 0usize,
722 concat!(
723 "Offset of field: ",
724 stringify!(_opaque_pthread_t),
725 "::",
726 stringify!(__sig)
727 )
728 );
729 assert_eq!(
730 unsafe {
731 &(*(::std::ptr::null::<_opaque_pthread_t>())).__cleanup_stack as *const _ as usize
732 },
733 8usize,
734 concat!(
735 "Offset of field: ",
736 stringify!(_opaque_pthread_t),
737 "::",
738 stringify!(__cleanup_stack)
739 )
740 );
741 assert_eq!(
742 unsafe { &(*(::std::ptr::null::<_opaque_pthread_t>())).__opaque as *const _ as usize },
743 16usize,
744 concat!(
745 "Offset of field: ",
746 stringify!(_opaque_pthread_t),
747 "::",
748 stringify!(__opaque)
749 )
750 );
751}
752pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t;
753pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t;
754pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t;
755pub type __darwin_pthread_key_t = ::std::os::raw::c_ulong;
756pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
757pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t;
758pub type __darwin_pthread_once_t = _opaque_pthread_once_t;
759pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
760pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t;
761pub type __darwin_pthread_t = *mut _opaque_pthread_t;
762pub type __darwin_nl_item = ::std::os::raw::c_int;
763pub type __darwin_wctrans_t = ::std::os::raw::c_int;
764pub type __darwin_wctype_t = __uint32_t;
765pub type u_int8_t = ::std::os::raw::c_uchar;
766pub type u_int16_t = ::std::os::raw::c_ushort;
767pub type u_int32_t = ::std::os::raw::c_uint;
768pub type u_int64_t = ::std::os::raw::c_ulonglong;
769pub type register_t = i64;
770pub type user_addr_t = u_int64_t;
771pub type user_size_t = u_int64_t;
772pub type user_ssize_t = i64;
773pub type user_long_t = i64;
774pub type user_ulong_t = u_int64_t;
775pub type user_time_t = i64;
776pub type user_off_t = i64;
777pub type syscall_arg_t = u_int64_t;
778pub type va_list = __darwin_va_list;
779extern "C" {
780 pub fn renameat(
781 arg1: ::std::os::raw::c_int,
782 arg2: *const ::std::os::raw::c_char,
783 arg3: ::std::os::raw::c_int,
784 arg4: *const ::std::os::raw::c_char,
785 ) -> ::std::os::raw::c_int;
786}
787extern "C" {
788 pub fn renamex_np(
789 arg1: *const ::std::os::raw::c_char,
790 arg2: *const ::std::os::raw::c_char,
791 arg3: ::std::os::raw::c_uint,
792 ) -> ::std::os::raw::c_int;
793}
794extern "C" {
795 pub fn renameatx_np(
796 arg1: ::std::os::raw::c_int,
797 arg2: *const ::std::os::raw::c_char,
798 arg3: ::std::os::raw::c_int,
799 arg4: *const ::std::os::raw::c_char,
800 arg5: ::std::os::raw::c_uint,
801 ) -> ::std::os::raw::c_int;
802}
803pub type fpos_t = __darwin_off_t;
804#[repr(C)]
805#[derive(Debug, Copy, Clone)]
806pub struct __sbuf {
807 pub _base: *mut ::std::os::raw::c_uchar,
808 pub _size: ::std::os::raw::c_int,
809}
810#[test]
811fn bindgen_test_layout___sbuf() {
812 assert_eq!(
813 ::std::mem::size_of::<__sbuf>(),
814 16usize,
815 concat!("Size of: ", stringify!(__sbuf))
816 );
817 assert_eq!(
818 ::std::mem::align_of::<__sbuf>(),
819 8usize,
820 concat!("Alignment of ", stringify!(__sbuf))
821 );
822 assert_eq!(
823 unsafe { &(*(::std::ptr::null::<__sbuf>()))._base as *const _ as usize },
824 0usize,
825 concat!(
826 "Offset of field: ",
827 stringify!(__sbuf),
828 "::",
829 stringify!(_base)
830 )
831 );
832 assert_eq!(
833 unsafe { &(*(::std::ptr::null::<__sbuf>()))._size as *const _ as usize },
834 8usize,
835 concat!(
836 "Offset of field: ",
837 stringify!(__sbuf),
838 "::",
839 stringify!(_size)
840 )
841 );
842}
843#[repr(C)]
844#[derive(Debug, Copy, Clone)]
845pub struct __sFILEX {
846 _unused: [u8; 0],
847}
848#[repr(C)]
849#[derive(Debug, Copy, Clone)]
850pub struct __sFILE {
851 pub _p: *mut ::std::os::raw::c_uchar,
852 pub _r: ::std::os::raw::c_int,
853 pub _w: ::std::os::raw::c_int,
854 pub _flags: ::std::os::raw::c_short,
855 pub _file: ::std::os::raw::c_short,
856 pub _bf: __sbuf,
857 pub _lbfsize: ::std::os::raw::c_int,
858 pub _cookie: *mut ::std::os::raw::c_void,
859 pub _close: ::std::option::Option<
860 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
861 >,
862 pub _read: ::std::option::Option<
863 unsafe extern "C" fn(
864 arg1: *mut ::std::os::raw::c_void,
865 arg2: *mut ::std::os::raw::c_char,
866 arg3: ::std::os::raw::c_int,
867 ) -> ::std::os::raw::c_int,
868 >,
869 pub _seek: ::std::option::Option<
870 unsafe extern "C" fn(
871 arg1: *mut ::std::os::raw::c_void,
872 arg2: fpos_t,
873 arg3: ::std::os::raw::c_int,
874 ) -> fpos_t,
875 >,
876 pub _write: ::std::option::Option<
877 unsafe extern "C" fn(
878 arg1: *mut ::std::os::raw::c_void,
879 arg2: *const ::std::os::raw::c_char,
880 arg3: ::std::os::raw::c_int,
881 ) -> ::std::os::raw::c_int,
882 >,
883 pub _ub: __sbuf,
884 pub _extra: *mut __sFILEX,
885 pub _ur: ::std::os::raw::c_int,
886 pub _ubuf: [::std::os::raw::c_uchar; 3usize],
887 pub _nbuf: [::std::os::raw::c_uchar; 1usize],
888 pub _lb: __sbuf,
889 pub _blksize: ::std::os::raw::c_int,
890 pub _offset: fpos_t,
891}
892#[test]
893fn bindgen_test_layout___sFILE() {
894 assert_eq!(
895 ::std::mem::size_of::<__sFILE>(),
896 152usize,
897 concat!("Size of: ", stringify!(__sFILE))
898 );
899 assert_eq!(
900 ::std::mem::align_of::<__sFILE>(),
901 8usize,
902 concat!("Alignment of ", stringify!(__sFILE))
903 );
904 assert_eq!(
905 unsafe { &(*(::std::ptr::null::<__sFILE>()))._p as *const _ as usize },
906 0usize,
907 concat!(
908 "Offset of field: ",
909 stringify!(__sFILE),
910 "::",
911 stringify!(_p)
912 )
913 );
914 assert_eq!(
915 unsafe { &(*(::std::ptr::null::<__sFILE>()))._r as *const _ as usize },
916 8usize,
917 concat!(
918 "Offset of field: ",
919 stringify!(__sFILE),
920 "::",
921 stringify!(_r)
922 )
923 );
924 assert_eq!(
925 unsafe { &(*(::std::ptr::null::<__sFILE>()))._w as *const _ as usize },
926 12usize,
927 concat!(
928 "Offset of field: ",
929 stringify!(__sFILE),
930 "::",
931 stringify!(_w)
932 )
933 );
934 assert_eq!(
935 unsafe { &(*(::std::ptr::null::<__sFILE>()))._flags as *const _ as usize },
936 16usize,
937 concat!(
938 "Offset of field: ",
939 stringify!(__sFILE),
940 "::",
941 stringify!(_flags)
942 )
943 );
944 assert_eq!(
945 unsafe { &(*(::std::ptr::null::<__sFILE>()))._file as *const _ as usize },
946 18usize,
947 concat!(
948 "Offset of field: ",
949 stringify!(__sFILE),
950 "::",
951 stringify!(_file)
952 )
953 );
954 assert_eq!(
955 unsafe { &(*(::std::ptr::null::<__sFILE>()))._bf as *const _ as usize },
956 24usize,
957 concat!(
958 "Offset of field: ",
959 stringify!(__sFILE),
960 "::",
961 stringify!(_bf)
962 )
963 );
964 assert_eq!(
965 unsafe { &(*(::std::ptr::null::<__sFILE>()))._lbfsize as *const _ as usize },
966 40usize,
967 concat!(
968 "Offset of field: ",
969 stringify!(__sFILE),
970 "::",
971 stringify!(_lbfsize)
972 )
973 );
974 assert_eq!(
975 unsafe { &(*(::std::ptr::null::<__sFILE>()))._cookie as *const _ as usize },
976 48usize,
977 concat!(
978 "Offset of field: ",
979 stringify!(__sFILE),
980 "::",
981 stringify!(_cookie)
982 )
983 );
984 assert_eq!(
985 unsafe { &(*(::std::ptr::null::<__sFILE>()))._close as *const _ as usize },
986 56usize,
987 concat!(
988 "Offset of field: ",
989 stringify!(__sFILE),
990 "::",
991 stringify!(_close)
992 )
993 );
994 assert_eq!(
995 unsafe { &(*(::std::ptr::null::<__sFILE>()))._read as *const _ as usize },
996 64usize,
997 concat!(
998 "Offset of field: ",
999 stringify!(__sFILE),
1000 "::",
1001 stringify!(_read)
1002 )
1003 );
1004 assert_eq!(
1005 unsafe { &(*(::std::ptr::null::<__sFILE>()))._seek as *const _ as usize },
1006 72usize,
1007 concat!(
1008 "Offset of field: ",
1009 stringify!(__sFILE),
1010 "::",
1011 stringify!(_seek)
1012 )
1013 );
1014 assert_eq!(
1015 unsafe { &(*(::std::ptr::null::<__sFILE>()))._write as *const _ as usize },
1016 80usize,
1017 concat!(
1018 "Offset of field: ",
1019 stringify!(__sFILE),
1020 "::",
1021 stringify!(_write)
1022 )
1023 );
1024 assert_eq!(
1025 unsafe { &(*(::std::ptr::null::<__sFILE>()))._ub as *const _ as usize },
1026 88usize,
1027 concat!(
1028 "Offset of field: ",
1029 stringify!(__sFILE),
1030 "::",
1031 stringify!(_ub)
1032 )
1033 );
1034 assert_eq!(
1035 unsafe { &(*(::std::ptr::null::<__sFILE>()))._extra as *const _ as usize },
1036 104usize,
1037 concat!(
1038 "Offset of field: ",
1039 stringify!(__sFILE),
1040 "::",
1041 stringify!(_extra)
1042 )
1043 );
1044 assert_eq!(
1045 unsafe { &(*(::std::ptr::null::<__sFILE>()))._ur as *const _ as usize },
1046 112usize,
1047 concat!(
1048 "Offset of field: ",
1049 stringify!(__sFILE),
1050 "::",
1051 stringify!(_ur)
1052 )
1053 );
1054 assert_eq!(
1055 unsafe { &(*(::std::ptr::null::<__sFILE>()))._ubuf as *const _ as usize },
1056 116usize,
1057 concat!(
1058 "Offset of field: ",
1059 stringify!(__sFILE),
1060 "::",
1061 stringify!(_ubuf)
1062 )
1063 );
1064 assert_eq!(
1065 unsafe { &(*(::std::ptr::null::<__sFILE>()))._nbuf as *const _ as usize },
1066 119usize,
1067 concat!(
1068 "Offset of field: ",
1069 stringify!(__sFILE),
1070 "::",
1071 stringify!(_nbuf)
1072 )
1073 );
1074 assert_eq!(
1075 unsafe { &(*(::std::ptr::null::<__sFILE>()))._lb as *const _ as usize },
1076 120usize,
1077 concat!(
1078 "Offset of field: ",
1079 stringify!(__sFILE),
1080 "::",
1081 stringify!(_lb)
1082 )
1083 );
1084 assert_eq!(
1085 unsafe { &(*(::std::ptr::null::<__sFILE>()))._blksize as *const _ as usize },
1086 136usize,
1087 concat!(
1088 "Offset of field: ",
1089 stringify!(__sFILE),
1090 "::",
1091 stringify!(_blksize)
1092 )
1093 );
1094 assert_eq!(
1095 unsafe { &(*(::std::ptr::null::<__sFILE>()))._offset as *const _ as usize },
1096 144usize,
1097 concat!(
1098 "Offset of field: ",
1099 stringify!(__sFILE),
1100 "::",
1101 stringify!(_offset)
1102 )
1103 );
1104}
1105pub type FILE = __sFILE;
1106extern "C" {
1107 pub static mut __stdinp: *mut FILE;
1108}
1109extern "C" {
1110 pub static mut __stdoutp: *mut FILE;
1111}
1112extern "C" {
1113 pub static mut __stderrp: *mut FILE;
1114}
1115extern "C" {
1116 pub fn clearerr(arg1: *mut FILE);
1117}
1118extern "C" {
1119 pub fn fclose(arg1: *mut FILE) -> ::std::os::raw::c_int;
1120}
1121extern "C" {
1122 pub fn feof(arg1: *mut FILE) -> ::std::os::raw::c_int;
1123}
1124extern "C" {
1125 pub fn ferror(arg1: *mut FILE) -> ::std::os::raw::c_int;
1126}
1127extern "C" {
1128 pub fn fflush(arg1: *mut FILE) -> ::std::os::raw::c_int;
1129}
1130extern "C" {
1131 pub fn fgetc(arg1: *mut FILE) -> ::std::os::raw::c_int;
1132}
1133extern "C" {
1134 pub fn fgetpos(arg1: *mut FILE, arg2: *mut fpos_t) -> ::std::os::raw::c_int;
1135}
1136extern "C" {
1137 pub fn fgets(
1138 arg1: *mut ::std::os::raw::c_char,
1139 arg2: ::std::os::raw::c_int,
1140 arg3: *mut FILE,
1141 ) -> *mut ::std::os::raw::c_char;
1142}
1143extern "C" {
1144 pub fn fopen(
1145 __filename: *const ::std::os::raw::c_char,
1146 __mode: *const ::std::os::raw::c_char,
1147 ) -> *mut FILE;
1148}
1149extern "C" {
1150 pub fn fprintf(
1151 arg1: *mut FILE,
1152 arg2: *const ::std::os::raw::c_char,
1153 ...
1154 ) -> ::std::os::raw::c_int;
1155}
1156extern "C" {
1157 pub fn fputc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1158}
1159extern "C" {
1160 pub fn fputs(arg1: *const ::std::os::raw::c_char, arg2: *mut FILE) -> ::std::os::raw::c_int;
1161}
1162extern "C" {
1163 pub fn fread(
1164 __ptr: *mut ::std::os::raw::c_void,
1165 __size: ::std::os::raw::c_ulong,
1166 __nitems: ::std::os::raw::c_ulong,
1167 __stream: *mut FILE,
1168 ) -> ::std::os::raw::c_ulong;
1169}
1170extern "C" {
1171 pub fn freopen(
1172 arg1: *const ::std::os::raw::c_char,
1173 arg2: *const ::std::os::raw::c_char,
1174 arg3: *mut FILE,
1175 ) -> *mut FILE;
1176}
1177extern "C" {
1178 pub fn fscanf(
1179 arg1: *mut FILE,
1180 arg2: *const ::std::os::raw::c_char,
1181 ...
1182 ) -> ::std::os::raw::c_int;
1183}
1184extern "C" {
1185 pub fn fseek(
1186 arg1: *mut FILE,
1187 arg2: ::std::os::raw::c_long,
1188 arg3: ::std::os::raw::c_int,
1189 ) -> ::std::os::raw::c_int;
1190}
1191extern "C" {
1192 pub fn fsetpos(arg1: *mut FILE, arg2: *const fpos_t) -> ::std::os::raw::c_int;
1193}
1194extern "C" {
1195 pub fn ftell(arg1: *mut FILE) -> ::std::os::raw::c_long;
1196}
1197extern "C" {
1198 pub fn fwrite(
1199 __ptr: *const ::std::os::raw::c_void,
1200 __size: ::std::os::raw::c_ulong,
1201 __nitems: ::std::os::raw::c_ulong,
1202 __stream: *mut FILE,
1203 ) -> ::std::os::raw::c_ulong;
1204}
1205extern "C" {
1206 pub fn getc(arg1: *mut FILE) -> ::std::os::raw::c_int;
1207}
1208extern "C" {
1209 pub fn getchar() -> ::std::os::raw::c_int;
1210}
1211extern "C" {
1212 pub fn gets(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1213}
1214extern "C" {
1215 pub fn perror(arg1: *const ::std::os::raw::c_char);
1216}
1217extern "C" {
1218 pub fn printf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1219}
1220extern "C" {
1221 pub fn putc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1222}
1223extern "C" {
1224 pub fn putchar(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1225}
1226extern "C" {
1227 pub fn puts(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1228}
1229extern "C" {
1230 pub fn remove(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1231}
1232extern "C" {
1233 pub fn rename(
1234 __old: *const ::std::os::raw::c_char,
1235 __new: *const ::std::os::raw::c_char,
1236 ) -> ::std::os::raw::c_int;
1237}
1238extern "C" {
1239 pub fn rewind(arg1: *mut FILE);
1240}
1241extern "C" {
1242 pub fn scanf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1243}
1244extern "C" {
1245 pub fn setbuf(arg1: *mut FILE, arg2: *mut ::std::os::raw::c_char);
1246}
1247extern "C" {
1248 pub fn setvbuf(
1249 arg1: *mut FILE,
1250 arg2: *mut ::std::os::raw::c_char,
1251 arg3: ::std::os::raw::c_int,
1252 arg4: size_t,
1253 ) -> ::std::os::raw::c_int;
1254}
1255extern "C" {
1256 pub fn sprintf(
1257 arg1: *mut ::std::os::raw::c_char,
1258 arg2: *const ::std::os::raw::c_char,
1259 ...
1260 ) -> ::std::os::raw::c_int;
1261}
1262extern "C" {
1263 pub fn sscanf(
1264 arg1: *const ::std::os::raw::c_char,
1265 arg2: *const ::std::os::raw::c_char,
1266 ...
1267 ) -> ::std::os::raw::c_int;
1268}
1269extern "C" {
1270 pub fn tmpfile() -> *mut FILE;
1271}
1272extern "C" {
1273 pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1274}
1275extern "C" {
1276 pub fn ungetc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1277}
1278extern "C" {
1279 pub fn vfprintf(
1280 arg1: *mut FILE,
1281 arg2: *const ::std::os::raw::c_char,
1282 arg3: *mut __va_list_tag,
1283 ) -> ::std::os::raw::c_int;
1284}
1285extern "C" {
1286 pub fn vprintf(
1287 arg1: *const ::std::os::raw::c_char,
1288 arg2: *mut __va_list_tag,
1289 ) -> ::std::os::raw::c_int;
1290}
1291extern "C" {
1292 pub fn vsprintf(
1293 arg1: *mut ::std::os::raw::c_char,
1294 arg2: *const ::std::os::raw::c_char,
1295 arg3: *mut __va_list_tag,
1296 ) -> ::std::os::raw::c_int;
1297}
1298extern "C" {
1299 pub fn ctermid(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1300}
1301extern "C" {
1302 pub fn fdopen(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) -> *mut FILE;
1303}
1304extern "C" {
1305 pub fn fileno(arg1: *mut FILE) -> ::std::os::raw::c_int;
1306}
1307extern "C" {
1308 pub fn pclose(arg1: *mut FILE) -> ::std::os::raw::c_int;
1309}
1310extern "C" {
1311 pub fn popen(
1312 arg1: *const ::std::os::raw::c_char,
1313 arg2: *const ::std::os::raw::c_char,
1314 ) -> *mut FILE;
1315}
1316extern "C" {
1317 pub fn __srget(arg1: *mut FILE) -> ::std::os::raw::c_int;
1318}
1319extern "C" {
1320 pub fn __svfscanf(
1321 arg1: *mut FILE,
1322 arg2: *const ::std::os::raw::c_char,
1323 arg3: *mut __va_list_tag,
1324 ) -> ::std::os::raw::c_int;
1325}
1326extern "C" {
1327 pub fn __swbuf(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1328}
1329extern "C" {
1330 pub fn flockfile(arg1: *mut FILE);
1331}
1332extern "C" {
1333 pub fn ftrylockfile(arg1: *mut FILE) -> ::std::os::raw::c_int;
1334}
1335extern "C" {
1336 pub fn funlockfile(arg1: *mut FILE);
1337}
1338extern "C" {
1339 pub fn getc_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1340}
1341extern "C" {
1342 pub fn getchar_unlocked() -> ::std::os::raw::c_int;
1343}
1344extern "C" {
1345 pub fn putc_unlocked(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1346}
1347extern "C" {
1348 pub fn putchar_unlocked(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1349}
1350extern "C" {
1351 pub fn getw(arg1: *mut FILE) -> ::std::os::raw::c_int;
1352}
1353extern "C" {
1354 pub fn putw(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1355}
1356extern "C" {
1357 pub fn tempnam(
1358 __dir: *const ::std::os::raw::c_char,
1359 __prefix: *const ::std::os::raw::c_char,
1360 ) -> *mut ::std::os::raw::c_char;
1361}
1362pub type off_t = __darwin_off_t;
1363extern "C" {
1364 pub fn fseeko(
1365 __stream: *mut FILE,
1366 __offset: off_t,
1367 __whence: ::std::os::raw::c_int,
1368 ) -> ::std::os::raw::c_int;
1369}
1370extern "C" {
1371 pub fn ftello(__stream: *mut FILE) -> off_t;
1372}
1373extern "C" {
1374 pub fn snprintf(
1375 __str: *mut ::std::os::raw::c_char,
1376 __size: ::std::os::raw::c_ulong,
1377 __format: *const ::std::os::raw::c_char,
1378 ...
1379 ) -> ::std::os::raw::c_int;
1380}
1381extern "C" {
1382 pub fn vfscanf(
1383 __stream: *mut FILE,
1384 __format: *const ::std::os::raw::c_char,
1385 arg1: *mut __va_list_tag,
1386 ) -> ::std::os::raw::c_int;
1387}
1388extern "C" {
1389 pub fn vscanf(
1390 __format: *const ::std::os::raw::c_char,
1391 arg1: *mut __va_list_tag,
1392 ) -> ::std::os::raw::c_int;
1393}
1394extern "C" {
1395 pub fn vsnprintf(
1396 __str: *mut ::std::os::raw::c_char,
1397 __size: ::std::os::raw::c_ulong,
1398 __format: *const ::std::os::raw::c_char,
1399 arg1: *mut __va_list_tag,
1400 ) -> ::std::os::raw::c_int;
1401}
1402extern "C" {
1403 pub fn vsscanf(
1404 __str: *const ::std::os::raw::c_char,
1405 __format: *const ::std::os::raw::c_char,
1406 arg1: *mut __va_list_tag,
1407 ) -> ::std::os::raw::c_int;
1408}
1409pub type ssize_t = __darwin_ssize_t;
1410extern "C" {
1411 pub fn dprintf(
1412 arg1: ::std::os::raw::c_int,
1413 arg2: *const ::std::os::raw::c_char,
1414 ...
1415 ) -> ::std::os::raw::c_int;
1416}
1417extern "C" {
1418 pub fn vdprintf(
1419 arg1: ::std::os::raw::c_int,
1420 arg2: *const ::std::os::raw::c_char,
1421 arg3: *mut __va_list_tag,
1422 ) -> ::std::os::raw::c_int;
1423}
1424extern "C" {
1425 pub fn getdelim(
1426 __linep: *mut *mut ::std::os::raw::c_char,
1427 __linecapp: *mut size_t,
1428 __delimiter: ::std::os::raw::c_int,
1429 __stream: *mut FILE,
1430 ) -> ssize_t;
1431}
1432extern "C" {
1433 pub fn getline(
1434 __linep: *mut *mut ::std::os::raw::c_char,
1435 __linecapp: *mut size_t,
1436 __stream: *mut FILE,
1437 ) -> ssize_t;
1438}
1439extern "C" {
1440 pub fn fmemopen(
1441 __buf: *mut ::std::os::raw::c_void,
1442 __size: size_t,
1443 __mode: *const ::std::os::raw::c_char,
1444 ) -> *mut FILE;
1445}
1446extern "C" {
1447 pub fn open_memstream(
1448 __bufp: *mut *mut ::std::os::raw::c_char,
1449 __sizep: *mut size_t,
1450 ) -> *mut FILE;
1451}
1452extern "C" {
1453 pub static sys_nerr: ::std::os::raw::c_int;
1454}
1455extern "C" {
1456 pub static mut sys_errlist: [*const ::std::os::raw::c_char; 0usize];
1457}
1458extern "C" {
1459 pub fn asprintf(
1460 arg1: *mut *mut ::std::os::raw::c_char,
1461 arg2: *const ::std::os::raw::c_char,
1462 ...
1463 ) -> ::std::os::raw::c_int;
1464}
1465extern "C" {
1466 pub fn ctermid_r(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1467}
1468extern "C" {
1469 pub fn fgetln(arg1: *mut FILE, arg2: *mut size_t) -> *mut ::std::os::raw::c_char;
1470}
1471extern "C" {
1472 pub fn fmtcheck(
1473 arg1: *const ::std::os::raw::c_char,
1474 arg2: *const ::std::os::raw::c_char,
1475 ) -> *const ::std::os::raw::c_char;
1476}
1477extern "C" {
1478 pub fn fpurge(arg1: *mut FILE) -> ::std::os::raw::c_int;
1479}
1480extern "C" {
1481 pub fn setbuffer(
1482 arg1: *mut FILE,
1483 arg2: *mut ::std::os::raw::c_char,
1484 arg3: ::std::os::raw::c_int,
1485 );
1486}
1487extern "C" {
1488 pub fn setlinebuf(arg1: *mut FILE) -> ::std::os::raw::c_int;
1489}
1490extern "C" {
1491 pub fn vasprintf(
1492 arg1: *mut *mut ::std::os::raw::c_char,
1493 arg2: *const ::std::os::raw::c_char,
1494 arg3: *mut __va_list_tag,
1495 ) -> ::std::os::raw::c_int;
1496}
1497extern "C" {
1498 pub fn zopen(
1499 arg1: *const ::std::os::raw::c_char,
1500 arg2: *const ::std::os::raw::c_char,
1501 arg3: ::std::os::raw::c_int,
1502 ) -> *mut FILE;
1503}
1504extern "C" {
1505 pub fn funopen(
1506 arg1: *const ::std::os::raw::c_void,
1507 arg2: ::std::option::Option<
1508 unsafe extern "C" fn(
1509 arg1: *mut ::std::os::raw::c_void,
1510 arg2: *mut ::std::os::raw::c_char,
1511 arg3: ::std::os::raw::c_int,
1512 ) -> ::std::os::raw::c_int,
1513 >,
1514 arg3: ::std::option::Option<
1515 unsafe extern "C" fn(
1516 arg1: *mut ::std::os::raw::c_void,
1517 arg2: *const ::std::os::raw::c_char,
1518 arg3: ::std::os::raw::c_int,
1519 ) -> ::std::os::raw::c_int,
1520 >,
1521 arg4: ::std::option::Option<
1522 unsafe extern "C" fn(
1523 arg1: *mut ::std::os::raw::c_void,
1524 arg2: fpos_t,
1525 arg3: ::std::os::raw::c_int,
1526 ) -> fpos_t,
1527 >,
1528 arg5: ::std::option::Option<
1529 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
1530 >,
1531 ) -> *mut FILE;
1532}
1533extern "C" {
1534 pub fn __sprintf_chk(
1535 arg1: *mut ::std::os::raw::c_char,
1536 arg2: ::std::os::raw::c_int,
1537 arg3: size_t,
1538 arg4: *const ::std::os::raw::c_char,
1539 ...
1540 ) -> ::std::os::raw::c_int;
1541}
1542extern "C" {
1543 pub fn __snprintf_chk(
1544 arg1: *mut ::std::os::raw::c_char,
1545 arg2: size_t,
1546 arg3: ::std::os::raw::c_int,
1547 arg4: size_t,
1548 arg5: *const ::std::os::raw::c_char,
1549 ...
1550 ) -> ::std::os::raw::c_int;
1551}
1552extern "C" {
1553 pub fn __vsprintf_chk(
1554 arg1: *mut ::std::os::raw::c_char,
1555 arg2: ::std::os::raw::c_int,
1556 arg3: size_t,
1557 arg4: *const ::std::os::raw::c_char,
1558 arg5: *mut __va_list_tag,
1559 ) -> ::std::os::raw::c_int;
1560}
1561extern "C" {
1562 pub fn __vsnprintf_chk(
1563 arg1: *mut ::std::os::raw::c_char,
1564 arg2: size_t,
1565 arg3: ::std::os::raw::c_int,
1566 arg4: size_t,
1567 arg5: *const ::std::os::raw::c_char,
1568 arg6: *mut __va_list_tag,
1569 ) -> ::std::os::raw::c_int;
1570}
1571pub type JSAMPLE = ::std::os::raw::c_uchar;
1572pub type JCOEF = ::std::os::raw::c_short;
1573pub type JOCTET = ::std::os::raw::c_uchar;
1574pub type UINT8 = ::std::os::raw::c_uchar;
1575pub type UINT16 = ::std::os::raw::c_ushort;
1576pub type INT16 = ::std::os::raw::c_short;
1577pub type INT32 = ::std::os::raw::c_long;
1578pub type JDIMENSION = ::std::os::raw::c_uint;
1579pub type boolean = ::std::os::raw::c_int;
1580pub type JSAMPROW = *mut JSAMPLE;
1581pub type JSAMPARRAY = *mut JSAMPROW;
1582pub type JSAMPIMAGE = *mut JSAMPARRAY;
1583pub type JBLOCK = [JCOEF; 64usize];
1584pub type JBLOCKROW = *mut JBLOCK;
1585pub type JBLOCKARRAY = *mut JBLOCKROW;
1586pub type JBLOCKIMAGE = *mut JBLOCKARRAY;
1587pub type JCOEFPTR = *mut JCOEF;
1588#[repr(C)]
1589#[derive(Copy, Clone)]
1590pub struct JQUANT_TBL {
1591 pub quantval: [UINT16; 64usize],
1592 pub sent_table: boolean,
1593}
1594#[test]
1595fn bindgen_test_layout_JQUANT_TBL() {
1596 assert_eq!(
1597 ::std::mem::size_of::<JQUANT_TBL>(),
1598 132usize,
1599 concat!("Size of: ", stringify!(JQUANT_TBL))
1600 );
1601 assert_eq!(
1602 ::std::mem::align_of::<JQUANT_TBL>(),
1603 4usize,
1604 concat!("Alignment of ", stringify!(JQUANT_TBL))
1605 );
1606 assert_eq!(
1607 unsafe { &(*(::std::ptr::null::<JQUANT_TBL>())).quantval as *const _ as usize },
1608 0usize,
1609 concat!(
1610 "Offset of field: ",
1611 stringify!(JQUANT_TBL),
1612 "::",
1613 stringify!(quantval)
1614 )
1615 );
1616 assert_eq!(
1617 unsafe { &(*(::std::ptr::null::<JQUANT_TBL>())).sent_table as *const _ as usize },
1618 128usize,
1619 concat!(
1620 "Offset of field: ",
1621 stringify!(JQUANT_TBL),
1622 "::",
1623 stringify!(sent_table)
1624 )
1625 );
1626}
1627#[repr(C)]
1628#[derive(Copy, Clone)]
1629pub struct JHUFF_TBL {
1630 pub bits: [UINT8; 17usize],
1631 pub huffval: [UINT8; 256usize],
1632 pub sent_table: boolean,
1633}
1634#[test]
1635fn bindgen_test_layout_JHUFF_TBL() {
1636 assert_eq!(
1637 ::std::mem::size_of::<JHUFF_TBL>(),
1638 280usize,
1639 concat!("Size of: ", stringify!(JHUFF_TBL))
1640 );
1641 assert_eq!(
1642 ::std::mem::align_of::<JHUFF_TBL>(),
1643 4usize,
1644 concat!("Alignment of ", stringify!(JHUFF_TBL))
1645 );
1646 assert_eq!(
1647 unsafe { &(*(::std::ptr::null::<JHUFF_TBL>())).bits as *const _ as usize },
1648 0usize,
1649 concat!(
1650 "Offset of field: ",
1651 stringify!(JHUFF_TBL),
1652 "::",
1653 stringify!(bits)
1654 )
1655 );
1656 assert_eq!(
1657 unsafe { &(*(::std::ptr::null::<JHUFF_TBL>())).huffval as *const _ as usize },
1658 17usize,
1659 concat!(
1660 "Offset of field: ",
1661 stringify!(JHUFF_TBL),
1662 "::",
1663 stringify!(huffval)
1664 )
1665 );
1666 assert_eq!(
1667 unsafe { &(*(::std::ptr::null::<JHUFF_TBL>())).sent_table as *const _ as usize },
1668 276usize,
1669 concat!(
1670 "Offset of field: ",
1671 stringify!(JHUFF_TBL),
1672 "::",
1673 stringify!(sent_table)
1674 )
1675 );
1676}
1677#[repr(C)]
1678#[derive(Debug, Copy, Clone)]
1679pub struct jpeg_component_info {
1680 pub component_id: ::std::os::raw::c_int,
1681 pub component_index: ::std::os::raw::c_int,
1682 pub h_samp_factor: ::std::os::raw::c_int,
1683 pub v_samp_factor: ::std::os::raw::c_int,
1684 pub quant_tbl_no: ::std::os::raw::c_int,
1685 pub dc_tbl_no: ::std::os::raw::c_int,
1686 pub ac_tbl_no: ::std::os::raw::c_int,
1687 pub width_in_blocks: JDIMENSION,
1688 pub height_in_blocks: JDIMENSION,
1689 pub DCT_scaled_size: ::std::os::raw::c_int,
1690 pub downsampled_width: JDIMENSION,
1691 pub downsampled_height: JDIMENSION,
1692 pub component_needed: boolean,
1693 pub MCU_width: ::std::os::raw::c_int,
1694 pub MCU_height: ::std::os::raw::c_int,
1695 pub MCU_blocks: ::std::os::raw::c_int,
1696 pub MCU_sample_width: ::std::os::raw::c_int,
1697 pub last_col_width: ::std::os::raw::c_int,
1698 pub last_row_height: ::std::os::raw::c_int,
1699 pub quant_table: *mut JQUANT_TBL,
1700 pub dct_table: *mut ::std::os::raw::c_void,
1701}
1702#[test]
1703fn bindgen_test_layout_jpeg_component_info() {
1704 assert_eq!(
1705 ::std::mem::size_of::<jpeg_component_info>(),
1706 96usize,
1707 concat!("Size of: ", stringify!(jpeg_component_info))
1708 );
1709 assert_eq!(
1710 ::std::mem::align_of::<jpeg_component_info>(),
1711 8usize,
1712 concat!("Alignment of ", stringify!(jpeg_component_info))
1713 );
1714 assert_eq!(
1715 unsafe {
1716 &(*(::std::ptr::null::<jpeg_component_info>())).component_id as *const _ as usize
1717 },
1718 0usize,
1719 concat!(
1720 "Offset of field: ",
1721 stringify!(jpeg_component_info),
1722 "::",
1723 stringify!(component_id)
1724 )
1725 );
1726 assert_eq!(
1727 unsafe {
1728 &(*(::std::ptr::null::<jpeg_component_info>())).component_index as *const _ as usize
1729 },
1730 4usize,
1731 concat!(
1732 "Offset of field: ",
1733 stringify!(jpeg_component_info),
1734 "::",
1735 stringify!(component_index)
1736 )
1737 );
1738 assert_eq!(
1739 unsafe {
1740 &(*(::std::ptr::null::<jpeg_component_info>())).h_samp_factor as *const _ as usize
1741 },
1742 8usize,
1743 concat!(
1744 "Offset of field: ",
1745 stringify!(jpeg_component_info),
1746 "::",
1747 stringify!(h_samp_factor)
1748 )
1749 );
1750 assert_eq!(
1751 unsafe {
1752 &(*(::std::ptr::null::<jpeg_component_info>())).v_samp_factor as *const _ as usize
1753 },
1754 12usize,
1755 concat!(
1756 "Offset of field: ",
1757 stringify!(jpeg_component_info),
1758 "::",
1759 stringify!(v_samp_factor)
1760 )
1761 );
1762 assert_eq!(
1763 unsafe {
1764 &(*(::std::ptr::null::<jpeg_component_info>())).quant_tbl_no as *const _ as usize
1765 },
1766 16usize,
1767 concat!(
1768 "Offset of field: ",
1769 stringify!(jpeg_component_info),
1770 "::",
1771 stringify!(quant_tbl_no)
1772 )
1773 );
1774 assert_eq!(
1775 unsafe { &(*(::std::ptr::null::<jpeg_component_info>())).dc_tbl_no as *const _ as usize },
1776 20usize,
1777 concat!(
1778 "Offset of field: ",
1779 stringify!(jpeg_component_info),
1780 "::",
1781 stringify!(dc_tbl_no)
1782 )
1783 );
1784 assert_eq!(
1785 unsafe { &(*(::std::ptr::null::<jpeg_component_info>())).ac_tbl_no as *const _ as usize },
1786 24usize,
1787 concat!(
1788 "Offset of field: ",
1789 stringify!(jpeg_component_info),
1790 "::",
1791 stringify!(ac_tbl_no)
1792 )
1793 );
1794 assert_eq!(
1795 unsafe {
1796 &(*(::std::ptr::null::<jpeg_component_info>())).width_in_blocks as *const _ as usize
1797 },
1798 28usize,
1799 concat!(
1800 "Offset of field: ",
1801 stringify!(jpeg_component_info),
1802 "::",
1803 stringify!(width_in_blocks)
1804 )
1805 );
1806 assert_eq!(
1807 unsafe {
1808 &(*(::std::ptr::null::<jpeg_component_info>())).height_in_blocks as *const _ as usize
1809 },
1810 32usize,
1811 concat!(
1812 "Offset of field: ",
1813 stringify!(jpeg_component_info),
1814 "::",
1815 stringify!(height_in_blocks)
1816 )
1817 );
1818 assert_eq!(
1819 unsafe {
1820 &(*(::std::ptr::null::<jpeg_component_info>())).DCT_scaled_size as *const _ as usize
1821 },
1822 36usize,
1823 concat!(
1824 "Offset of field: ",
1825 stringify!(jpeg_component_info),
1826 "::",
1827 stringify!(DCT_scaled_size)
1828 )
1829 );
1830 assert_eq!(
1831 unsafe {
1832 &(*(::std::ptr::null::<jpeg_component_info>())).downsampled_width as *const _ as usize
1833 },
1834 40usize,
1835 concat!(
1836 "Offset of field: ",
1837 stringify!(jpeg_component_info),
1838 "::",
1839 stringify!(downsampled_width)
1840 )
1841 );
1842 assert_eq!(
1843 unsafe {
1844 &(*(::std::ptr::null::<jpeg_component_info>())).downsampled_height as *const _ as usize
1845 },
1846 44usize,
1847 concat!(
1848 "Offset of field: ",
1849 stringify!(jpeg_component_info),
1850 "::",
1851 stringify!(downsampled_height)
1852 )
1853 );
1854 assert_eq!(
1855 unsafe {
1856 &(*(::std::ptr::null::<jpeg_component_info>())).component_needed as *const _ as usize
1857 },
1858 48usize,
1859 concat!(
1860 "Offset of field: ",
1861 stringify!(jpeg_component_info),
1862 "::",
1863 stringify!(component_needed)
1864 )
1865 );
1866 assert_eq!(
1867 unsafe { &(*(::std::ptr::null::<jpeg_component_info>())).MCU_width as *const _ as usize },
1868 52usize,
1869 concat!(
1870 "Offset of field: ",
1871 stringify!(jpeg_component_info),
1872 "::",
1873 stringify!(MCU_width)
1874 )
1875 );
1876 assert_eq!(
1877 unsafe { &(*(::std::ptr::null::<jpeg_component_info>())).MCU_height as *const _ as usize },
1878 56usize,
1879 concat!(
1880 "Offset of field: ",
1881 stringify!(jpeg_component_info),
1882 "::",
1883 stringify!(MCU_height)
1884 )
1885 );
1886 assert_eq!(
1887 unsafe { &(*(::std::ptr::null::<jpeg_component_info>())).MCU_blocks as *const _ as usize },
1888 60usize,
1889 concat!(
1890 "Offset of field: ",
1891 stringify!(jpeg_component_info),
1892 "::",
1893 stringify!(MCU_blocks)
1894 )
1895 );
1896 assert_eq!(
1897 unsafe {
1898 &(*(::std::ptr::null::<jpeg_component_info>())).MCU_sample_width as *const _ as usize
1899 },
1900 64usize,
1901 concat!(
1902 "Offset of field: ",
1903 stringify!(jpeg_component_info),
1904 "::",
1905 stringify!(MCU_sample_width)
1906 )
1907 );
1908 assert_eq!(
1909 unsafe {
1910 &(*(::std::ptr::null::<jpeg_component_info>())).last_col_width as *const _ as usize
1911 },
1912 68usize,
1913 concat!(
1914 "Offset of field: ",
1915 stringify!(jpeg_component_info),
1916 "::",
1917 stringify!(last_col_width)
1918 )
1919 );
1920 assert_eq!(
1921 unsafe {
1922 &(*(::std::ptr::null::<jpeg_component_info>())).last_row_height as *const _ as usize
1923 },
1924 72usize,
1925 concat!(
1926 "Offset of field: ",
1927 stringify!(jpeg_component_info),
1928 "::",
1929 stringify!(last_row_height)
1930 )
1931 );
1932 assert_eq!(
1933 unsafe { &(*(::std::ptr::null::<jpeg_component_info>())).quant_table as *const _ as usize },
1934 80usize,
1935 concat!(
1936 "Offset of field: ",
1937 stringify!(jpeg_component_info),
1938 "::",
1939 stringify!(quant_table)
1940 )
1941 );
1942 assert_eq!(
1943 unsafe { &(*(::std::ptr::null::<jpeg_component_info>())).dct_table as *const _ as usize },
1944 88usize,
1945 concat!(
1946 "Offset of field: ",
1947 stringify!(jpeg_component_info),
1948 "::",
1949 stringify!(dct_table)
1950 )
1951 );
1952}
1953#[repr(C)]
1954#[derive(Debug, Copy, Clone)]
1955pub struct jpeg_scan_info {
1956 pub comps_in_scan: ::std::os::raw::c_int,
1957 pub component_index: [::std::os::raw::c_int; 4usize],
1958 pub Ss: ::std::os::raw::c_int,
1959 pub Se: ::std::os::raw::c_int,
1960 pub Ah: ::std::os::raw::c_int,
1961 pub Al: ::std::os::raw::c_int,
1962}
1963#[test]
1964fn bindgen_test_layout_jpeg_scan_info() {
1965 assert_eq!(
1966 ::std::mem::size_of::<jpeg_scan_info>(),
1967 36usize,
1968 concat!("Size of: ", stringify!(jpeg_scan_info))
1969 );
1970 assert_eq!(
1971 ::std::mem::align_of::<jpeg_scan_info>(),
1972 4usize,
1973 concat!("Alignment of ", stringify!(jpeg_scan_info))
1974 );
1975 assert_eq!(
1976 unsafe { &(*(::std::ptr::null::<jpeg_scan_info>())).comps_in_scan as *const _ as usize },
1977 0usize,
1978 concat!(
1979 "Offset of field: ",
1980 stringify!(jpeg_scan_info),
1981 "::",
1982 stringify!(comps_in_scan)
1983 )
1984 );
1985 assert_eq!(
1986 unsafe { &(*(::std::ptr::null::<jpeg_scan_info>())).component_index as *const _ as usize },
1987 4usize,
1988 concat!(
1989 "Offset of field: ",
1990 stringify!(jpeg_scan_info),
1991 "::",
1992 stringify!(component_index)
1993 )
1994 );
1995 assert_eq!(
1996 unsafe { &(*(::std::ptr::null::<jpeg_scan_info>())).Ss as *const _ as usize },
1997 20usize,
1998 concat!(
1999 "Offset of field: ",
2000 stringify!(jpeg_scan_info),
2001 "::",
2002 stringify!(Ss)
2003 )
2004 );
2005 assert_eq!(
2006 unsafe { &(*(::std::ptr::null::<jpeg_scan_info>())).Se as *const _ as usize },
2007 24usize,
2008 concat!(
2009 "Offset of field: ",
2010 stringify!(jpeg_scan_info),
2011 "::",
2012 stringify!(Se)
2013 )
2014 );
2015 assert_eq!(
2016 unsafe { &(*(::std::ptr::null::<jpeg_scan_info>())).Ah as *const _ as usize },
2017 28usize,
2018 concat!(
2019 "Offset of field: ",
2020 stringify!(jpeg_scan_info),
2021 "::",
2022 stringify!(Ah)
2023 )
2024 );
2025 assert_eq!(
2026 unsafe { &(*(::std::ptr::null::<jpeg_scan_info>())).Al as *const _ as usize },
2027 32usize,
2028 concat!(
2029 "Offset of field: ",
2030 stringify!(jpeg_scan_info),
2031 "::",
2032 stringify!(Al)
2033 )
2034 );
2035}
2036pub type jpeg_saved_marker_ptr = *mut jpeg_marker_struct;
2037#[repr(C)]
2038#[derive(Debug, Copy, Clone)]
2039pub struct jpeg_marker_struct {
2040 pub next: jpeg_saved_marker_ptr,
2041 pub marker: UINT8,
2042 pub original_length: ::std::os::raw::c_uint,
2043 pub data_length: ::std::os::raw::c_uint,
2044 pub data: *mut JOCTET,
2045}
2046#[test]
2047fn bindgen_test_layout_jpeg_marker_struct() {
2048 assert_eq!(
2049 ::std::mem::size_of::<jpeg_marker_struct>(),
2050 32usize,
2051 concat!("Size of: ", stringify!(jpeg_marker_struct))
2052 );
2053 assert_eq!(
2054 ::std::mem::align_of::<jpeg_marker_struct>(),
2055 8usize,
2056 concat!("Alignment of ", stringify!(jpeg_marker_struct))
2057 );
2058 assert_eq!(
2059 unsafe { &(*(::std::ptr::null::<jpeg_marker_struct>())).next as *const _ as usize },
2060 0usize,
2061 concat!(
2062 "Offset of field: ",
2063 stringify!(jpeg_marker_struct),
2064 "::",
2065 stringify!(next)
2066 )
2067 );
2068 assert_eq!(
2069 unsafe { &(*(::std::ptr::null::<jpeg_marker_struct>())).marker as *const _ as usize },
2070 8usize,
2071 concat!(
2072 "Offset of field: ",
2073 stringify!(jpeg_marker_struct),
2074 "::",
2075 stringify!(marker)
2076 )
2077 );
2078 assert_eq!(
2079 unsafe {
2080 &(*(::std::ptr::null::<jpeg_marker_struct>())).original_length as *const _ as usize
2081 },
2082 12usize,
2083 concat!(
2084 "Offset of field: ",
2085 stringify!(jpeg_marker_struct),
2086 "::",
2087 stringify!(original_length)
2088 )
2089 );
2090 assert_eq!(
2091 unsafe { &(*(::std::ptr::null::<jpeg_marker_struct>())).data_length as *const _ as usize },
2092 16usize,
2093 concat!(
2094 "Offset of field: ",
2095 stringify!(jpeg_marker_struct),
2096 "::",
2097 stringify!(data_length)
2098 )
2099 );
2100 assert_eq!(
2101 unsafe { &(*(::std::ptr::null::<jpeg_marker_struct>())).data as *const _ as usize },
2102 24usize,
2103 concat!(
2104 "Offset of field: ",
2105 stringify!(jpeg_marker_struct),
2106 "::",
2107 stringify!(data)
2108 )
2109 );
2110}
2111pub const J_COLOR_SPACE_JCS_UNKNOWN: J_COLOR_SPACE = 0;
2112pub const J_COLOR_SPACE_JCS_GRAYSCALE: J_COLOR_SPACE = 1;
2113pub const J_COLOR_SPACE_JCS_RGB: J_COLOR_SPACE = 2;
2114pub const J_COLOR_SPACE_JCS_YCbCr: J_COLOR_SPACE = 3;
2115pub const J_COLOR_SPACE_JCS_CMYK: J_COLOR_SPACE = 4;
2116pub const J_COLOR_SPACE_JCS_YCCK: J_COLOR_SPACE = 5;
2117pub const J_COLOR_SPACE_JCS_EXT_RGB: J_COLOR_SPACE = 6;
2118pub const J_COLOR_SPACE_JCS_EXT_RGBX: J_COLOR_SPACE = 7;
2119pub const J_COLOR_SPACE_JCS_EXT_BGR: J_COLOR_SPACE = 8;
2120pub const J_COLOR_SPACE_JCS_EXT_BGRX: J_COLOR_SPACE = 9;
2121pub const J_COLOR_SPACE_JCS_EXT_XBGR: J_COLOR_SPACE = 10;
2122pub const J_COLOR_SPACE_JCS_EXT_XRGB: J_COLOR_SPACE = 11;
2123pub const J_COLOR_SPACE_JCS_EXT_RGBA: J_COLOR_SPACE = 12;
2124pub const J_COLOR_SPACE_JCS_EXT_BGRA: J_COLOR_SPACE = 13;
2125pub const J_COLOR_SPACE_JCS_EXT_ABGR: J_COLOR_SPACE = 14;
2126pub const J_COLOR_SPACE_JCS_EXT_ARGB: J_COLOR_SPACE = 15;
2127pub const J_COLOR_SPACE_JCS_RGB565: J_COLOR_SPACE = 16;
2128pub type J_COLOR_SPACE = u32;
2129pub const J_DCT_METHOD_JDCT_ISLOW: J_DCT_METHOD = 0;
2130pub const J_DCT_METHOD_JDCT_IFAST: J_DCT_METHOD = 1;
2131pub const J_DCT_METHOD_JDCT_FLOAT: J_DCT_METHOD = 2;
2132pub type J_DCT_METHOD = u32;
2133pub const J_DITHER_MODE_JDITHER_NONE: J_DITHER_MODE = 0;
2134pub const J_DITHER_MODE_JDITHER_ORDERED: J_DITHER_MODE = 1;
2135pub const J_DITHER_MODE_JDITHER_FS: J_DITHER_MODE = 2;
2136pub type J_DITHER_MODE = u32;
2137#[repr(C)]
2138#[derive(Debug, Copy, Clone)]
2139pub struct jpeg_common_struct {
2140 pub err: *mut jpeg_error_mgr,
2141 pub mem: *mut jpeg_memory_mgr,
2142 pub progress: *mut jpeg_progress_mgr,
2143 pub client_data: *mut ::std::os::raw::c_void,
2144 pub is_decompressor: boolean,
2145 pub global_state: ::std::os::raw::c_int,
2146}
2147#[test]
2148fn bindgen_test_layout_jpeg_common_struct() {
2149 assert_eq!(
2150 ::std::mem::size_of::<jpeg_common_struct>(),
2151 40usize,
2152 concat!("Size of: ", stringify!(jpeg_common_struct))
2153 );
2154 assert_eq!(
2155 ::std::mem::align_of::<jpeg_common_struct>(),
2156 8usize,
2157 concat!("Alignment of ", stringify!(jpeg_common_struct))
2158 );
2159 assert_eq!(
2160 unsafe { &(*(::std::ptr::null::<jpeg_common_struct>())).err as *const _ as usize },
2161 0usize,
2162 concat!(
2163 "Offset of field: ",
2164 stringify!(jpeg_common_struct),
2165 "::",
2166 stringify!(err)
2167 )
2168 );
2169 assert_eq!(
2170 unsafe { &(*(::std::ptr::null::<jpeg_common_struct>())).mem as *const _ as usize },
2171 8usize,
2172 concat!(
2173 "Offset of field: ",
2174 stringify!(jpeg_common_struct),
2175 "::",
2176 stringify!(mem)
2177 )
2178 );
2179 assert_eq!(
2180 unsafe { &(*(::std::ptr::null::<jpeg_common_struct>())).progress as *const _ as usize },
2181 16usize,
2182 concat!(
2183 "Offset of field: ",
2184 stringify!(jpeg_common_struct),
2185 "::",
2186 stringify!(progress)
2187 )
2188 );
2189 assert_eq!(
2190 unsafe { &(*(::std::ptr::null::<jpeg_common_struct>())).client_data as *const _ as usize },
2191 24usize,
2192 concat!(
2193 "Offset of field: ",
2194 stringify!(jpeg_common_struct),
2195 "::",
2196 stringify!(client_data)
2197 )
2198 );
2199 assert_eq!(
2200 unsafe {
2201 &(*(::std::ptr::null::<jpeg_common_struct>())).is_decompressor as *const _ as usize
2202 },
2203 32usize,
2204 concat!(
2205 "Offset of field: ",
2206 stringify!(jpeg_common_struct),
2207 "::",
2208 stringify!(is_decompressor)
2209 )
2210 );
2211 assert_eq!(
2212 unsafe { &(*(::std::ptr::null::<jpeg_common_struct>())).global_state as *const _ as usize },
2213 36usize,
2214 concat!(
2215 "Offset of field: ",
2216 stringify!(jpeg_common_struct),
2217 "::",
2218 stringify!(global_state)
2219 )
2220 );
2221}
2222pub type j_common_ptr = *mut jpeg_common_struct;
2223pub type j_compress_ptr = *mut jpeg_compress_struct;
2224pub type j_decompress_ptr = *mut jpeg_decompress_struct;
2225#[repr(C)]
2226#[derive(Debug, Copy, Clone)]
2227pub struct jpeg_compress_struct {
2228 pub err: *mut jpeg_error_mgr,
2229 pub mem: *mut jpeg_memory_mgr,
2230 pub progress: *mut jpeg_progress_mgr,
2231 pub client_data: *mut ::std::os::raw::c_void,
2232 pub is_decompressor: boolean,
2233 pub global_state: ::std::os::raw::c_int,
2234 pub dest: *mut jpeg_destination_mgr,
2235 pub image_width: JDIMENSION,
2236 pub image_height: JDIMENSION,
2237 pub input_components: ::std::os::raw::c_int,
2238 pub in_color_space: J_COLOR_SPACE,
2239 pub input_gamma: f64,
2240 pub data_precision: ::std::os::raw::c_int,
2241 pub num_components: ::std::os::raw::c_int,
2242 pub jpeg_color_space: J_COLOR_SPACE,
2243 pub comp_info: *mut jpeg_component_info,
2244 pub quant_tbl_ptrs: [*mut JQUANT_TBL; 4usize],
2245 pub dc_huff_tbl_ptrs: [*mut JHUFF_TBL; 4usize],
2246 pub ac_huff_tbl_ptrs: [*mut JHUFF_TBL; 4usize],
2247 pub arith_dc_L: [UINT8; 16usize],
2248 pub arith_dc_U: [UINT8; 16usize],
2249 pub arith_ac_K: [UINT8; 16usize],
2250 pub num_scans: ::std::os::raw::c_int,
2251 pub scan_info: *const jpeg_scan_info,
2252 pub raw_data_in: boolean,
2253 pub arith_code: boolean,
2254 pub optimize_coding: boolean,
2255 pub CCIR601_sampling: boolean,
2256 pub smoothing_factor: ::std::os::raw::c_int,
2257 pub dct_method: J_DCT_METHOD,
2258 pub restart_interval: ::std::os::raw::c_uint,
2259 pub restart_in_rows: ::std::os::raw::c_int,
2260 pub write_JFIF_header: boolean,
2261 pub JFIF_major_version: UINT8,
2262 pub JFIF_minor_version: UINT8,
2263 pub density_unit: UINT8,
2264 pub X_density: UINT16,
2265 pub Y_density: UINT16,
2266 pub write_Adobe_marker: boolean,
2267 pub next_scanline: JDIMENSION,
2268 pub progressive_mode: boolean,
2269 pub max_h_samp_factor: ::std::os::raw::c_int,
2270 pub max_v_samp_factor: ::std::os::raw::c_int,
2271 pub total_iMCU_rows: JDIMENSION,
2272 pub comps_in_scan: ::std::os::raw::c_int,
2273 pub cur_comp_info: [*mut jpeg_component_info; 4usize],
2274 pub MCUs_per_row: JDIMENSION,
2275 pub MCU_rows_in_scan: JDIMENSION,
2276 pub blocks_in_MCU: ::std::os::raw::c_int,
2277 pub MCU_membership: [::std::os::raw::c_int; 10usize],
2278 pub Ss: ::std::os::raw::c_int,
2279 pub Se: ::std::os::raw::c_int,
2280 pub Ah: ::std::os::raw::c_int,
2281 pub Al: ::std::os::raw::c_int,
2282 pub master: *mut jpeg_comp_master,
2283 pub main: *mut jpeg_c_main_controller,
2284 pub prep: *mut jpeg_c_prep_controller,
2285 pub coef: *mut jpeg_c_coef_controller,
2286 pub marker: *mut jpeg_marker_writer,
2287 pub cconvert: *mut jpeg_color_converter,
2288 pub downsample: *mut jpeg_downsampler,
2289 pub fdct: *mut jpeg_forward_dct,
2290 pub entropy: *mut jpeg_entropy_encoder,
2291 pub script_space: *mut jpeg_scan_info,
2292 pub script_space_size: ::std::os::raw::c_int,
2293}
2294#[test]
2295fn bindgen_test_layout_jpeg_compress_struct() {
2296 assert_eq!(
2297 ::std::mem::size_of::<jpeg_compress_struct>(),
2298 520usize,
2299 concat!("Size of: ", stringify!(jpeg_compress_struct))
2300 );
2301 assert_eq!(
2302 ::std::mem::align_of::<jpeg_compress_struct>(),
2303 8usize,
2304 concat!("Alignment of ", stringify!(jpeg_compress_struct))
2305 );
2306 assert_eq!(
2307 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).err as *const _ as usize },
2308 0usize,
2309 concat!(
2310 "Offset of field: ",
2311 stringify!(jpeg_compress_struct),
2312 "::",
2313 stringify!(err)
2314 )
2315 );
2316 assert_eq!(
2317 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).mem as *const _ as usize },
2318 8usize,
2319 concat!(
2320 "Offset of field: ",
2321 stringify!(jpeg_compress_struct),
2322 "::",
2323 stringify!(mem)
2324 )
2325 );
2326 assert_eq!(
2327 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).progress as *const _ as usize },
2328 16usize,
2329 concat!(
2330 "Offset of field: ",
2331 stringify!(jpeg_compress_struct),
2332 "::",
2333 stringify!(progress)
2334 )
2335 );
2336 assert_eq!(
2337 unsafe {
2338 &(*(::std::ptr::null::<jpeg_compress_struct>())).client_data as *const _ as usize
2339 },
2340 24usize,
2341 concat!(
2342 "Offset of field: ",
2343 stringify!(jpeg_compress_struct),
2344 "::",
2345 stringify!(client_data)
2346 )
2347 );
2348 assert_eq!(
2349 unsafe {
2350 &(*(::std::ptr::null::<jpeg_compress_struct>())).is_decompressor as *const _ as usize
2351 },
2352 32usize,
2353 concat!(
2354 "Offset of field: ",
2355 stringify!(jpeg_compress_struct),
2356 "::",
2357 stringify!(is_decompressor)
2358 )
2359 );
2360 assert_eq!(
2361 unsafe {
2362 &(*(::std::ptr::null::<jpeg_compress_struct>())).global_state as *const _ as usize
2363 },
2364 36usize,
2365 concat!(
2366 "Offset of field: ",
2367 stringify!(jpeg_compress_struct),
2368 "::",
2369 stringify!(global_state)
2370 )
2371 );
2372 assert_eq!(
2373 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).dest as *const _ as usize },
2374 40usize,
2375 concat!(
2376 "Offset of field: ",
2377 stringify!(jpeg_compress_struct),
2378 "::",
2379 stringify!(dest)
2380 )
2381 );
2382 assert_eq!(
2383 unsafe {
2384 &(*(::std::ptr::null::<jpeg_compress_struct>())).image_width as *const _ as usize
2385 },
2386 48usize,
2387 concat!(
2388 "Offset of field: ",
2389 stringify!(jpeg_compress_struct),
2390 "::",
2391 stringify!(image_width)
2392 )
2393 );
2394 assert_eq!(
2395 unsafe {
2396 &(*(::std::ptr::null::<jpeg_compress_struct>())).image_height as *const _ as usize
2397 },
2398 52usize,
2399 concat!(
2400 "Offset of field: ",
2401 stringify!(jpeg_compress_struct),
2402 "::",
2403 stringify!(image_height)
2404 )
2405 );
2406 assert_eq!(
2407 unsafe {
2408 &(*(::std::ptr::null::<jpeg_compress_struct>())).input_components as *const _ as usize
2409 },
2410 56usize,
2411 concat!(
2412 "Offset of field: ",
2413 stringify!(jpeg_compress_struct),
2414 "::",
2415 stringify!(input_components)
2416 )
2417 );
2418 assert_eq!(
2419 unsafe {
2420 &(*(::std::ptr::null::<jpeg_compress_struct>())).in_color_space as *const _ as usize
2421 },
2422 60usize,
2423 concat!(
2424 "Offset of field: ",
2425 stringify!(jpeg_compress_struct),
2426 "::",
2427 stringify!(in_color_space)
2428 )
2429 );
2430 assert_eq!(
2431 unsafe {
2432 &(*(::std::ptr::null::<jpeg_compress_struct>())).input_gamma as *const _ as usize
2433 },
2434 64usize,
2435 concat!(
2436 "Offset of field: ",
2437 stringify!(jpeg_compress_struct),
2438 "::",
2439 stringify!(input_gamma)
2440 )
2441 );
2442 assert_eq!(
2443 unsafe {
2444 &(*(::std::ptr::null::<jpeg_compress_struct>())).data_precision as *const _ as usize
2445 },
2446 72usize,
2447 concat!(
2448 "Offset of field: ",
2449 stringify!(jpeg_compress_struct),
2450 "::",
2451 stringify!(data_precision)
2452 )
2453 );
2454 assert_eq!(
2455 unsafe {
2456 &(*(::std::ptr::null::<jpeg_compress_struct>())).num_components as *const _ as usize
2457 },
2458 76usize,
2459 concat!(
2460 "Offset of field: ",
2461 stringify!(jpeg_compress_struct),
2462 "::",
2463 stringify!(num_components)
2464 )
2465 );
2466 assert_eq!(
2467 unsafe {
2468 &(*(::std::ptr::null::<jpeg_compress_struct>())).jpeg_color_space as *const _ as usize
2469 },
2470 80usize,
2471 concat!(
2472 "Offset of field: ",
2473 stringify!(jpeg_compress_struct),
2474 "::",
2475 stringify!(jpeg_color_space)
2476 )
2477 );
2478 assert_eq!(
2479 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).comp_info as *const _ as usize },
2480 88usize,
2481 concat!(
2482 "Offset of field: ",
2483 stringify!(jpeg_compress_struct),
2484 "::",
2485 stringify!(comp_info)
2486 )
2487 );
2488 assert_eq!(
2489 unsafe {
2490 &(*(::std::ptr::null::<jpeg_compress_struct>())).quant_tbl_ptrs as *const _ as usize
2491 },
2492 96usize,
2493 concat!(
2494 "Offset of field: ",
2495 stringify!(jpeg_compress_struct),
2496 "::",
2497 stringify!(quant_tbl_ptrs)
2498 )
2499 );
2500 assert_eq!(
2501 unsafe {
2502 &(*(::std::ptr::null::<jpeg_compress_struct>())).dc_huff_tbl_ptrs as *const _ as usize
2503 },
2504 128usize,
2505 concat!(
2506 "Offset of field: ",
2507 stringify!(jpeg_compress_struct),
2508 "::",
2509 stringify!(dc_huff_tbl_ptrs)
2510 )
2511 );
2512 assert_eq!(
2513 unsafe {
2514 &(*(::std::ptr::null::<jpeg_compress_struct>())).ac_huff_tbl_ptrs as *const _ as usize
2515 },
2516 160usize,
2517 concat!(
2518 "Offset of field: ",
2519 stringify!(jpeg_compress_struct),
2520 "::",
2521 stringify!(ac_huff_tbl_ptrs)
2522 )
2523 );
2524 assert_eq!(
2525 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).arith_dc_L as *const _ as usize },
2526 192usize,
2527 concat!(
2528 "Offset of field: ",
2529 stringify!(jpeg_compress_struct),
2530 "::",
2531 stringify!(arith_dc_L)
2532 )
2533 );
2534 assert_eq!(
2535 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).arith_dc_U as *const _ as usize },
2536 208usize,
2537 concat!(
2538 "Offset of field: ",
2539 stringify!(jpeg_compress_struct),
2540 "::",
2541 stringify!(arith_dc_U)
2542 )
2543 );
2544 assert_eq!(
2545 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).arith_ac_K as *const _ as usize },
2546 224usize,
2547 concat!(
2548 "Offset of field: ",
2549 stringify!(jpeg_compress_struct),
2550 "::",
2551 stringify!(arith_ac_K)
2552 )
2553 );
2554 assert_eq!(
2555 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).num_scans as *const _ as usize },
2556 240usize,
2557 concat!(
2558 "Offset of field: ",
2559 stringify!(jpeg_compress_struct),
2560 "::",
2561 stringify!(num_scans)
2562 )
2563 );
2564 assert_eq!(
2565 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).scan_info as *const _ as usize },
2566 248usize,
2567 concat!(
2568 "Offset of field: ",
2569 stringify!(jpeg_compress_struct),
2570 "::",
2571 stringify!(scan_info)
2572 )
2573 );
2574 assert_eq!(
2575 unsafe {
2576 &(*(::std::ptr::null::<jpeg_compress_struct>())).raw_data_in as *const _ as usize
2577 },
2578 256usize,
2579 concat!(
2580 "Offset of field: ",
2581 stringify!(jpeg_compress_struct),
2582 "::",
2583 stringify!(raw_data_in)
2584 )
2585 );
2586 assert_eq!(
2587 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).arith_code as *const _ as usize },
2588 260usize,
2589 concat!(
2590 "Offset of field: ",
2591 stringify!(jpeg_compress_struct),
2592 "::",
2593 stringify!(arith_code)
2594 )
2595 );
2596 assert_eq!(
2597 unsafe {
2598 &(*(::std::ptr::null::<jpeg_compress_struct>())).optimize_coding as *const _ as usize
2599 },
2600 264usize,
2601 concat!(
2602 "Offset of field: ",
2603 stringify!(jpeg_compress_struct),
2604 "::",
2605 stringify!(optimize_coding)
2606 )
2607 );
2608 assert_eq!(
2609 unsafe {
2610 &(*(::std::ptr::null::<jpeg_compress_struct>())).CCIR601_sampling as *const _ as usize
2611 },
2612 268usize,
2613 concat!(
2614 "Offset of field: ",
2615 stringify!(jpeg_compress_struct),
2616 "::",
2617 stringify!(CCIR601_sampling)
2618 )
2619 );
2620 assert_eq!(
2621 unsafe {
2622 &(*(::std::ptr::null::<jpeg_compress_struct>())).smoothing_factor as *const _ as usize
2623 },
2624 272usize,
2625 concat!(
2626 "Offset of field: ",
2627 stringify!(jpeg_compress_struct),
2628 "::",
2629 stringify!(smoothing_factor)
2630 )
2631 );
2632 assert_eq!(
2633 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).dct_method as *const _ as usize },
2634 276usize,
2635 concat!(
2636 "Offset of field: ",
2637 stringify!(jpeg_compress_struct),
2638 "::",
2639 stringify!(dct_method)
2640 )
2641 );
2642 assert_eq!(
2643 unsafe {
2644 &(*(::std::ptr::null::<jpeg_compress_struct>())).restart_interval as *const _ as usize
2645 },
2646 280usize,
2647 concat!(
2648 "Offset of field: ",
2649 stringify!(jpeg_compress_struct),
2650 "::",
2651 stringify!(restart_interval)
2652 )
2653 );
2654 assert_eq!(
2655 unsafe {
2656 &(*(::std::ptr::null::<jpeg_compress_struct>())).restart_in_rows as *const _ as usize
2657 },
2658 284usize,
2659 concat!(
2660 "Offset of field: ",
2661 stringify!(jpeg_compress_struct),
2662 "::",
2663 stringify!(restart_in_rows)
2664 )
2665 );
2666 assert_eq!(
2667 unsafe {
2668 &(*(::std::ptr::null::<jpeg_compress_struct>())).write_JFIF_header as *const _ as usize
2669 },
2670 288usize,
2671 concat!(
2672 "Offset of field: ",
2673 stringify!(jpeg_compress_struct),
2674 "::",
2675 stringify!(write_JFIF_header)
2676 )
2677 );
2678 assert_eq!(
2679 unsafe {
2680 &(*(::std::ptr::null::<jpeg_compress_struct>())).JFIF_major_version as *const _ as usize
2681 },
2682 292usize,
2683 concat!(
2684 "Offset of field: ",
2685 stringify!(jpeg_compress_struct),
2686 "::",
2687 stringify!(JFIF_major_version)
2688 )
2689 );
2690 assert_eq!(
2691 unsafe {
2692 &(*(::std::ptr::null::<jpeg_compress_struct>())).JFIF_minor_version as *const _ as usize
2693 },
2694 293usize,
2695 concat!(
2696 "Offset of field: ",
2697 stringify!(jpeg_compress_struct),
2698 "::",
2699 stringify!(JFIF_minor_version)
2700 )
2701 );
2702 assert_eq!(
2703 unsafe {
2704 &(*(::std::ptr::null::<jpeg_compress_struct>())).density_unit as *const _ as usize
2705 },
2706 294usize,
2707 concat!(
2708 "Offset of field: ",
2709 stringify!(jpeg_compress_struct),
2710 "::",
2711 stringify!(density_unit)
2712 )
2713 );
2714 assert_eq!(
2715 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).X_density as *const _ as usize },
2716 296usize,
2717 concat!(
2718 "Offset of field: ",
2719 stringify!(jpeg_compress_struct),
2720 "::",
2721 stringify!(X_density)
2722 )
2723 );
2724 assert_eq!(
2725 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).Y_density as *const _ as usize },
2726 298usize,
2727 concat!(
2728 "Offset of field: ",
2729 stringify!(jpeg_compress_struct),
2730 "::",
2731 stringify!(Y_density)
2732 )
2733 );
2734 assert_eq!(
2735 unsafe {
2736 &(*(::std::ptr::null::<jpeg_compress_struct>())).write_Adobe_marker as *const _ as usize
2737 },
2738 300usize,
2739 concat!(
2740 "Offset of field: ",
2741 stringify!(jpeg_compress_struct),
2742 "::",
2743 stringify!(write_Adobe_marker)
2744 )
2745 );
2746 assert_eq!(
2747 unsafe {
2748 &(*(::std::ptr::null::<jpeg_compress_struct>())).next_scanline as *const _ as usize
2749 },
2750 304usize,
2751 concat!(
2752 "Offset of field: ",
2753 stringify!(jpeg_compress_struct),
2754 "::",
2755 stringify!(next_scanline)
2756 )
2757 );
2758 assert_eq!(
2759 unsafe {
2760 &(*(::std::ptr::null::<jpeg_compress_struct>())).progressive_mode as *const _ as usize
2761 },
2762 308usize,
2763 concat!(
2764 "Offset of field: ",
2765 stringify!(jpeg_compress_struct),
2766 "::",
2767 stringify!(progressive_mode)
2768 )
2769 );
2770 assert_eq!(
2771 unsafe {
2772 &(*(::std::ptr::null::<jpeg_compress_struct>())).max_h_samp_factor as *const _ as usize
2773 },
2774 312usize,
2775 concat!(
2776 "Offset of field: ",
2777 stringify!(jpeg_compress_struct),
2778 "::",
2779 stringify!(max_h_samp_factor)
2780 )
2781 );
2782 assert_eq!(
2783 unsafe {
2784 &(*(::std::ptr::null::<jpeg_compress_struct>())).max_v_samp_factor as *const _ as usize
2785 },
2786 316usize,
2787 concat!(
2788 "Offset of field: ",
2789 stringify!(jpeg_compress_struct),
2790 "::",
2791 stringify!(max_v_samp_factor)
2792 )
2793 );
2794 assert_eq!(
2795 unsafe {
2796 &(*(::std::ptr::null::<jpeg_compress_struct>())).total_iMCU_rows as *const _ as usize
2797 },
2798 320usize,
2799 concat!(
2800 "Offset of field: ",
2801 stringify!(jpeg_compress_struct),
2802 "::",
2803 stringify!(total_iMCU_rows)
2804 )
2805 );
2806 assert_eq!(
2807 unsafe {
2808 &(*(::std::ptr::null::<jpeg_compress_struct>())).comps_in_scan as *const _ as usize
2809 },
2810 324usize,
2811 concat!(
2812 "Offset of field: ",
2813 stringify!(jpeg_compress_struct),
2814 "::",
2815 stringify!(comps_in_scan)
2816 )
2817 );
2818 assert_eq!(
2819 unsafe {
2820 &(*(::std::ptr::null::<jpeg_compress_struct>())).cur_comp_info as *const _ as usize
2821 },
2822 328usize,
2823 concat!(
2824 "Offset of field: ",
2825 stringify!(jpeg_compress_struct),
2826 "::",
2827 stringify!(cur_comp_info)
2828 )
2829 );
2830 assert_eq!(
2831 unsafe {
2832 &(*(::std::ptr::null::<jpeg_compress_struct>())).MCUs_per_row as *const _ as usize
2833 },
2834 360usize,
2835 concat!(
2836 "Offset of field: ",
2837 stringify!(jpeg_compress_struct),
2838 "::",
2839 stringify!(MCUs_per_row)
2840 )
2841 );
2842 assert_eq!(
2843 unsafe {
2844 &(*(::std::ptr::null::<jpeg_compress_struct>())).MCU_rows_in_scan as *const _ as usize
2845 },
2846 364usize,
2847 concat!(
2848 "Offset of field: ",
2849 stringify!(jpeg_compress_struct),
2850 "::",
2851 stringify!(MCU_rows_in_scan)
2852 )
2853 );
2854 assert_eq!(
2855 unsafe {
2856 &(*(::std::ptr::null::<jpeg_compress_struct>())).blocks_in_MCU as *const _ as usize
2857 },
2858 368usize,
2859 concat!(
2860 "Offset of field: ",
2861 stringify!(jpeg_compress_struct),
2862 "::",
2863 stringify!(blocks_in_MCU)
2864 )
2865 );
2866 assert_eq!(
2867 unsafe {
2868 &(*(::std::ptr::null::<jpeg_compress_struct>())).MCU_membership as *const _ as usize
2869 },
2870 372usize,
2871 concat!(
2872 "Offset of field: ",
2873 stringify!(jpeg_compress_struct),
2874 "::",
2875 stringify!(MCU_membership)
2876 )
2877 );
2878 assert_eq!(
2879 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).Ss as *const _ as usize },
2880 412usize,
2881 concat!(
2882 "Offset of field: ",
2883 stringify!(jpeg_compress_struct),
2884 "::",
2885 stringify!(Ss)
2886 )
2887 );
2888 assert_eq!(
2889 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).Se as *const _ as usize },
2890 416usize,
2891 concat!(
2892 "Offset of field: ",
2893 stringify!(jpeg_compress_struct),
2894 "::",
2895 stringify!(Se)
2896 )
2897 );
2898 assert_eq!(
2899 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).Ah as *const _ as usize },
2900 420usize,
2901 concat!(
2902 "Offset of field: ",
2903 stringify!(jpeg_compress_struct),
2904 "::",
2905 stringify!(Ah)
2906 )
2907 );
2908 assert_eq!(
2909 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).Al as *const _ as usize },
2910 424usize,
2911 concat!(
2912 "Offset of field: ",
2913 stringify!(jpeg_compress_struct),
2914 "::",
2915 stringify!(Al)
2916 )
2917 );
2918 assert_eq!(
2919 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).master as *const _ as usize },
2920 432usize,
2921 concat!(
2922 "Offset of field: ",
2923 stringify!(jpeg_compress_struct),
2924 "::",
2925 stringify!(master)
2926 )
2927 );
2928 assert_eq!(
2929 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).main as *const _ as usize },
2930 440usize,
2931 concat!(
2932 "Offset of field: ",
2933 stringify!(jpeg_compress_struct),
2934 "::",
2935 stringify!(main)
2936 )
2937 );
2938 assert_eq!(
2939 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).prep as *const _ as usize },
2940 448usize,
2941 concat!(
2942 "Offset of field: ",
2943 stringify!(jpeg_compress_struct),
2944 "::",
2945 stringify!(prep)
2946 )
2947 );
2948 assert_eq!(
2949 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).coef as *const _ as usize },
2950 456usize,
2951 concat!(
2952 "Offset of field: ",
2953 stringify!(jpeg_compress_struct),
2954 "::",
2955 stringify!(coef)
2956 )
2957 );
2958 assert_eq!(
2959 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).marker as *const _ as usize },
2960 464usize,
2961 concat!(
2962 "Offset of field: ",
2963 stringify!(jpeg_compress_struct),
2964 "::",
2965 stringify!(marker)
2966 )
2967 );
2968 assert_eq!(
2969 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).cconvert as *const _ as usize },
2970 472usize,
2971 concat!(
2972 "Offset of field: ",
2973 stringify!(jpeg_compress_struct),
2974 "::",
2975 stringify!(cconvert)
2976 )
2977 );
2978 assert_eq!(
2979 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).downsample as *const _ as usize },
2980 480usize,
2981 concat!(
2982 "Offset of field: ",
2983 stringify!(jpeg_compress_struct),
2984 "::",
2985 stringify!(downsample)
2986 )
2987 );
2988 assert_eq!(
2989 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).fdct as *const _ as usize },
2990 488usize,
2991 concat!(
2992 "Offset of field: ",
2993 stringify!(jpeg_compress_struct),
2994 "::",
2995 stringify!(fdct)
2996 )
2997 );
2998 assert_eq!(
2999 unsafe { &(*(::std::ptr::null::<jpeg_compress_struct>())).entropy as *const _ as usize },
3000 496usize,
3001 concat!(
3002 "Offset of field: ",
3003 stringify!(jpeg_compress_struct),
3004 "::",
3005 stringify!(entropy)
3006 )
3007 );
3008 assert_eq!(
3009 unsafe {
3010 &(*(::std::ptr::null::<jpeg_compress_struct>())).script_space as *const _ as usize
3011 },
3012 504usize,
3013 concat!(
3014 "Offset of field: ",
3015 stringify!(jpeg_compress_struct),
3016 "::",
3017 stringify!(script_space)
3018 )
3019 );
3020 assert_eq!(
3021 unsafe {
3022 &(*(::std::ptr::null::<jpeg_compress_struct>())).script_space_size as *const _ as usize
3023 },
3024 512usize,
3025 concat!(
3026 "Offset of field: ",
3027 stringify!(jpeg_compress_struct),
3028 "::",
3029 stringify!(script_space_size)
3030 )
3031 );
3032}
3033#[repr(C)]
3034#[derive(Debug, Copy, Clone)]
3035pub struct jpeg_decompress_struct {
3036 pub err: *mut jpeg_error_mgr,
3037 pub mem: *mut jpeg_memory_mgr,
3038 pub progress: *mut jpeg_progress_mgr,
3039 pub client_data: *mut ::std::os::raw::c_void,
3040 pub is_decompressor: boolean,
3041 pub global_state: ::std::os::raw::c_int,
3042 pub src: *mut jpeg_source_mgr,
3043 pub image_width: JDIMENSION,
3044 pub image_height: JDIMENSION,
3045 pub num_components: ::std::os::raw::c_int,
3046 pub jpeg_color_space: J_COLOR_SPACE,
3047 pub out_color_space: J_COLOR_SPACE,
3048 pub scale_num: ::std::os::raw::c_uint,
3049 pub scale_denom: ::std::os::raw::c_uint,
3050 pub output_gamma: f64,
3051 pub buffered_image: boolean,
3052 pub raw_data_out: boolean,
3053 pub dct_method: J_DCT_METHOD,
3054 pub do_fancy_upsampling: boolean,
3055 pub do_block_smoothing: boolean,
3056 pub quantize_colors: boolean,
3057 pub dither_mode: J_DITHER_MODE,
3058 pub two_pass_quantize: boolean,
3059 pub desired_number_of_colors: ::std::os::raw::c_int,
3060 pub enable_1pass_quant: boolean,
3061 pub enable_external_quant: boolean,
3062 pub enable_2pass_quant: boolean,
3063 pub output_width: JDIMENSION,
3064 pub output_height: JDIMENSION,
3065 pub out_color_components: ::std::os::raw::c_int,
3066 pub output_components: ::std::os::raw::c_int,
3067 pub rec_outbuf_height: ::std::os::raw::c_int,
3068 pub actual_number_of_colors: ::std::os::raw::c_int,
3069 pub colormap: JSAMPARRAY,
3070 pub output_scanline: JDIMENSION,
3071 pub input_scan_number: ::std::os::raw::c_int,
3072 pub input_iMCU_row: JDIMENSION,
3073 pub output_scan_number: ::std::os::raw::c_int,
3074 pub output_iMCU_row: JDIMENSION,
3075 pub coef_bits: *mut [::std::os::raw::c_int; 64usize],
3076 pub quant_tbl_ptrs: [*mut JQUANT_TBL; 4usize],
3077 pub dc_huff_tbl_ptrs: [*mut JHUFF_TBL; 4usize],
3078 pub ac_huff_tbl_ptrs: [*mut JHUFF_TBL; 4usize],
3079 pub data_precision: ::std::os::raw::c_int,
3080 pub comp_info: *mut jpeg_component_info,
3081 pub progressive_mode: boolean,
3082 pub arith_code: boolean,
3083 pub arith_dc_L: [UINT8; 16usize],
3084 pub arith_dc_U: [UINT8; 16usize],
3085 pub arith_ac_K: [UINT8; 16usize],
3086 pub restart_interval: ::std::os::raw::c_uint,
3087 pub saw_JFIF_marker: boolean,
3088 pub JFIF_major_version: UINT8,
3089 pub JFIF_minor_version: UINT8,
3090 pub density_unit: UINT8,
3091 pub X_density: UINT16,
3092 pub Y_density: UINT16,
3093 pub saw_Adobe_marker: boolean,
3094 pub Adobe_transform: UINT8,
3095 pub CCIR601_sampling: boolean,
3096 pub marker_list: jpeg_saved_marker_ptr,
3097 pub max_h_samp_factor: ::std::os::raw::c_int,
3098 pub max_v_samp_factor: ::std::os::raw::c_int,
3099 pub min_DCT_scaled_size: ::std::os::raw::c_int,
3100 pub total_iMCU_rows: JDIMENSION,
3101 pub sample_range_limit: *mut JSAMPLE,
3102 pub comps_in_scan: ::std::os::raw::c_int,
3103 pub cur_comp_info: [*mut jpeg_component_info; 4usize],
3104 pub MCUs_per_row: JDIMENSION,
3105 pub MCU_rows_in_scan: JDIMENSION,
3106 pub blocks_in_MCU: ::std::os::raw::c_int,
3107 pub MCU_membership: [::std::os::raw::c_int; 10usize],
3108 pub Ss: ::std::os::raw::c_int,
3109 pub Se: ::std::os::raw::c_int,
3110 pub Ah: ::std::os::raw::c_int,
3111 pub Al: ::std::os::raw::c_int,
3112 pub unread_marker: ::std::os::raw::c_int,
3113 pub master: *mut jpeg_decomp_master,
3114 pub main: *mut jpeg_d_main_controller,
3115 pub coef: *mut jpeg_d_coef_controller,
3116 pub post: *mut jpeg_d_post_controller,
3117 pub inputctl: *mut jpeg_input_controller,
3118 pub marker: *mut jpeg_marker_reader,
3119 pub entropy: *mut jpeg_entropy_decoder,
3120 pub idct: *mut jpeg_inverse_dct,
3121 pub upsample: *mut jpeg_upsampler,
3122 pub cconvert: *mut jpeg_color_deconverter,
3123 pub cquantize: *mut jpeg_color_quantizer,
3124}
3125#[test]
3126fn bindgen_test_layout_jpeg_decompress_struct() {
3127 assert_eq!(
3128 ::std::mem::size_of::<jpeg_decompress_struct>(),
3129 632usize,
3130 concat!("Size of: ", stringify!(jpeg_decompress_struct))
3131 );
3132 assert_eq!(
3133 ::std::mem::align_of::<jpeg_decompress_struct>(),
3134 8usize,
3135 concat!("Alignment of ", stringify!(jpeg_decompress_struct))
3136 );
3137 assert_eq!(
3138 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).err as *const _ as usize },
3139 0usize,
3140 concat!(
3141 "Offset of field: ",
3142 stringify!(jpeg_decompress_struct),
3143 "::",
3144 stringify!(err)
3145 )
3146 );
3147 assert_eq!(
3148 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).mem as *const _ as usize },
3149 8usize,
3150 concat!(
3151 "Offset of field: ",
3152 stringify!(jpeg_decompress_struct),
3153 "::",
3154 stringify!(mem)
3155 )
3156 );
3157 assert_eq!(
3158 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).progress as *const _ as usize },
3159 16usize,
3160 concat!(
3161 "Offset of field: ",
3162 stringify!(jpeg_decompress_struct),
3163 "::",
3164 stringify!(progress)
3165 )
3166 );
3167 assert_eq!(
3168 unsafe {
3169 &(*(::std::ptr::null::<jpeg_decompress_struct>())).client_data as *const _ as usize
3170 },
3171 24usize,
3172 concat!(
3173 "Offset of field: ",
3174 stringify!(jpeg_decompress_struct),
3175 "::",
3176 stringify!(client_data)
3177 )
3178 );
3179 assert_eq!(
3180 unsafe {
3181 &(*(::std::ptr::null::<jpeg_decompress_struct>())).is_decompressor as *const _ as usize
3182 },
3183 32usize,
3184 concat!(
3185 "Offset of field: ",
3186 stringify!(jpeg_decompress_struct),
3187 "::",
3188 stringify!(is_decompressor)
3189 )
3190 );
3191 assert_eq!(
3192 unsafe {
3193 &(*(::std::ptr::null::<jpeg_decompress_struct>())).global_state as *const _ as usize
3194 },
3195 36usize,
3196 concat!(
3197 "Offset of field: ",
3198 stringify!(jpeg_decompress_struct),
3199 "::",
3200 stringify!(global_state)
3201 )
3202 );
3203 assert_eq!(
3204 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).src as *const _ as usize },
3205 40usize,
3206 concat!(
3207 "Offset of field: ",
3208 stringify!(jpeg_decompress_struct),
3209 "::",
3210 stringify!(src)
3211 )
3212 );
3213 assert_eq!(
3214 unsafe {
3215 &(*(::std::ptr::null::<jpeg_decompress_struct>())).image_width as *const _ as usize
3216 },
3217 48usize,
3218 concat!(
3219 "Offset of field: ",
3220 stringify!(jpeg_decompress_struct),
3221 "::",
3222 stringify!(image_width)
3223 )
3224 );
3225 assert_eq!(
3226 unsafe {
3227 &(*(::std::ptr::null::<jpeg_decompress_struct>())).image_height as *const _ as usize
3228 },
3229 52usize,
3230 concat!(
3231 "Offset of field: ",
3232 stringify!(jpeg_decompress_struct),
3233 "::",
3234 stringify!(image_height)
3235 )
3236 );
3237 assert_eq!(
3238 unsafe {
3239 &(*(::std::ptr::null::<jpeg_decompress_struct>())).num_components as *const _ as usize
3240 },
3241 56usize,
3242 concat!(
3243 "Offset of field: ",
3244 stringify!(jpeg_decompress_struct),
3245 "::",
3246 stringify!(num_components)
3247 )
3248 );
3249 assert_eq!(
3250 unsafe {
3251 &(*(::std::ptr::null::<jpeg_decompress_struct>())).jpeg_color_space as *const _ as usize
3252 },
3253 60usize,
3254 concat!(
3255 "Offset of field: ",
3256 stringify!(jpeg_decompress_struct),
3257 "::",
3258 stringify!(jpeg_color_space)
3259 )
3260 );
3261 assert_eq!(
3262 unsafe {
3263 &(*(::std::ptr::null::<jpeg_decompress_struct>())).out_color_space as *const _ as usize
3264 },
3265 64usize,
3266 concat!(
3267 "Offset of field: ",
3268 stringify!(jpeg_decompress_struct),
3269 "::",
3270 stringify!(out_color_space)
3271 )
3272 );
3273 assert_eq!(
3274 unsafe {
3275 &(*(::std::ptr::null::<jpeg_decompress_struct>())).scale_num as *const _ as usize
3276 },
3277 68usize,
3278 concat!(
3279 "Offset of field: ",
3280 stringify!(jpeg_decompress_struct),
3281 "::",
3282 stringify!(scale_num)
3283 )
3284 );
3285 assert_eq!(
3286 unsafe {
3287 &(*(::std::ptr::null::<jpeg_decompress_struct>())).scale_denom as *const _ as usize
3288 },
3289 72usize,
3290 concat!(
3291 "Offset of field: ",
3292 stringify!(jpeg_decompress_struct),
3293 "::",
3294 stringify!(scale_denom)
3295 )
3296 );
3297 assert_eq!(
3298 unsafe {
3299 &(*(::std::ptr::null::<jpeg_decompress_struct>())).output_gamma as *const _ as usize
3300 },
3301 80usize,
3302 concat!(
3303 "Offset of field: ",
3304 stringify!(jpeg_decompress_struct),
3305 "::",
3306 stringify!(output_gamma)
3307 )
3308 );
3309 assert_eq!(
3310 unsafe {
3311 &(*(::std::ptr::null::<jpeg_decompress_struct>())).buffered_image as *const _ as usize
3312 },
3313 88usize,
3314 concat!(
3315 "Offset of field: ",
3316 stringify!(jpeg_decompress_struct),
3317 "::",
3318 stringify!(buffered_image)
3319 )
3320 );
3321 assert_eq!(
3322 unsafe {
3323 &(*(::std::ptr::null::<jpeg_decompress_struct>())).raw_data_out as *const _ as usize
3324 },
3325 92usize,
3326 concat!(
3327 "Offset of field: ",
3328 stringify!(jpeg_decompress_struct),
3329 "::",
3330 stringify!(raw_data_out)
3331 )
3332 );
3333 assert_eq!(
3334 unsafe {
3335 &(*(::std::ptr::null::<jpeg_decompress_struct>())).dct_method as *const _ as usize
3336 },
3337 96usize,
3338 concat!(
3339 "Offset of field: ",
3340 stringify!(jpeg_decompress_struct),
3341 "::",
3342 stringify!(dct_method)
3343 )
3344 );
3345 assert_eq!(
3346 unsafe {
3347 &(*(::std::ptr::null::<jpeg_decompress_struct>())).do_fancy_upsampling as *const _
3348 as usize
3349 },
3350 100usize,
3351 concat!(
3352 "Offset of field: ",
3353 stringify!(jpeg_decompress_struct),
3354 "::",
3355 stringify!(do_fancy_upsampling)
3356 )
3357 );
3358 assert_eq!(
3359 unsafe {
3360 &(*(::std::ptr::null::<jpeg_decompress_struct>())).do_block_smoothing as *const _
3361 as usize
3362 },
3363 104usize,
3364 concat!(
3365 "Offset of field: ",
3366 stringify!(jpeg_decompress_struct),
3367 "::",
3368 stringify!(do_block_smoothing)
3369 )
3370 );
3371 assert_eq!(
3372 unsafe {
3373 &(*(::std::ptr::null::<jpeg_decompress_struct>())).quantize_colors as *const _ as usize
3374 },
3375 108usize,
3376 concat!(
3377 "Offset of field: ",
3378 stringify!(jpeg_decompress_struct),
3379 "::",
3380 stringify!(quantize_colors)
3381 )
3382 );
3383 assert_eq!(
3384 unsafe {
3385 &(*(::std::ptr::null::<jpeg_decompress_struct>())).dither_mode as *const _ as usize
3386 },
3387 112usize,
3388 concat!(
3389 "Offset of field: ",
3390 stringify!(jpeg_decompress_struct),
3391 "::",
3392 stringify!(dither_mode)
3393 )
3394 );
3395 assert_eq!(
3396 unsafe {
3397 &(*(::std::ptr::null::<jpeg_decompress_struct>())).two_pass_quantize as *const _
3398 as usize
3399 },
3400 116usize,
3401 concat!(
3402 "Offset of field: ",
3403 stringify!(jpeg_decompress_struct),
3404 "::",
3405 stringify!(two_pass_quantize)
3406 )
3407 );
3408 assert_eq!(
3409 unsafe {
3410 &(*(::std::ptr::null::<jpeg_decompress_struct>())).desired_number_of_colors as *const _
3411 as usize
3412 },
3413 120usize,
3414 concat!(
3415 "Offset of field: ",
3416 stringify!(jpeg_decompress_struct),
3417 "::",
3418 stringify!(desired_number_of_colors)
3419 )
3420 );
3421 assert_eq!(
3422 unsafe {
3423 &(*(::std::ptr::null::<jpeg_decompress_struct>())).enable_1pass_quant as *const _
3424 as usize
3425 },
3426 124usize,
3427 concat!(
3428 "Offset of field: ",
3429 stringify!(jpeg_decompress_struct),
3430 "::",
3431 stringify!(enable_1pass_quant)
3432 )
3433 );
3434 assert_eq!(
3435 unsafe {
3436 &(*(::std::ptr::null::<jpeg_decompress_struct>())).enable_external_quant as *const _
3437 as usize
3438 },
3439 128usize,
3440 concat!(
3441 "Offset of field: ",
3442 stringify!(jpeg_decompress_struct),
3443 "::",
3444 stringify!(enable_external_quant)
3445 )
3446 );
3447 assert_eq!(
3448 unsafe {
3449 &(*(::std::ptr::null::<jpeg_decompress_struct>())).enable_2pass_quant as *const _
3450 as usize
3451 },
3452 132usize,
3453 concat!(
3454 "Offset of field: ",
3455 stringify!(jpeg_decompress_struct),
3456 "::",
3457 stringify!(enable_2pass_quant)
3458 )
3459 );
3460 assert_eq!(
3461 unsafe {
3462 &(*(::std::ptr::null::<jpeg_decompress_struct>())).output_width as *const _ as usize
3463 },
3464 136usize,
3465 concat!(
3466 "Offset of field: ",
3467 stringify!(jpeg_decompress_struct),
3468 "::",
3469 stringify!(output_width)
3470 )
3471 );
3472 assert_eq!(
3473 unsafe {
3474 &(*(::std::ptr::null::<jpeg_decompress_struct>())).output_height as *const _ as usize
3475 },
3476 140usize,
3477 concat!(
3478 "Offset of field: ",
3479 stringify!(jpeg_decompress_struct),
3480 "::",
3481 stringify!(output_height)
3482 )
3483 );
3484 assert_eq!(
3485 unsafe {
3486 &(*(::std::ptr::null::<jpeg_decompress_struct>())).out_color_components as *const _
3487 as usize
3488 },
3489 144usize,
3490 concat!(
3491 "Offset of field: ",
3492 stringify!(jpeg_decompress_struct),
3493 "::",
3494 stringify!(out_color_components)
3495 )
3496 );
3497 assert_eq!(
3498 unsafe {
3499 &(*(::std::ptr::null::<jpeg_decompress_struct>())).output_components as *const _
3500 as usize
3501 },
3502 148usize,
3503 concat!(
3504 "Offset of field: ",
3505 stringify!(jpeg_decompress_struct),
3506 "::",
3507 stringify!(output_components)
3508 )
3509 );
3510 assert_eq!(
3511 unsafe {
3512 &(*(::std::ptr::null::<jpeg_decompress_struct>())).rec_outbuf_height as *const _
3513 as usize
3514 },
3515 152usize,
3516 concat!(
3517 "Offset of field: ",
3518 stringify!(jpeg_decompress_struct),
3519 "::",
3520 stringify!(rec_outbuf_height)
3521 )
3522 );
3523 assert_eq!(
3524 unsafe {
3525 &(*(::std::ptr::null::<jpeg_decompress_struct>())).actual_number_of_colors as *const _
3526 as usize
3527 },
3528 156usize,
3529 concat!(
3530 "Offset of field: ",
3531 stringify!(jpeg_decompress_struct),
3532 "::",
3533 stringify!(actual_number_of_colors)
3534 )
3535 );
3536 assert_eq!(
3537 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).colormap as *const _ as usize },
3538 160usize,
3539 concat!(
3540 "Offset of field: ",
3541 stringify!(jpeg_decompress_struct),
3542 "::",
3543 stringify!(colormap)
3544 )
3545 );
3546 assert_eq!(
3547 unsafe {
3548 &(*(::std::ptr::null::<jpeg_decompress_struct>())).output_scanline as *const _ as usize
3549 },
3550 168usize,
3551 concat!(
3552 "Offset of field: ",
3553 stringify!(jpeg_decompress_struct),
3554 "::",
3555 stringify!(output_scanline)
3556 )
3557 );
3558 assert_eq!(
3559 unsafe {
3560 &(*(::std::ptr::null::<jpeg_decompress_struct>())).input_scan_number as *const _
3561 as usize
3562 },
3563 172usize,
3564 concat!(
3565 "Offset of field: ",
3566 stringify!(jpeg_decompress_struct),
3567 "::",
3568 stringify!(input_scan_number)
3569 )
3570 );
3571 assert_eq!(
3572 unsafe {
3573 &(*(::std::ptr::null::<jpeg_decompress_struct>())).input_iMCU_row as *const _ as usize
3574 },
3575 176usize,
3576 concat!(
3577 "Offset of field: ",
3578 stringify!(jpeg_decompress_struct),
3579 "::",
3580 stringify!(input_iMCU_row)
3581 )
3582 );
3583 assert_eq!(
3584 unsafe {
3585 &(*(::std::ptr::null::<jpeg_decompress_struct>())).output_scan_number as *const _
3586 as usize
3587 },
3588 180usize,
3589 concat!(
3590 "Offset of field: ",
3591 stringify!(jpeg_decompress_struct),
3592 "::",
3593 stringify!(output_scan_number)
3594 )
3595 );
3596 assert_eq!(
3597 unsafe {
3598 &(*(::std::ptr::null::<jpeg_decompress_struct>())).output_iMCU_row as *const _ as usize
3599 },
3600 184usize,
3601 concat!(
3602 "Offset of field: ",
3603 stringify!(jpeg_decompress_struct),
3604 "::",
3605 stringify!(output_iMCU_row)
3606 )
3607 );
3608 assert_eq!(
3609 unsafe {
3610 &(*(::std::ptr::null::<jpeg_decompress_struct>())).coef_bits as *const _ as usize
3611 },
3612 192usize,
3613 concat!(
3614 "Offset of field: ",
3615 stringify!(jpeg_decompress_struct),
3616 "::",
3617 stringify!(coef_bits)
3618 )
3619 );
3620 assert_eq!(
3621 unsafe {
3622 &(*(::std::ptr::null::<jpeg_decompress_struct>())).quant_tbl_ptrs as *const _ as usize
3623 },
3624 200usize,
3625 concat!(
3626 "Offset of field: ",
3627 stringify!(jpeg_decompress_struct),
3628 "::",
3629 stringify!(quant_tbl_ptrs)
3630 )
3631 );
3632 assert_eq!(
3633 unsafe {
3634 &(*(::std::ptr::null::<jpeg_decompress_struct>())).dc_huff_tbl_ptrs as *const _ as usize
3635 },
3636 232usize,
3637 concat!(
3638 "Offset of field: ",
3639 stringify!(jpeg_decompress_struct),
3640 "::",
3641 stringify!(dc_huff_tbl_ptrs)
3642 )
3643 );
3644 assert_eq!(
3645 unsafe {
3646 &(*(::std::ptr::null::<jpeg_decompress_struct>())).ac_huff_tbl_ptrs as *const _ as usize
3647 },
3648 264usize,
3649 concat!(
3650 "Offset of field: ",
3651 stringify!(jpeg_decompress_struct),
3652 "::",
3653 stringify!(ac_huff_tbl_ptrs)
3654 )
3655 );
3656 assert_eq!(
3657 unsafe {
3658 &(*(::std::ptr::null::<jpeg_decompress_struct>())).data_precision as *const _ as usize
3659 },
3660 296usize,
3661 concat!(
3662 "Offset of field: ",
3663 stringify!(jpeg_decompress_struct),
3664 "::",
3665 stringify!(data_precision)
3666 )
3667 );
3668 assert_eq!(
3669 unsafe {
3670 &(*(::std::ptr::null::<jpeg_decompress_struct>())).comp_info as *const _ as usize
3671 },
3672 304usize,
3673 concat!(
3674 "Offset of field: ",
3675 stringify!(jpeg_decompress_struct),
3676 "::",
3677 stringify!(comp_info)
3678 )
3679 );
3680 assert_eq!(
3681 unsafe {
3682 &(*(::std::ptr::null::<jpeg_decompress_struct>())).progressive_mode as *const _ as usize
3683 },
3684 312usize,
3685 concat!(
3686 "Offset of field: ",
3687 stringify!(jpeg_decompress_struct),
3688 "::",
3689 stringify!(progressive_mode)
3690 )
3691 );
3692 assert_eq!(
3693 unsafe {
3694 &(*(::std::ptr::null::<jpeg_decompress_struct>())).arith_code as *const _ as usize
3695 },
3696 316usize,
3697 concat!(
3698 "Offset of field: ",
3699 stringify!(jpeg_decompress_struct),
3700 "::",
3701 stringify!(arith_code)
3702 )
3703 );
3704 assert_eq!(
3705 unsafe {
3706 &(*(::std::ptr::null::<jpeg_decompress_struct>())).arith_dc_L as *const _ as usize
3707 },
3708 320usize,
3709 concat!(
3710 "Offset of field: ",
3711 stringify!(jpeg_decompress_struct),
3712 "::",
3713 stringify!(arith_dc_L)
3714 )
3715 );
3716 assert_eq!(
3717 unsafe {
3718 &(*(::std::ptr::null::<jpeg_decompress_struct>())).arith_dc_U as *const _ as usize
3719 },
3720 336usize,
3721 concat!(
3722 "Offset of field: ",
3723 stringify!(jpeg_decompress_struct),
3724 "::",
3725 stringify!(arith_dc_U)
3726 )
3727 );
3728 assert_eq!(
3729 unsafe {
3730 &(*(::std::ptr::null::<jpeg_decompress_struct>())).arith_ac_K as *const _ as usize
3731 },
3732 352usize,
3733 concat!(
3734 "Offset of field: ",
3735 stringify!(jpeg_decompress_struct),
3736 "::",
3737 stringify!(arith_ac_K)
3738 )
3739 );
3740 assert_eq!(
3741 unsafe {
3742 &(*(::std::ptr::null::<jpeg_decompress_struct>())).restart_interval as *const _ as usize
3743 },
3744 368usize,
3745 concat!(
3746 "Offset of field: ",
3747 stringify!(jpeg_decompress_struct),
3748 "::",
3749 stringify!(restart_interval)
3750 )
3751 );
3752 assert_eq!(
3753 unsafe {
3754 &(*(::std::ptr::null::<jpeg_decompress_struct>())).saw_JFIF_marker as *const _ as usize
3755 },
3756 372usize,
3757 concat!(
3758 "Offset of field: ",
3759 stringify!(jpeg_decompress_struct),
3760 "::",
3761 stringify!(saw_JFIF_marker)
3762 )
3763 );
3764 assert_eq!(
3765 unsafe {
3766 &(*(::std::ptr::null::<jpeg_decompress_struct>())).JFIF_major_version as *const _
3767 as usize
3768 },
3769 376usize,
3770 concat!(
3771 "Offset of field: ",
3772 stringify!(jpeg_decompress_struct),
3773 "::",
3774 stringify!(JFIF_major_version)
3775 )
3776 );
3777 assert_eq!(
3778 unsafe {
3779 &(*(::std::ptr::null::<jpeg_decompress_struct>())).JFIF_minor_version as *const _
3780 as usize
3781 },
3782 377usize,
3783 concat!(
3784 "Offset of field: ",
3785 stringify!(jpeg_decompress_struct),
3786 "::",
3787 stringify!(JFIF_minor_version)
3788 )
3789 );
3790 assert_eq!(
3791 unsafe {
3792 &(*(::std::ptr::null::<jpeg_decompress_struct>())).density_unit as *const _ as usize
3793 },
3794 378usize,
3795 concat!(
3796 "Offset of field: ",
3797 stringify!(jpeg_decompress_struct),
3798 "::",
3799 stringify!(density_unit)
3800 )
3801 );
3802 assert_eq!(
3803 unsafe {
3804 &(*(::std::ptr::null::<jpeg_decompress_struct>())).X_density as *const _ as usize
3805 },
3806 380usize,
3807 concat!(
3808 "Offset of field: ",
3809 stringify!(jpeg_decompress_struct),
3810 "::",
3811 stringify!(X_density)
3812 )
3813 );
3814 assert_eq!(
3815 unsafe {
3816 &(*(::std::ptr::null::<jpeg_decompress_struct>())).Y_density as *const _ as usize
3817 },
3818 382usize,
3819 concat!(
3820 "Offset of field: ",
3821 stringify!(jpeg_decompress_struct),
3822 "::",
3823 stringify!(Y_density)
3824 )
3825 );
3826 assert_eq!(
3827 unsafe {
3828 &(*(::std::ptr::null::<jpeg_decompress_struct>())).saw_Adobe_marker as *const _ as usize
3829 },
3830 384usize,
3831 concat!(
3832 "Offset of field: ",
3833 stringify!(jpeg_decompress_struct),
3834 "::",
3835 stringify!(saw_Adobe_marker)
3836 )
3837 );
3838 assert_eq!(
3839 unsafe {
3840 &(*(::std::ptr::null::<jpeg_decompress_struct>())).Adobe_transform as *const _ as usize
3841 },
3842 388usize,
3843 concat!(
3844 "Offset of field: ",
3845 stringify!(jpeg_decompress_struct),
3846 "::",
3847 stringify!(Adobe_transform)
3848 )
3849 );
3850 assert_eq!(
3851 unsafe {
3852 &(*(::std::ptr::null::<jpeg_decompress_struct>())).CCIR601_sampling as *const _ as usize
3853 },
3854 392usize,
3855 concat!(
3856 "Offset of field: ",
3857 stringify!(jpeg_decompress_struct),
3858 "::",
3859 stringify!(CCIR601_sampling)
3860 )
3861 );
3862 assert_eq!(
3863 unsafe {
3864 &(*(::std::ptr::null::<jpeg_decompress_struct>())).marker_list as *const _ as usize
3865 },
3866 400usize,
3867 concat!(
3868 "Offset of field: ",
3869 stringify!(jpeg_decompress_struct),
3870 "::",
3871 stringify!(marker_list)
3872 )
3873 );
3874 assert_eq!(
3875 unsafe {
3876 &(*(::std::ptr::null::<jpeg_decompress_struct>())).max_h_samp_factor as *const _
3877 as usize
3878 },
3879 408usize,
3880 concat!(
3881 "Offset of field: ",
3882 stringify!(jpeg_decompress_struct),
3883 "::",
3884 stringify!(max_h_samp_factor)
3885 )
3886 );
3887 assert_eq!(
3888 unsafe {
3889 &(*(::std::ptr::null::<jpeg_decompress_struct>())).max_v_samp_factor as *const _
3890 as usize
3891 },
3892 412usize,
3893 concat!(
3894 "Offset of field: ",
3895 stringify!(jpeg_decompress_struct),
3896 "::",
3897 stringify!(max_v_samp_factor)
3898 )
3899 );
3900 assert_eq!(
3901 unsafe {
3902 &(*(::std::ptr::null::<jpeg_decompress_struct>())).min_DCT_scaled_size as *const _
3903 as usize
3904 },
3905 416usize,
3906 concat!(
3907 "Offset of field: ",
3908 stringify!(jpeg_decompress_struct),
3909 "::",
3910 stringify!(min_DCT_scaled_size)
3911 )
3912 );
3913 assert_eq!(
3914 unsafe {
3915 &(*(::std::ptr::null::<jpeg_decompress_struct>())).total_iMCU_rows as *const _ as usize
3916 },
3917 420usize,
3918 concat!(
3919 "Offset of field: ",
3920 stringify!(jpeg_decompress_struct),
3921 "::",
3922 stringify!(total_iMCU_rows)
3923 )
3924 );
3925 assert_eq!(
3926 unsafe {
3927 &(*(::std::ptr::null::<jpeg_decompress_struct>())).sample_range_limit as *const _
3928 as usize
3929 },
3930 424usize,
3931 concat!(
3932 "Offset of field: ",
3933 stringify!(jpeg_decompress_struct),
3934 "::",
3935 stringify!(sample_range_limit)
3936 )
3937 );
3938 assert_eq!(
3939 unsafe {
3940 &(*(::std::ptr::null::<jpeg_decompress_struct>())).comps_in_scan as *const _ as usize
3941 },
3942 432usize,
3943 concat!(
3944 "Offset of field: ",
3945 stringify!(jpeg_decompress_struct),
3946 "::",
3947 stringify!(comps_in_scan)
3948 )
3949 );
3950 assert_eq!(
3951 unsafe {
3952 &(*(::std::ptr::null::<jpeg_decompress_struct>())).cur_comp_info as *const _ as usize
3953 },
3954 440usize,
3955 concat!(
3956 "Offset of field: ",
3957 stringify!(jpeg_decompress_struct),
3958 "::",
3959 stringify!(cur_comp_info)
3960 )
3961 );
3962 assert_eq!(
3963 unsafe {
3964 &(*(::std::ptr::null::<jpeg_decompress_struct>())).MCUs_per_row as *const _ as usize
3965 },
3966 472usize,
3967 concat!(
3968 "Offset of field: ",
3969 stringify!(jpeg_decompress_struct),
3970 "::",
3971 stringify!(MCUs_per_row)
3972 )
3973 );
3974 assert_eq!(
3975 unsafe {
3976 &(*(::std::ptr::null::<jpeg_decompress_struct>())).MCU_rows_in_scan as *const _ as usize
3977 },
3978 476usize,
3979 concat!(
3980 "Offset of field: ",
3981 stringify!(jpeg_decompress_struct),
3982 "::",
3983 stringify!(MCU_rows_in_scan)
3984 )
3985 );
3986 assert_eq!(
3987 unsafe {
3988 &(*(::std::ptr::null::<jpeg_decompress_struct>())).blocks_in_MCU as *const _ as usize
3989 },
3990 480usize,
3991 concat!(
3992 "Offset of field: ",
3993 stringify!(jpeg_decompress_struct),
3994 "::",
3995 stringify!(blocks_in_MCU)
3996 )
3997 );
3998 assert_eq!(
3999 unsafe {
4000 &(*(::std::ptr::null::<jpeg_decompress_struct>())).MCU_membership as *const _ as usize
4001 },
4002 484usize,
4003 concat!(
4004 "Offset of field: ",
4005 stringify!(jpeg_decompress_struct),
4006 "::",
4007 stringify!(MCU_membership)
4008 )
4009 );
4010 assert_eq!(
4011 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).Ss as *const _ as usize },
4012 524usize,
4013 concat!(
4014 "Offset of field: ",
4015 stringify!(jpeg_decompress_struct),
4016 "::",
4017 stringify!(Ss)
4018 )
4019 );
4020 assert_eq!(
4021 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).Se as *const _ as usize },
4022 528usize,
4023 concat!(
4024 "Offset of field: ",
4025 stringify!(jpeg_decompress_struct),
4026 "::",
4027 stringify!(Se)
4028 )
4029 );
4030 assert_eq!(
4031 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).Ah as *const _ as usize },
4032 532usize,
4033 concat!(
4034 "Offset of field: ",
4035 stringify!(jpeg_decompress_struct),
4036 "::",
4037 stringify!(Ah)
4038 )
4039 );
4040 assert_eq!(
4041 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).Al as *const _ as usize },
4042 536usize,
4043 concat!(
4044 "Offset of field: ",
4045 stringify!(jpeg_decompress_struct),
4046 "::",
4047 stringify!(Al)
4048 )
4049 );
4050 assert_eq!(
4051 unsafe {
4052 &(*(::std::ptr::null::<jpeg_decompress_struct>())).unread_marker as *const _ as usize
4053 },
4054 540usize,
4055 concat!(
4056 "Offset of field: ",
4057 stringify!(jpeg_decompress_struct),
4058 "::",
4059 stringify!(unread_marker)
4060 )
4061 );
4062 assert_eq!(
4063 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).master as *const _ as usize },
4064 544usize,
4065 concat!(
4066 "Offset of field: ",
4067 stringify!(jpeg_decompress_struct),
4068 "::",
4069 stringify!(master)
4070 )
4071 );
4072 assert_eq!(
4073 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).main as *const _ as usize },
4074 552usize,
4075 concat!(
4076 "Offset of field: ",
4077 stringify!(jpeg_decompress_struct),
4078 "::",
4079 stringify!(main)
4080 )
4081 );
4082 assert_eq!(
4083 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).coef as *const _ as usize },
4084 560usize,
4085 concat!(
4086 "Offset of field: ",
4087 stringify!(jpeg_decompress_struct),
4088 "::",
4089 stringify!(coef)
4090 )
4091 );
4092 assert_eq!(
4093 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).post as *const _ as usize },
4094 568usize,
4095 concat!(
4096 "Offset of field: ",
4097 stringify!(jpeg_decompress_struct),
4098 "::",
4099 stringify!(post)
4100 )
4101 );
4102 assert_eq!(
4103 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).inputctl as *const _ as usize },
4104 576usize,
4105 concat!(
4106 "Offset of field: ",
4107 stringify!(jpeg_decompress_struct),
4108 "::",
4109 stringify!(inputctl)
4110 )
4111 );
4112 assert_eq!(
4113 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).marker as *const _ as usize },
4114 584usize,
4115 concat!(
4116 "Offset of field: ",
4117 stringify!(jpeg_decompress_struct),
4118 "::",
4119 stringify!(marker)
4120 )
4121 );
4122 assert_eq!(
4123 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).entropy as *const _ as usize },
4124 592usize,
4125 concat!(
4126 "Offset of field: ",
4127 stringify!(jpeg_decompress_struct),
4128 "::",
4129 stringify!(entropy)
4130 )
4131 );
4132 assert_eq!(
4133 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).idct as *const _ as usize },
4134 600usize,
4135 concat!(
4136 "Offset of field: ",
4137 stringify!(jpeg_decompress_struct),
4138 "::",
4139 stringify!(idct)
4140 )
4141 );
4142 assert_eq!(
4143 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).upsample as *const _ as usize },
4144 608usize,
4145 concat!(
4146 "Offset of field: ",
4147 stringify!(jpeg_decompress_struct),
4148 "::",
4149 stringify!(upsample)
4150 )
4151 );
4152 assert_eq!(
4153 unsafe { &(*(::std::ptr::null::<jpeg_decompress_struct>())).cconvert as *const _ as usize },
4154 616usize,
4155 concat!(
4156 "Offset of field: ",
4157 stringify!(jpeg_decompress_struct),
4158 "::",
4159 stringify!(cconvert)
4160 )
4161 );
4162 assert_eq!(
4163 unsafe {
4164 &(*(::std::ptr::null::<jpeg_decompress_struct>())).cquantize as *const _ as usize
4165 },
4166 624usize,
4167 concat!(
4168 "Offset of field: ",
4169 stringify!(jpeg_decompress_struct),
4170 "::",
4171 stringify!(cquantize)
4172 )
4173 );
4174}
4175#[repr(C)]
4176#[derive(Copy, Clone)]
4177pub struct jpeg_error_mgr {
4178 pub error_exit: ::std::option::Option<unsafe extern "C" fn(cinfo: j_common_ptr)>,
4179 pub emit_message: ::std::option::Option<
4180 unsafe extern "C" fn(cinfo: j_common_ptr, msg_level: ::std::os::raw::c_int),
4181 >,
4182 pub output_message: ::std::option::Option<unsafe extern "C" fn(cinfo: j_common_ptr)>,
4183 pub format_message: ::std::option::Option<
4184 unsafe extern "C" fn(cinfo: j_common_ptr, buffer: *mut ::std::os::raw::c_char),
4185 >,
4186 pub reset_error_mgr: ::std::option::Option<unsafe extern "C" fn(cinfo: j_common_ptr)>,
4187 pub msg_code: ::std::os::raw::c_int,
4188 pub msg_parm: jpeg_error_mgr__bindgen_ty_1,
4189 pub trace_level: ::std::os::raw::c_int,
4190 pub num_warnings: ::std::os::raw::c_long,
4191 pub jpeg_message_table: *const *const ::std::os::raw::c_char,
4192 pub last_jpeg_message: ::std::os::raw::c_int,
4193 pub addon_message_table: *const *const ::std::os::raw::c_char,
4194 pub first_addon_message: ::std::os::raw::c_int,
4195 pub last_addon_message: ::std::os::raw::c_int,
4196}
4197#[repr(C)]
4198#[derive(Copy, Clone)]
4199pub union jpeg_error_mgr__bindgen_ty_1 {
4200 pub i: [::std::os::raw::c_int; 8usize],
4201 pub s: [::std::os::raw::c_char; 80usize],
4202 _bindgen_union_align: [u32; 20usize],
4203}
4204#[test]
4205fn bindgen_test_layout_jpeg_error_mgr__bindgen_ty_1() {
4206 assert_eq!(
4207 ::std::mem::size_of::<jpeg_error_mgr__bindgen_ty_1>(),
4208 80usize,
4209 concat!("Size of: ", stringify!(jpeg_error_mgr__bindgen_ty_1))
4210 );
4211 assert_eq!(
4212 ::std::mem::align_of::<jpeg_error_mgr__bindgen_ty_1>(),
4213 4usize,
4214 concat!("Alignment of ", stringify!(jpeg_error_mgr__bindgen_ty_1))
4215 );
4216 assert_eq!(
4217 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr__bindgen_ty_1>())).i as *const _ as usize },
4218 0usize,
4219 concat!(
4220 "Offset of field: ",
4221 stringify!(jpeg_error_mgr__bindgen_ty_1),
4222 "::",
4223 stringify!(i)
4224 )
4225 );
4226 assert_eq!(
4227 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr__bindgen_ty_1>())).s as *const _ as usize },
4228 0usize,
4229 concat!(
4230 "Offset of field: ",
4231 stringify!(jpeg_error_mgr__bindgen_ty_1),
4232 "::",
4233 stringify!(s)
4234 )
4235 );
4236}
4237#[test]
4238fn bindgen_test_layout_jpeg_error_mgr() {
4239 assert_eq!(
4240 ::std::mem::size_of::<jpeg_error_mgr>(),
4241 168usize,
4242 concat!("Size of: ", stringify!(jpeg_error_mgr))
4243 );
4244 assert_eq!(
4245 ::std::mem::align_of::<jpeg_error_mgr>(),
4246 8usize,
4247 concat!("Alignment of ", stringify!(jpeg_error_mgr))
4248 );
4249 assert_eq!(
4250 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).error_exit as *const _ as usize },
4251 0usize,
4252 concat!(
4253 "Offset of field: ",
4254 stringify!(jpeg_error_mgr),
4255 "::",
4256 stringify!(error_exit)
4257 )
4258 );
4259 assert_eq!(
4260 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).emit_message as *const _ as usize },
4261 8usize,
4262 concat!(
4263 "Offset of field: ",
4264 stringify!(jpeg_error_mgr),
4265 "::",
4266 stringify!(emit_message)
4267 )
4268 );
4269 assert_eq!(
4270 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).output_message as *const _ as usize },
4271 16usize,
4272 concat!(
4273 "Offset of field: ",
4274 stringify!(jpeg_error_mgr),
4275 "::",
4276 stringify!(output_message)
4277 )
4278 );
4279 assert_eq!(
4280 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).format_message as *const _ as usize },
4281 24usize,
4282 concat!(
4283 "Offset of field: ",
4284 stringify!(jpeg_error_mgr),
4285 "::",
4286 stringify!(format_message)
4287 )
4288 );
4289 assert_eq!(
4290 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).reset_error_mgr as *const _ as usize },
4291 32usize,
4292 concat!(
4293 "Offset of field: ",
4294 stringify!(jpeg_error_mgr),
4295 "::",
4296 stringify!(reset_error_mgr)
4297 )
4298 );
4299 assert_eq!(
4300 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).msg_code as *const _ as usize },
4301 40usize,
4302 concat!(
4303 "Offset of field: ",
4304 stringify!(jpeg_error_mgr),
4305 "::",
4306 stringify!(msg_code)
4307 )
4308 );
4309 assert_eq!(
4310 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).msg_parm as *const _ as usize },
4311 44usize,
4312 concat!(
4313 "Offset of field: ",
4314 stringify!(jpeg_error_mgr),
4315 "::",
4316 stringify!(msg_parm)
4317 )
4318 );
4319 assert_eq!(
4320 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).trace_level as *const _ as usize },
4321 124usize,
4322 concat!(
4323 "Offset of field: ",
4324 stringify!(jpeg_error_mgr),
4325 "::",
4326 stringify!(trace_level)
4327 )
4328 );
4329 assert_eq!(
4330 unsafe { &(*(::std::ptr::null::<jpeg_error_mgr>())).num_warnings as *const _ as usize },
4331 128usize,
4332 concat!(
4333 "Offset of field: ",
4334 stringify!(jpeg_error_mgr),
4335 "::",
4336 stringify!(num_warnings)
4337 )
4338 );
4339 assert_eq!(
4340 unsafe {
4341 &(*(::std::ptr::null::<jpeg_error_mgr>())).jpeg_message_table as *const _ as usize
4342 },
4343 136usize,
4344 concat!(
4345 "Offset of field: ",
4346 stringify!(jpeg_error_mgr),
4347 "::",
4348 stringify!(jpeg_message_table)
4349 )
4350 );
4351 assert_eq!(
4352 unsafe {
4353 &(*(::std::ptr::null::<jpeg_error_mgr>())).last_jpeg_message as *const _ as usize
4354 },
4355 144usize,
4356 concat!(
4357 "Offset of field: ",
4358 stringify!(jpeg_error_mgr),
4359 "::",
4360 stringify!(last_jpeg_message)
4361 )
4362 );
4363 assert_eq!(
4364 unsafe {
4365 &(*(::std::ptr::null::<jpeg_error_mgr>())).addon_message_table as *const _ as usize
4366 },
4367 152usize,
4368 concat!(
4369 "Offset of field: ",
4370 stringify!(jpeg_error_mgr),
4371 "::",
4372 stringify!(addon_message_table)
4373 )
4374 );
4375 assert_eq!(
4376 unsafe {
4377 &(*(::std::ptr::null::<jpeg_error_mgr>())).first_addon_message as *const _ as usize
4378 },
4379 160usize,
4380 concat!(
4381 "Offset of field: ",
4382 stringify!(jpeg_error_mgr),
4383 "::",
4384 stringify!(first_addon_message)
4385 )
4386 );
4387 assert_eq!(
4388 unsafe {
4389 &(*(::std::ptr::null::<jpeg_error_mgr>())).last_addon_message as *const _ as usize
4390 },
4391 164usize,
4392 concat!(
4393 "Offset of field: ",
4394 stringify!(jpeg_error_mgr),
4395 "::",
4396 stringify!(last_addon_message)
4397 )
4398 );
4399}
4400#[repr(C)]
4401#[derive(Debug, Copy, Clone)]
4402pub struct jpeg_progress_mgr {
4403 pub progress_monitor: ::std::option::Option<unsafe extern "C" fn(cinfo: j_common_ptr)>,
4404 pub pass_counter: ::std::os::raw::c_long,
4405 pub pass_limit: ::std::os::raw::c_long,
4406 pub completed_passes: ::std::os::raw::c_int,
4407 pub total_passes: ::std::os::raw::c_int,
4408}
4409#[test]
4410fn bindgen_test_layout_jpeg_progress_mgr() {
4411 assert_eq!(
4412 ::std::mem::size_of::<jpeg_progress_mgr>(),
4413 32usize,
4414 concat!("Size of: ", stringify!(jpeg_progress_mgr))
4415 );
4416 assert_eq!(
4417 ::std::mem::align_of::<jpeg_progress_mgr>(),
4418 8usize,
4419 concat!("Alignment of ", stringify!(jpeg_progress_mgr))
4420 );
4421 assert_eq!(
4422 unsafe {
4423 &(*(::std::ptr::null::<jpeg_progress_mgr>())).progress_monitor as *const _ as usize
4424 },
4425 0usize,
4426 concat!(
4427 "Offset of field: ",
4428 stringify!(jpeg_progress_mgr),
4429 "::",
4430 stringify!(progress_monitor)
4431 )
4432 );
4433 assert_eq!(
4434 unsafe { &(*(::std::ptr::null::<jpeg_progress_mgr>())).pass_counter as *const _ as usize },
4435 8usize,
4436 concat!(
4437 "Offset of field: ",
4438 stringify!(jpeg_progress_mgr),
4439 "::",
4440 stringify!(pass_counter)
4441 )
4442 );
4443 assert_eq!(
4444 unsafe { &(*(::std::ptr::null::<jpeg_progress_mgr>())).pass_limit as *const _ as usize },
4445 16usize,
4446 concat!(
4447 "Offset of field: ",
4448 stringify!(jpeg_progress_mgr),
4449 "::",
4450 stringify!(pass_limit)
4451 )
4452 );
4453 assert_eq!(
4454 unsafe {
4455 &(*(::std::ptr::null::<jpeg_progress_mgr>())).completed_passes as *const _ as usize
4456 },
4457 24usize,
4458 concat!(
4459 "Offset of field: ",
4460 stringify!(jpeg_progress_mgr),
4461 "::",
4462 stringify!(completed_passes)
4463 )
4464 );
4465 assert_eq!(
4466 unsafe { &(*(::std::ptr::null::<jpeg_progress_mgr>())).total_passes as *const _ as usize },
4467 28usize,
4468 concat!(
4469 "Offset of field: ",
4470 stringify!(jpeg_progress_mgr),
4471 "::",
4472 stringify!(total_passes)
4473 )
4474 );
4475}
4476#[repr(C)]
4477#[derive(Debug, Copy, Clone)]
4478pub struct jpeg_destination_mgr {
4479 pub next_output_byte: *mut JOCTET,
4480 pub free_in_buffer: size_t,
4481 pub init_destination: ::std::option::Option<unsafe extern "C" fn(cinfo: j_compress_ptr)>,
4482 pub empty_output_buffer:
4483 ::std::option::Option<unsafe extern "C" fn(cinfo: j_compress_ptr) -> boolean>,
4484 pub term_destination: ::std::option::Option<unsafe extern "C" fn(cinfo: j_compress_ptr)>,
4485}
4486#[test]
4487fn bindgen_test_layout_jpeg_destination_mgr() {
4488 assert_eq!(
4489 ::std::mem::size_of::<jpeg_destination_mgr>(),
4490 40usize,
4491 concat!("Size of: ", stringify!(jpeg_destination_mgr))
4492 );
4493 assert_eq!(
4494 ::std::mem::align_of::<jpeg_destination_mgr>(),
4495 8usize,
4496 concat!("Alignment of ", stringify!(jpeg_destination_mgr))
4497 );
4498 assert_eq!(
4499 unsafe {
4500 &(*(::std::ptr::null::<jpeg_destination_mgr>())).next_output_byte as *const _ as usize
4501 },
4502 0usize,
4503 concat!(
4504 "Offset of field: ",
4505 stringify!(jpeg_destination_mgr),
4506 "::",
4507 stringify!(next_output_byte)
4508 )
4509 );
4510 assert_eq!(
4511 unsafe {
4512 &(*(::std::ptr::null::<jpeg_destination_mgr>())).free_in_buffer as *const _ as usize
4513 },
4514 8usize,
4515 concat!(
4516 "Offset of field: ",
4517 stringify!(jpeg_destination_mgr),
4518 "::",
4519 stringify!(free_in_buffer)
4520 )
4521 );
4522 assert_eq!(
4523 unsafe {
4524 &(*(::std::ptr::null::<jpeg_destination_mgr>())).init_destination as *const _ as usize
4525 },
4526 16usize,
4527 concat!(
4528 "Offset of field: ",
4529 stringify!(jpeg_destination_mgr),
4530 "::",
4531 stringify!(init_destination)
4532 )
4533 );
4534 assert_eq!(
4535 unsafe {
4536 &(*(::std::ptr::null::<jpeg_destination_mgr>())).empty_output_buffer as *const _
4537 as usize
4538 },
4539 24usize,
4540 concat!(
4541 "Offset of field: ",
4542 stringify!(jpeg_destination_mgr),
4543 "::",
4544 stringify!(empty_output_buffer)
4545 )
4546 );
4547 assert_eq!(
4548 unsafe {
4549 &(*(::std::ptr::null::<jpeg_destination_mgr>())).term_destination as *const _ as usize
4550 },
4551 32usize,
4552 concat!(
4553 "Offset of field: ",
4554 stringify!(jpeg_destination_mgr),
4555 "::",
4556 stringify!(term_destination)
4557 )
4558 );
4559}
4560#[repr(C)]
4561#[derive(Debug, Copy, Clone)]
4562pub struct jpeg_source_mgr {
4563 pub next_input_byte: *const JOCTET,
4564 pub bytes_in_buffer: size_t,
4565 pub init_source: ::std::option::Option<unsafe extern "C" fn(cinfo: j_decompress_ptr)>,
4566 pub fill_input_buffer:
4567 ::std::option::Option<unsafe extern "C" fn(cinfo: j_decompress_ptr) -> boolean>,
4568 pub skip_input_data: ::std::option::Option<
4569 unsafe extern "C" fn(cinfo: j_decompress_ptr, num_bytes: ::std::os::raw::c_long),
4570 >,
4571 pub resync_to_restart: ::std::option::Option<
4572 unsafe extern "C" fn(cinfo: j_decompress_ptr, desired: ::std::os::raw::c_int) -> boolean,
4573 >,
4574 pub term_source: ::std::option::Option<unsafe extern "C" fn(cinfo: j_decompress_ptr)>,
4575}
4576#[test]
4577fn bindgen_test_layout_jpeg_source_mgr() {
4578 assert_eq!(
4579 ::std::mem::size_of::<jpeg_source_mgr>(),
4580 56usize,
4581 concat!("Size of: ", stringify!(jpeg_source_mgr))
4582 );
4583 assert_eq!(
4584 ::std::mem::align_of::<jpeg_source_mgr>(),
4585 8usize,
4586 concat!("Alignment of ", stringify!(jpeg_source_mgr))
4587 );
4588 assert_eq!(
4589 unsafe { &(*(::std::ptr::null::<jpeg_source_mgr>())).next_input_byte as *const _ as usize },
4590 0usize,
4591 concat!(
4592 "Offset of field: ",
4593 stringify!(jpeg_source_mgr),
4594 "::",
4595 stringify!(next_input_byte)
4596 )
4597 );
4598 assert_eq!(
4599 unsafe { &(*(::std::ptr::null::<jpeg_source_mgr>())).bytes_in_buffer as *const _ as usize },
4600 8usize,
4601 concat!(
4602 "Offset of field: ",
4603 stringify!(jpeg_source_mgr),
4604 "::",
4605 stringify!(bytes_in_buffer)
4606 )
4607 );
4608 assert_eq!(
4609 unsafe { &(*(::std::ptr::null::<jpeg_source_mgr>())).init_source as *const _ as usize },
4610 16usize,
4611 concat!(
4612 "Offset of field: ",
4613 stringify!(jpeg_source_mgr),
4614 "::",
4615 stringify!(init_source)
4616 )
4617 );
4618 assert_eq!(
4619 unsafe {
4620 &(*(::std::ptr::null::<jpeg_source_mgr>())).fill_input_buffer as *const _ as usize
4621 },
4622 24usize,
4623 concat!(
4624 "Offset of field: ",
4625 stringify!(jpeg_source_mgr),
4626 "::",
4627 stringify!(fill_input_buffer)
4628 )
4629 );
4630 assert_eq!(
4631 unsafe { &(*(::std::ptr::null::<jpeg_source_mgr>())).skip_input_data as *const _ as usize },
4632 32usize,
4633 concat!(
4634 "Offset of field: ",
4635 stringify!(jpeg_source_mgr),
4636 "::",
4637 stringify!(skip_input_data)
4638 )
4639 );
4640 assert_eq!(
4641 unsafe {
4642 &(*(::std::ptr::null::<jpeg_source_mgr>())).resync_to_restart as *const _ as usize
4643 },
4644 40usize,
4645 concat!(
4646 "Offset of field: ",
4647 stringify!(jpeg_source_mgr),
4648 "::",
4649 stringify!(resync_to_restart)
4650 )
4651 );
4652 assert_eq!(
4653 unsafe { &(*(::std::ptr::null::<jpeg_source_mgr>())).term_source as *const _ as usize },
4654 48usize,
4655 concat!(
4656 "Offset of field: ",
4657 stringify!(jpeg_source_mgr),
4658 "::",
4659 stringify!(term_source)
4660 )
4661 );
4662}
4663#[repr(C)]
4664#[derive(Debug, Copy, Clone)]
4665pub struct jvirt_sarray_control {
4666 _unused: [u8; 0],
4667}
4668pub type jvirt_sarray_ptr = *mut jvirt_sarray_control;
4669#[repr(C)]
4670#[derive(Debug, Copy, Clone)]
4671pub struct jvirt_barray_control {
4672 _unused: [u8; 0],
4673}
4674pub type jvirt_barray_ptr = *mut jvirt_barray_control;
4675#[repr(C)]
4676#[derive(Debug, Copy, Clone)]
4677pub struct jpeg_memory_mgr {
4678 pub alloc_small: ::std::option::Option<
4679 unsafe extern "C" fn(
4680 cinfo: j_common_ptr,
4681 pool_id: ::std::os::raw::c_int,
4682 sizeofobject: size_t,
4683 ) -> *mut ::std::os::raw::c_void,
4684 >,
4685 pub alloc_large: ::std::option::Option<
4686 unsafe extern "C" fn(
4687 cinfo: j_common_ptr,
4688 pool_id: ::std::os::raw::c_int,
4689 sizeofobject: size_t,
4690 ) -> *mut ::std::os::raw::c_void,
4691 >,
4692 pub alloc_sarray: ::std::option::Option<
4693 unsafe extern "C" fn(
4694 cinfo: j_common_ptr,
4695 pool_id: ::std::os::raw::c_int,
4696 samplesperrow: JDIMENSION,
4697 numrows: JDIMENSION,
4698 ) -> JSAMPARRAY,
4699 >,
4700 pub alloc_barray: ::std::option::Option<
4701 unsafe extern "C" fn(
4702 cinfo: j_common_ptr,
4703 pool_id: ::std::os::raw::c_int,
4704 blocksperrow: JDIMENSION,
4705 numrows: JDIMENSION,
4706 ) -> JBLOCKARRAY,
4707 >,
4708 pub request_virt_sarray: ::std::option::Option<
4709 unsafe extern "C" fn(
4710 cinfo: j_common_ptr,
4711 pool_id: ::std::os::raw::c_int,
4712 pre_zero: boolean,
4713 samplesperrow: JDIMENSION,
4714 numrows: JDIMENSION,
4715 maxaccess: JDIMENSION,
4716 ) -> jvirt_sarray_ptr,
4717 >,
4718 pub request_virt_barray: ::std::option::Option<
4719 unsafe extern "C" fn(
4720 cinfo: j_common_ptr,
4721 pool_id: ::std::os::raw::c_int,
4722 pre_zero: boolean,
4723 blocksperrow: JDIMENSION,
4724 numrows: JDIMENSION,
4725 maxaccess: JDIMENSION,
4726 ) -> jvirt_barray_ptr,
4727 >,
4728 pub realize_virt_arrays: ::std::option::Option<unsafe extern "C" fn(cinfo: j_common_ptr)>,
4729 pub access_virt_sarray: ::std::option::Option<
4730 unsafe extern "C" fn(
4731 cinfo: j_common_ptr,
4732 ptr: jvirt_sarray_ptr,
4733 start_row: JDIMENSION,
4734 num_rows: JDIMENSION,
4735 writable: boolean,
4736 ) -> JSAMPARRAY,
4737 >,
4738 pub access_virt_barray: ::std::option::Option<
4739 unsafe extern "C" fn(
4740 cinfo: j_common_ptr,
4741 ptr: jvirt_barray_ptr,
4742 start_row: JDIMENSION,
4743 num_rows: JDIMENSION,
4744 writable: boolean,
4745 ) -> JBLOCKARRAY,
4746 >,
4747 pub free_pool: ::std::option::Option<
4748 unsafe extern "C" fn(cinfo: j_common_ptr, pool_id: ::std::os::raw::c_int),
4749 >,
4750 pub self_destruct: ::std::option::Option<unsafe extern "C" fn(cinfo: j_common_ptr)>,
4751 pub max_memory_to_use: ::std::os::raw::c_long,
4752 pub max_alloc_chunk: ::std::os::raw::c_long,
4753}
4754#[test]
4755fn bindgen_test_layout_jpeg_memory_mgr() {
4756 assert_eq!(
4757 ::std::mem::size_of::<jpeg_memory_mgr>(),
4758 104usize,
4759 concat!("Size of: ", stringify!(jpeg_memory_mgr))
4760 );
4761 assert_eq!(
4762 ::std::mem::align_of::<jpeg_memory_mgr>(),
4763 8usize,
4764 concat!("Alignment of ", stringify!(jpeg_memory_mgr))
4765 );
4766 assert_eq!(
4767 unsafe { &(*(::std::ptr::null::<jpeg_memory_mgr>())).alloc_small as *const _ as usize },
4768 0usize,
4769 concat!(
4770 "Offset of field: ",
4771 stringify!(jpeg_memory_mgr),
4772 "::",
4773 stringify!(alloc_small)
4774 )
4775 );
4776 assert_eq!(
4777 unsafe { &(*(::std::ptr::null::<jpeg_memory_mgr>())).alloc_large as *const _ as usize },
4778 8usize,
4779 concat!(
4780 "Offset of field: ",
4781 stringify!(jpeg_memory_mgr),
4782 "::",
4783 stringify!(alloc_large)
4784 )
4785 );
4786 assert_eq!(
4787 unsafe { &(*(::std::ptr::null::<jpeg_memory_mgr>())).alloc_sarray as *const _ as usize },
4788 16usize,
4789 concat!(
4790 "Offset of field: ",
4791 stringify!(jpeg_memory_mgr),
4792 "::",
4793 stringify!(alloc_sarray)
4794 )
4795 );
4796 assert_eq!(
4797 unsafe { &(*(::std::ptr::null::<jpeg_memory_mgr>())).alloc_barray as *const _ as usize },
4798 24usize,
4799 concat!(
4800 "Offset of field: ",
4801 stringify!(jpeg_memory_mgr),
4802 "::",
4803 stringify!(alloc_barray)
4804 )
4805 );
4806 assert_eq!(
4807 unsafe {
4808 &(*(::std::ptr::null::<jpeg_memory_mgr>())).request_virt_sarray as *const _ as usize
4809 },
4810 32usize,
4811 concat!(
4812 "Offset of field: ",
4813 stringify!(jpeg_memory_mgr),
4814 "::",
4815 stringify!(request_virt_sarray)
4816 )
4817 );
4818 assert_eq!(
4819 unsafe {
4820 &(*(::std::ptr::null::<jpeg_memory_mgr>())).request_virt_barray as *const _ as usize
4821 },
4822 40usize,
4823 concat!(
4824 "Offset of field: ",
4825 stringify!(jpeg_memory_mgr),
4826 "::",
4827 stringify!(request_virt_barray)
4828 )
4829 );
4830 assert_eq!(
4831 unsafe {
4832 &(*(::std::ptr::null::<jpeg_memory_mgr>())).realize_virt_arrays as *const _ as usize
4833 },
4834 48usize,
4835 concat!(
4836 "Offset of field: ",
4837 stringify!(jpeg_memory_mgr),
4838 "::",
4839 stringify!(realize_virt_arrays)
4840 )
4841 );
4842 assert_eq!(
4843 unsafe {
4844 &(*(::std::ptr::null::<jpeg_memory_mgr>())).access_virt_sarray as *const _ as usize
4845 },
4846 56usize,
4847 concat!(
4848 "Offset of field: ",
4849 stringify!(jpeg_memory_mgr),
4850 "::",
4851 stringify!(access_virt_sarray)
4852 )
4853 );
4854 assert_eq!(
4855 unsafe {
4856 &(*(::std::ptr::null::<jpeg_memory_mgr>())).access_virt_barray as *const _ as usize
4857 },
4858 64usize,
4859 concat!(
4860 "Offset of field: ",
4861 stringify!(jpeg_memory_mgr),
4862 "::",
4863 stringify!(access_virt_barray)
4864 )
4865 );
4866 assert_eq!(
4867 unsafe { &(*(::std::ptr::null::<jpeg_memory_mgr>())).free_pool as *const _ as usize },
4868 72usize,
4869 concat!(
4870 "Offset of field: ",
4871 stringify!(jpeg_memory_mgr),
4872 "::",
4873 stringify!(free_pool)
4874 )
4875 );
4876 assert_eq!(
4877 unsafe { &(*(::std::ptr::null::<jpeg_memory_mgr>())).self_destruct as *const _ as usize },
4878 80usize,
4879 concat!(
4880 "Offset of field: ",
4881 stringify!(jpeg_memory_mgr),
4882 "::",
4883 stringify!(self_destruct)
4884 )
4885 );
4886 assert_eq!(
4887 unsafe {
4888 &(*(::std::ptr::null::<jpeg_memory_mgr>())).max_memory_to_use as *const _ as usize
4889 },
4890 88usize,
4891 concat!(
4892 "Offset of field: ",
4893 stringify!(jpeg_memory_mgr),
4894 "::",
4895 stringify!(max_memory_to_use)
4896 )
4897 );
4898 assert_eq!(
4899 unsafe { &(*(::std::ptr::null::<jpeg_memory_mgr>())).max_alloc_chunk as *const _ as usize },
4900 96usize,
4901 concat!(
4902 "Offset of field: ",
4903 stringify!(jpeg_memory_mgr),
4904 "::",
4905 stringify!(max_alloc_chunk)
4906 )
4907 );
4908}
4909pub type jpeg_marker_parser_method =
4910 ::std::option::Option<unsafe extern "C" fn(cinfo: j_decompress_ptr) -> boolean>;
4911extern "C" {
4912 pub fn jpeg_std_error(err: *mut jpeg_error_mgr) -> *mut jpeg_error_mgr;
4913}
4914extern "C" {
4915 pub fn jpeg_CreateCompress(
4916 cinfo: j_compress_ptr,
4917 version: ::std::os::raw::c_int,
4918 structsize: size_t,
4919 );
4920}
4921extern "C" {
4922 pub fn jpeg_CreateDecompress(
4923 cinfo: j_decompress_ptr,
4924 version: ::std::os::raw::c_int,
4925 structsize: size_t,
4926 );
4927}
4928extern "C" {
4929 pub fn jpeg_destroy_compress(cinfo: j_compress_ptr);
4930}
4931extern "C" {
4932 pub fn jpeg_destroy_decompress(cinfo: j_decompress_ptr);
4933}
4934extern "C" {
4935 pub fn jpeg_stdio_dest(cinfo: j_compress_ptr, outfile: *mut FILE);
4936}
4937extern "C" {
4938 pub fn jpeg_stdio_src(cinfo: j_decompress_ptr, infile: *mut FILE);
4939}
4940extern "C" {
4941 pub fn jpeg_mem_dest(
4942 cinfo: j_compress_ptr,
4943 outbuffer: *mut *mut ::std::os::raw::c_uchar,
4944 outsize: *mut ::std::os::raw::c_ulong,
4945 );
4946}
4947extern "C" {
4948 pub fn jpeg_mem_src(
4949 cinfo: j_decompress_ptr,
4950 inbuffer: *const ::std::os::raw::c_uchar,
4951 insize: ::std::os::raw::c_ulong,
4952 );
4953}
4954extern "C" {
4955 pub fn jpeg_set_defaults(cinfo: j_compress_ptr);
4956}
4957extern "C" {
4958 pub fn jpeg_set_colorspace(cinfo: j_compress_ptr, colorspace: J_COLOR_SPACE);
4959}
4960extern "C" {
4961 pub fn jpeg_default_colorspace(cinfo: j_compress_ptr);
4962}
4963extern "C" {
4964 pub fn jpeg_set_quality(
4965 cinfo: j_compress_ptr,
4966 quality: ::std::os::raw::c_int,
4967 force_baseline: boolean,
4968 );
4969}
4970extern "C" {
4971 pub fn jpeg_set_linear_quality(
4972 cinfo: j_compress_ptr,
4973 scale_factor: ::std::os::raw::c_int,
4974 force_baseline: boolean,
4975 );
4976}
4977extern "C" {
4978 pub fn jpeg_add_quant_table(
4979 cinfo: j_compress_ptr,
4980 which_tbl: ::std::os::raw::c_int,
4981 basic_table: *const ::std::os::raw::c_uint,
4982 scale_factor: ::std::os::raw::c_int,
4983 force_baseline: boolean,
4984 );
4985}
4986extern "C" {
4987 pub fn jpeg_quality_scaling(quality: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4988}
4989extern "C" {
4990 pub fn jpeg_simple_progression(cinfo: j_compress_ptr);
4991}
4992extern "C" {
4993 pub fn jpeg_suppress_tables(cinfo: j_compress_ptr, suppress: boolean);
4994}
4995extern "C" {
4996 pub fn jpeg_alloc_quant_table(cinfo: j_common_ptr) -> *mut JQUANT_TBL;
4997}
4998extern "C" {
4999 pub fn jpeg_alloc_huff_table(cinfo: j_common_ptr) -> *mut JHUFF_TBL;
5000}
5001extern "C" {
5002 pub fn jpeg_start_compress(cinfo: j_compress_ptr, write_all_tables: boolean);
5003}
5004extern "C" {
5005 pub fn jpeg_write_scanlines(
5006 cinfo: j_compress_ptr,
5007 scanlines: JSAMPARRAY,
5008 num_lines: JDIMENSION,
5009 ) -> JDIMENSION;
5010}
5011extern "C" {
5012 pub fn jpeg_finish_compress(cinfo: j_compress_ptr);
5013}
5014extern "C" {
5015 pub fn jpeg_write_raw_data(
5016 cinfo: j_compress_ptr,
5017 data: JSAMPIMAGE,
5018 num_lines: JDIMENSION,
5019 ) -> JDIMENSION;
5020}
5021extern "C" {
5022 pub fn jpeg_write_marker(
5023 cinfo: j_compress_ptr,
5024 marker: ::std::os::raw::c_int,
5025 dataptr: *const JOCTET,
5026 datalen: ::std::os::raw::c_uint,
5027 );
5028}
5029extern "C" {
5030 pub fn jpeg_write_m_header(
5031 cinfo: j_compress_ptr,
5032 marker: ::std::os::raw::c_int,
5033 datalen: ::std::os::raw::c_uint,
5034 );
5035}
5036extern "C" {
5037 pub fn jpeg_write_m_byte(cinfo: j_compress_ptr, val: ::std::os::raw::c_int);
5038}
5039extern "C" {
5040 pub fn jpeg_write_tables(cinfo: j_compress_ptr);
5041}
5042extern "C" {
5043 pub fn jpeg_write_icc_profile(
5044 cinfo: j_compress_ptr,
5045 icc_data_ptr: *const JOCTET,
5046 icc_data_len: ::std::os::raw::c_uint,
5047 );
5048}
5049extern "C" {
5050 pub fn jpeg_read_header(
5051 cinfo: j_decompress_ptr,
5052 require_image: boolean,
5053 ) -> ::std::os::raw::c_int;
5054}
5055extern "C" {
5056 pub fn jpeg_start_decompress(cinfo: j_decompress_ptr) -> boolean;
5057}
5058extern "C" {
5059 pub fn jpeg_read_scanlines(
5060 cinfo: j_decompress_ptr,
5061 scanlines: JSAMPARRAY,
5062 max_lines: JDIMENSION,
5063 ) -> JDIMENSION;
5064}
5065extern "C" {
5066 pub fn jpeg_skip_scanlines(cinfo: j_decompress_ptr, num_lines: JDIMENSION) -> JDIMENSION;
5067}
5068extern "C" {
5069 pub fn jpeg_crop_scanline(
5070 cinfo: j_decompress_ptr,
5071 xoffset: *mut JDIMENSION,
5072 width: *mut JDIMENSION,
5073 );
5074}
5075extern "C" {
5076 pub fn jpeg_finish_decompress(cinfo: j_decompress_ptr) -> boolean;
5077}
5078extern "C" {
5079 pub fn jpeg_read_raw_data(
5080 cinfo: j_decompress_ptr,
5081 data: JSAMPIMAGE,
5082 max_lines: JDIMENSION,
5083 ) -> JDIMENSION;
5084}
5085extern "C" {
5086 pub fn jpeg_has_multiple_scans(cinfo: j_decompress_ptr) -> boolean;
5087}
5088extern "C" {
5089 pub fn jpeg_start_output(
5090 cinfo: j_decompress_ptr,
5091 scan_number: ::std::os::raw::c_int,
5092 ) -> boolean;
5093}
5094extern "C" {
5095 pub fn jpeg_finish_output(cinfo: j_decompress_ptr) -> boolean;
5096}
5097extern "C" {
5098 pub fn jpeg_input_complete(cinfo: j_decompress_ptr) -> boolean;
5099}
5100extern "C" {
5101 pub fn jpeg_new_colormap(cinfo: j_decompress_ptr);
5102}
5103extern "C" {
5104 pub fn jpeg_consume_input(cinfo: j_decompress_ptr) -> ::std::os::raw::c_int;
5105}
5106extern "C" {
5107 pub fn jpeg_calc_output_dimensions(cinfo: j_decompress_ptr);
5108}
5109extern "C" {
5110 pub fn jpeg_save_markers(
5111 cinfo: j_decompress_ptr,
5112 marker_code: ::std::os::raw::c_int,
5113 length_limit: ::std::os::raw::c_uint,
5114 );
5115}
5116extern "C" {
5117 pub fn jpeg_set_marker_processor(
5118 cinfo: j_decompress_ptr,
5119 marker_code: ::std::os::raw::c_int,
5120 routine: jpeg_marker_parser_method,
5121 );
5122}
5123extern "C" {
5124 pub fn jpeg_read_coefficients(cinfo: j_decompress_ptr) -> *mut jvirt_barray_ptr;
5125}
5126extern "C" {
5127 pub fn jpeg_write_coefficients(cinfo: j_compress_ptr, coef_arrays: *mut jvirt_barray_ptr);
5128}
5129extern "C" {
5130 pub fn jpeg_copy_critical_parameters(srcinfo: j_decompress_ptr, dstinfo: j_compress_ptr);
5131}
5132extern "C" {
5133 pub fn jpeg_abort_compress(cinfo: j_compress_ptr);
5134}
5135extern "C" {
5136 pub fn jpeg_abort_decompress(cinfo: j_decompress_ptr);
5137}
5138extern "C" {
5139 pub fn jpeg_abort(cinfo: j_common_ptr);
5140}
5141extern "C" {
5142 pub fn jpeg_destroy(cinfo: j_common_ptr);
5143}
5144extern "C" {
5145 pub fn jpeg_resync_to_restart(
5146 cinfo: j_decompress_ptr,
5147 desired: ::std::os::raw::c_int,
5148 ) -> boolean;
5149}
5150extern "C" {
5151 pub fn jpeg_read_icc_profile(
5152 cinfo: j_decompress_ptr,
5153 icc_data_ptr: *mut *mut JOCTET,
5154 icc_data_len: *mut ::std::os::raw::c_uint,
5155 ) -> boolean;
5156}
5157pub type __builtin_va_list = [__va_list_tag; 1usize];
5158#[repr(C)]
5159#[derive(Debug, Copy, Clone)]
5160pub struct __va_list_tag {
5161 pub gp_offset: ::std::os::raw::c_uint,
5162 pub fp_offset: ::std::os::raw::c_uint,
5163 pub overflow_arg_area: *mut ::std::os::raw::c_void,
5164 pub reg_save_area: *mut ::std::os::raw::c_void,
5165}
5166#[test]
5167fn bindgen_test_layout___va_list_tag() {
5168 assert_eq!(
5169 ::std::mem::size_of::<__va_list_tag>(),
5170 24usize,
5171 concat!("Size of: ", stringify!(__va_list_tag))
5172 );
5173 assert_eq!(
5174 ::std::mem::align_of::<__va_list_tag>(),
5175 8usize,
5176 concat!("Alignment of ", stringify!(__va_list_tag))
5177 );
5178 assert_eq!(
5179 unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
5180 0usize,
5181 concat!(
5182 "Offset of field: ",
5183 stringify!(__va_list_tag),
5184 "::",
5185 stringify!(gp_offset)
5186 )
5187 );
5188 assert_eq!(
5189 unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
5190 4usize,
5191 concat!(
5192 "Offset of field: ",
5193 stringify!(__va_list_tag),
5194 "::",
5195 stringify!(fp_offset)
5196 )
5197 );
5198 assert_eq!(
5199 unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
5200 8usize,
5201 concat!(
5202 "Offset of field: ",
5203 stringify!(__va_list_tag),
5204 "::",
5205 stringify!(overflow_arg_area)
5206 )
5207 );
5208 assert_eq!(
5209 unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
5210 16usize,
5211 concat!(
5212 "Offset of field: ",
5213 stringify!(__va_list_tag),
5214 "::",
5215 stringify!(reg_save_area)
5216 )
5217 );
5218}
5219#[repr(C)]
5220#[derive(Debug, Copy, Clone)]
5221pub struct jpeg_comp_master {
5222 pub _address: u8,
5223}
5224#[repr(C)]
5225#[derive(Debug, Copy, Clone)]
5226pub struct jpeg_c_main_controller {
5227 pub _address: u8,
5228}
5229#[repr(C)]
5230#[derive(Debug, Copy, Clone)]
5231pub struct jpeg_c_prep_controller {
5232 pub _address: u8,
5233}
5234#[repr(C)]
5235#[derive(Debug, Copy, Clone)]
5236pub struct jpeg_c_coef_controller {
5237 pub _address: u8,
5238}
5239#[repr(C)]
5240#[derive(Debug, Copy, Clone)]
5241pub struct jpeg_marker_writer {
5242 pub _address: u8,
5243}
5244#[repr(C)]
5245#[derive(Debug, Copy, Clone)]
5246pub struct jpeg_color_converter {
5247 pub _address: u8,
5248}
5249#[repr(C)]
5250#[derive(Debug, Copy, Clone)]
5251pub struct jpeg_downsampler {
5252 pub _address: u8,
5253}
5254#[repr(C)]
5255#[derive(Debug, Copy, Clone)]
5256pub struct jpeg_forward_dct {
5257 pub _address: u8,
5258}
5259#[repr(C)]
5260#[derive(Debug, Copy, Clone)]
5261pub struct jpeg_entropy_encoder {
5262 pub _address: u8,
5263}
5264#[repr(C)]
5265#[derive(Debug, Copy, Clone)]
5266pub struct jpeg_decomp_master {
5267 pub _address: u8,
5268}
5269#[repr(C)]
5270#[derive(Debug, Copy, Clone)]
5271pub struct jpeg_d_main_controller {
5272 pub _address: u8,
5273}
5274#[repr(C)]
5275#[derive(Debug, Copy, Clone)]
5276pub struct jpeg_d_coef_controller {
5277 pub _address: u8,
5278}
5279#[repr(C)]
5280#[derive(Debug, Copy, Clone)]
5281pub struct jpeg_d_post_controller {
5282 pub _address: u8,
5283}
5284#[repr(C)]
5285#[derive(Debug, Copy, Clone)]
5286pub struct jpeg_input_controller {
5287 pub _address: u8,
5288}
5289#[repr(C)]
5290#[derive(Debug, Copy, Clone)]
5291pub struct jpeg_marker_reader {
5292 pub _address: u8,
5293}
5294#[repr(C)]
5295#[derive(Debug, Copy, Clone)]
5296pub struct jpeg_entropy_decoder {
5297 pub _address: u8,
5298}
5299#[repr(C)]
5300#[derive(Debug, Copy, Clone)]
5301pub struct jpeg_inverse_dct {
5302 pub _address: u8,
5303}
5304#[repr(C)]
5305#[derive(Debug, Copy, Clone)]
5306pub struct jpeg_upsampler {
5307 pub _address: u8,
5308}
5309#[repr(C)]
5310#[derive(Debug, Copy, Clone)]
5311pub struct jpeg_color_deconverter {
5312 pub _address: u8,
5313}
5314#[repr(C)]
5315#[derive(Debug, Copy, Clone)]
5316pub struct jpeg_color_quantizer {
5317 pub _address: u8,
5318}