1pub const SQUASH_VERSION_MAJOR: u32 = 0;
4pub const SQUASH_VERSION_MINOR: u32 = 8;
5pub const SQUASH_VERSION_REVISION: u32 = 0;
6pub const SQUASH_VERSION_API: &'static [u8; 4usize] = b"0.8\0";
7extern "C" {
8 pub fn squash_version() -> ::std::os::raw::c_uint;
9}
10extern "C" {
11 pub fn squash_version_api() -> *const ::std::os::raw::c_char;
12}
13pub mod SquashStatus {
14 pub type Type = i32;
15 pub const SQUASH_OK: Type = 1;
16 pub const SQUASH_PROCESSING: Type = 2;
17 pub const SQUASH_END_OF_STREAM: Type = 3;
18 pub const SQUASH_FAILED: Type = -1;
19 pub const SQUASH_UNABLE_TO_LOAD: Type = -2;
20 pub const SQUASH_BAD_PARAM: Type = -3;
21 pub const SQUASH_BAD_VALUE: Type = -4;
22 pub const SQUASH_MEMORY: Type = -5;
23 pub const SQUASH_BUFFER_FULL: Type = -6;
24 pub const SQUASH_BUFFER_EMPTY: Type = -7;
25 pub const SQUASH_STATE: Type = -8;
26 pub const SQUASH_INVALID_OPERATION: Type = -9;
27 pub const SQUASH_NOT_FOUND: Type = -10;
28 pub const SQUASH_INVALID_BUFFER: Type = -11;
29 pub const SQUASH_IO: Type = -12;
30 pub const SQUASH_RANGE: Type = -13;
31}
32extern "C" {
33 pub fn squash_status_to_string(status: SquashStatus::Type) -> *const ::std::os::raw::c_char;
34}
35extern "C" {
36 pub fn squash_error(status: SquashStatus::Type) -> SquashStatus::Type;
37}
38#[repr(C)]
39#[derive(Debug, Copy, Clone)]
40pub struct SquashContext {
41 _unused: [u8; 0],
42}
43#[repr(C)]
44#[derive(Debug, Copy, Clone)]
45pub struct SquashCodec {
46 _unused: [u8; 0],
47}
48#[repr(C)]
49#[derive(Debug, Copy, Clone)]
50pub struct SquashPlugin {
51 _unused: [u8; 0],
52}
53#[repr(C)]
54#[derive(Debug, Copy, Clone)]
55pub struct SquashFile {
56 _unused: [u8; 0],
57}
58extern "C" {
59 pub fn squash_object_ref(obj: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void;
60}
61extern "C" {
62 pub fn squash_object_unref(obj: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void;
63}
64extern "C" {
65 pub fn squash_object_get_ref_count(obj: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_uint;
66}
67extern "C" {
68 pub fn squash_object_ref_sink(obj: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void;
69}
70pub type SquashDestroyNotify =
71 ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>;
72#[repr(C)]
73#[derive(Debug, Copy, Clone)]
74pub struct SquashObject {
75 pub ref_count: ::std::os::raw::c_uint,
76 pub is_floating: ::std::os::raw::c_int,
77 pub destroy_notify: SquashDestroyNotify,
78}
79#[test]
80fn bindgen_test_layout_SquashObject() {
81 assert_eq!(
82 ::std::mem::size_of::<SquashObject>(),
83 16usize,
84 concat!("Size of: ", stringify!(SquashObject))
85 );
86 assert_eq!(
87 ::std::mem::align_of::<SquashObject>(),
88 8usize,
89 concat!("Alignment of ", stringify!(SquashObject))
90 );
91 assert_eq!(
92 unsafe { &(*(::std::ptr::null::<SquashObject>())).ref_count as *const _ as usize },
93 0usize,
94 concat!(
95 "Offset of field: ",
96 stringify!(SquashObject),
97 "::",
98 stringify!(ref_count)
99 )
100 );
101 assert_eq!(
102 unsafe { &(*(::std::ptr::null::<SquashObject>())).is_floating as *const _ as usize },
103 4usize,
104 concat!(
105 "Offset of field: ",
106 stringify!(SquashObject),
107 "::",
108 stringify!(is_floating)
109 )
110 );
111 assert_eq!(
112 unsafe { &(*(::std::ptr::null::<SquashObject>())).destroy_notify as *const _ as usize },
113 8usize,
114 concat!(
115 "Offset of field: ",
116 stringify!(SquashObject),
117 "::",
118 stringify!(destroy_notify)
119 )
120 );
121}
122extern "C" {
123 pub fn squash_object_init(
124 obj: *mut ::std::os::raw::c_void,
125 is_floating: bool,
126 destroy_notify: SquashDestroyNotify,
127 );
128}
129extern "C" {
130 pub fn squash_object_destroy(obj: *mut ::std::os::raw::c_void);
131}
132#[repr(C)]
133#[derive(Debug, Copy, Clone)]
134pub struct SquashOptions {
135 pub base_object: SquashObject,
136 pub codec: *mut SquashCodec,
137 pub values: *mut SquashOptionValue,
138}
139#[test]
140fn bindgen_test_layout_SquashOptions() {
141 assert_eq!(
142 ::std::mem::size_of::<SquashOptions>(),
143 32usize,
144 concat!("Size of: ", stringify!(SquashOptions))
145 );
146 assert_eq!(
147 ::std::mem::align_of::<SquashOptions>(),
148 8usize,
149 concat!("Alignment of ", stringify!(SquashOptions))
150 );
151 assert_eq!(
152 unsafe { &(*(::std::ptr::null::<SquashOptions>())).base_object as *const _ as usize },
153 0usize,
154 concat!(
155 "Offset of field: ",
156 stringify!(SquashOptions),
157 "::",
158 stringify!(base_object)
159 )
160 );
161 assert_eq!(
162 unsafe { &(*(::std::ptr::null::<SquashOptions>())).codec as *const _ as usize },
163 16usize,
164 concat!(
165 "Offset of field: ",
166 stringify!(SquashOptions),
167 "::",
168 stringify!(codec)
169 )
170 );
171 assert_eq!(
172 unsafe { &(*(::std::ptr::null::<SquashOptions>())).values as *const _ as usize },
173 24usize,
174 concat!(
175 "Offset of field: ",
176 stringify!(SquashOptions),
177 "::",
178 stringify!(values)
179 )
180 );
181}
182pub mod SquashOptionType {
183 pub type Type = u32;
184 pub const SQUASH_OPTION_TYPE_NONE: Type = 0;
185 pub const SQUASH_OPTION_TYPE_BOOL: Type = 1;
186 pub const SQUASH_OPTION_TYPE_STRING: Type = 2;
187 pub const SQUASH_OPTION_TYPE_INT: Type = 3;
188 pub const SQUASH_OPTION_TYPE_SIZE: Type = 4;
189 pub const SQUASH_OPTION_TYPE_ENUM_STRING: Type = 18;
190 pub const SQUASH_OPTION_TYPE_ENUM_INT: Type = 19;
191 pub const SQUASH_OPTION_TYPE_RANGE_INT: Type = 35;
192 pub const SQUASH_OPTION_TYPE_RANGE_SIZE: Type = 36;
193}
194#[repr(C)]
195#[derive(Debug, Copy, Clone)]
196pub struct SquashOptionInfoEnumStringMap {
197 pub name: *const ::std::os::raw::c_char,
198 pub value: ::std::os::raw::c_int,
199}
200#[test]
201fn bindgen_test_layout_SquashOptionInfoEnumStringMap() {
202 assert_eq!(
203 ::std::mem::size_of::<SquashOptionInfoEnumStringMap>(),
204 16usize,
205 concat!("Size of: ", stringify!(SquashOptionInfoEnumStringMap))
206 );
207 assert_eq!(
208 ::std::mem::align_of::<SquashOptionInfoEnumStringMap>(),
209 8usize,
210 concat!("Alignment of ", stringify!(SquashOptionInfoEnumStringMap))
211 );
212 assert_eq!(
213 unsafe {
214 &(*(::std::ptr::null::<SquashOptionInfoEnumStringMap>())).name as *const _ as usize
215 },
216 0usize,
217 concat!(
218 "Offset of field: ",
219 stringify!(SquashOptionInfoEnumStringMap),
220 "::",
221 stringify!(name)
222 )
223 );
224 assert_eq!(
225 unsafe {
226 &(*(::std::ptr::null::<SquashOptionInfoEnumStringMap>())).value as *const _ as usize
227 },
228 8usize,
229 concat!(
230 "Offset of field: ",
231 stringify!(SquashOptionInfoEnumStringMap),
232 "::",
233 stringify!(value)
234 )
235 );
236}
237#[repr(C)]
238#[derive(Debug, Copy, Clone)]
239pub struct SquashOptionInfoEnumString {
240 pub values: *const SquashOptionInfoEnumStringMap,
241}
242#[test]
243fn bindgen_test_layout_SquashOptionInfoEnumString() {
244 assert_eq!(
245 ::std::mem::size_of::<SquashOptionInfoEnumString>(),
246 8usize,
247 concat!("Size of: ", stringify!(SquashOptionInfoEnumString))
248 );
249 assert_eq!(
250 ::std::mem::align_of::<SquashOptionInfoEnumString>(),
251 8usize,
252 concat!("Alignment of ", stringify!(SquashOptionInfoEnumString))
253 );
254 assert_eq!(
255 unsafe {
256 &(*(::std::ptr::null::<SquashOptionInfoEnumString>())).values as *const _ as usize
257 },
258 0usize,
259 concat!(
260 "Offset of field: ",
261 stringify!(SquashOptionInfoEnumString),
262 "::",
263 stringify!(values)
264 )
265 );
266}
267#[repr(C)]
268#[derive(Debug, Copy, Clone)]
269pub struct SquashOptionInfoEnumInt {
270 pub values_length: usize,
271 pub values: *const ::std::os::raw::c_int,
272}
273#[test]
274fn bindgen_test_layout_SquashOptionInfoEnumInt() {
275 assert_eq!(
276 ::std::mem::size_of::<SquashOptionInfoEnumInt>(),
277 16usize,
278 concat!("Size of: ", stringify!(SquashOptionInfoEnumInt))
279 );
280 assert_eq!(
281 ::std::mem::align_of::<SquashOptionInfoEnumInt>(),
282 8usize,
283 concat!("Alignment of ", stringify!(SquashOptionInfoEnumInt))
284 );
285 assert_eq!(
286 unsafe {
287 &(*(::std::ptr::null::<SquashOptionInfoEnumInt>())).values_length as *const _ as usize
288 },
289 0usize,
290 concat!(
291 "Offset of field: ",
292 stringify!(SquashOptionInfoEnumInt),
293 "::",
294 stringify!(values_length)
295 )
296 );
297 assert_eq!(
298 unsafe { &(*(::std::ptr::null::<SquashOptionInfoEnumInt>())).values as *const _ as usize },
299 8usize,
300 concat!(
301 "Offset of field: ",
302 stringify!(SquashOptionInfoEnumInt),
303 "::",
304 stringify!(values)
305 )
306 );
307}
308#[repr(C)]
309#[derive(Debug, Copy, Clone)]
310pub struct SquashOptionInfoRangeInt {
311 pub min: ::std::os::raw::c_int,
312 pub max: ::std::os::raw::c_int,
313 pub modulus: ::std::os::raw::c_int,
314 pub allow_zero: bool,
315}
316#[test]
317fn bindgen_test_layout_SquashOptionInfoRangeInt() {
318 assert_eq!(
319 ::std::mem::size_of::<SquashOptionInfoRangeInt>(),
320 16usize,
321 concat!("Size of: ", stringify!(SquashOptionInfoRangeInt))
322 );
323 assert_eq!(
324 ::std::mem::align_of::<SquashOptionInfoRangeInt>(),
325 4usize,
326 concat!("Alignment of ", stringify!(SquashOptionInfoRangeInt))
327 );
328 assert_eq!(
329 unsafe { &(*(::std::ptr::null::<SquashOptionInfoRangeInt>())).min as *const _ as usize },
330 0usize,
331 concat!(
332 "Offset of field: ",
333 stringify!(SquashOptionInfoRangeInt),
334 "::",
335 stringify!(min)
336 )
337 );
338 assert_eq!(
339 unsafe { &(*(::std::ptr::null::<SquashOptionInfoRangeInt>())).max as *const _ as usize },
340 4usize,
341 concat!(
342 "Offset of field: ",
343 stringify!(SquashOptionInfoRangeInt),
344 "::",
345 stringify!(max)
346 )
347 );
348 assert_eq!(
349 unsafe {
350 &(*(::std::ptr::null::<SquashOptionInfoRangeInt>())).modulus as *const _ as usize
351 },
352 8usize,
353 concat!(
354 "Offset of field: ",
355 stringify!(SquashOptionInfoRangeInt),
356 "::",
357 stringify!(modulus)
358 )
359 );
360 assert_eq!(
361 unsafe {
362 &(*(::std::ptr::null::<SquashOptionInfoRangeInt>())).allow_zero as *const _ as usize
363 },
364 12usize,
365 concat!(
366 "Offset of field: ",
367 stringify!(SquashOptionInfoRangeInt),
368 "::",
369 stringify!(allow_zero)
370 )
371 );
372}
373#[repr(C)]
374#[derive(Debug, Copy, Clone)]
375pub struct SquashOptionInfoRangeSize {
376 pub min: usize,
377 pub max: usize,
378 pub modulus: usize,
379 pub allow_zero: bool,
380}
381#[test]
382fn bindgen_test_layout_SquashOptionInfoRangeSize() {
383 assert_eq!(
384 ::std::mem::size_of::<SquashOptionInfoRangeSize>(),
385 32usize,
386 concat!("Size of: ", stringify!(SquashOptionInfoRangeSize))
387 );
388 assert_eq!(
389 ::std::mem::align_of::<SquashOptionInfoRangeSize>(),
390 8usize,
391 concat!("Alignment of ", stringify!(SquashOptionInfoRangeSize))
392 );
393 assert_eq!(
394 unsafe { &(*(::std::ptr::null::<SquashOptionInfoRangeSize>())).min as *const _ as usize },
395 0usize,
396 concat!(
397 "Offset of field: ",
398 stringify!(SquashOptionInfoRangeSize),
399 "::",
400 stringify!(min)
401 )
402 );
403 assert_eq!(
404 unsafe { &(*(::std::ptr::null::<SquashOptionInfoRangeSize>())).max as *const _ as usize },
405 8usize,
406 concat!(
407 "Offset of field: ",
408 stringify!(SquashOptionInfoRangeSize),
409 "::",
410 stringify!(max)
411 )
412 );
413 assert_eq!(
414 unsafe {
415 &(*(::std::ptr::null::<SquashOptionInfoRangeSize>())).modulus as *const _ as usize
416 },
417 16usize,
418 concat!(
419 "Offset of field: ",
420 stringify!(SquashOptionInfoRangeSize),
421 "::",
422 stringify!(modulus)
423 )
424 );
425 assert_eq!(
426 unsafe {
427 &(*(::std::ptr::null::<SquashOptionInfoRangeSize>())).allow_zero as *const _ as usize
428 },
429 24usize,
430 concat!(
431 "Offset of field: ",
432 stringify!(SquashOptionInfoRangeSize),
433 "::",
434 stringify!(allow_zero)
435 )
436 );
437}
438#[repr(C)]
439#[derive(Copy, Clone)]
440pub union SquashOptionValue {
441 pub string_value: *mut ::std::os::raw::c_char,
442 pub int_value: ::std::os::raw::c_int,
443 pub bool_value: bool,
444 pub size_value: usize,
445 _bindgen_union_align: u64,
446}
447#[test]
448fn bindgen_test_layout_SquashOptionValue() {
449 assert_eq!(
450 ::std::mem::size_of::<SquashOptionValue>(),
451 8usize,
452 concat!("Size of: ", stringify!(SquashOptionValue))
453 );
454 assert_eq!(
455 ::std::mem::align_of::<SquashOptionValue>(),
456 8usize,
457 concat!("Alignment of ", stringify!(SquashOptionValue))
458 );
459 assert_eq!(
460 unsafe { &(*(::std::ptr::null::<SquashOptionValue>())).string_value as *const _ as usize },
461 0usize,
462 concat!(
463 "Offset of field: ",
464 stringify!(SquashOptionValue),
465 "::",
466 stringify!(string_value)
467 )
468 );
469 assert_eq!(
470 unsafe { &(*(::std::ptr::null::<SquashOptionValue>())).int_value as *const _ as usize },
471 0usize,
472 concat!(
473 "Offset of field: ",
474 stringify!(SquashOptionValue),
475 "::",
476 stringify!(int_value)
477 )
478 );
479 assert_eq!(
480 unsafe { &(*(::std::ptr::null::<SquashOptionValue>())).bool_value as *const _ as usize },
481 0usize,
482 concat!(
483 "Offset of field: ",
484 stringify!(SquashOptionValue),
485 "::",
486 stringify!(bool_value)
487 )
488 );
489 assert_eq!(
490 unsafe { &(*(::std::ptr::null::<SquashOptionValue>())).size_value as *const _ as usize },
491 0usize,
492 concat!(
493 "Offset of field: ",
494 stringify!(SquashOptionValue),
495 "::",
496 stringify!(size_value)
497 )
498 );
499}
500impl ::std::fmt::Debug for SquashOptionValue {
501 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
502 write!(f, "SquashOptionValue {{ union }}")
503 }
504}
505#[repr(C)]
506#[derive(Copy, Clone)]
507pub struct SquashOptionInfo {
508 pub name: *const ::std::os::raw::c_char,
509 pub type_: SquashOptionType::Type,
510 pub info: SquashOptionInfo__bindgen_ty_1,
511 pub default_value: SquashOptionValue,
512}
513#[repr(C)]
514#[derive(Copy, Clone)]
515pub union SquashOptionInfo__bindgen_ty_1 {
516 pub enum_string: SquashOptionInfoEnumString,
517 pub enum_int: SquashOptionInfoEnumInt,
518 pub range_int: SquashOptionInfoRangeInt,
519 pub range_size: SquashOptionInfoRangeSize,
520 _bindgen_union_align: [u64; 4usize],
521}
522#[test]
523fn bindgen_test_layout_SquashOptionInfo__bindgen_ty_1() {
524 assert_eq!(
525 ::std::mem::size_of::<SquashOptionInfo__bindgen_ty_1>(),
526 32usize,
527 concat!("Size of: ", stringify!(SquashOptionInfo__bindgen_ty_1))
528 );
529 assert_eq!(
530 ::std::mem::align_of::<SquashOptionInfo__bindgen_ty_1>(),
531 8usize,
532 concat!("Alignment of ", stringify!(SquashOptionInfo__bindgen_ty_1))
533 );
534 assert_eq!(
535 unsafe {
536 &(*(::std::ptr::null::<SquashOptionInfo__bindgen_ty_1>())).enum_string as *const _
537 as usize
538 },
539 0usize,
540 concat!(
541 "Offset of field: ",
542 stringify!(SquashOptionInfo__bindgen_ty_1),
543 "::",
544 stringify!(enum_string)
545 )
546 );
547 assert_eq!(
548 unsafe {
549 &(*(::std::ptr::null::<SquashOptionInfo__bindgen_ty_1>())).enum_int as *const _ as usize
550 },
551 0usize,
552 concat!(
553 "Offset of field: ",
554 stringify!(SquashOptionInfo__bindgen_ty_1),
555 "::",
556 stringify!(enum_int)
557 )
558 );
559 assert_eq!(
560 unsafe {
561 &(*(::std::ptr::null::<SquashOptionInfo__bindgen_ty_1>())).range_int as *const _
562 as usize
563 },
564 0usize,
565 concat!(
566 "Offset of field: ",
567 stringify!(SquashOptionInfo__bindgen_ty_1),
568 "::",
569 stringify!(range_int)
570 )
571 );
572 assert_eq!(
573 unsafe {
574 &(*(::std::ptr::null::<SquashOptionInfo__bindgen_ty_1>())).range_size as *const _
575 as usize
576 },
577 0usize,
578 concat!(
579 "Offset of field: ",
580 stringify!(SquashOptionInfo__bindgen_ty_1),
581 "::",
582 stringify!(range_size)
583 )
584 );
585}
586impl ::std::fmt::Debug for SquashOptionInfo__bindgen_ty_1 {
587 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
588 write!(f, "SquashOptionInfo__bindgen_ty_1 {{ union }}")
589 }
590}
591#[test]
592fn bindgen_test_layout_SquashOptionInfo() {
593 assert_eq!(
594 ::std::mem::size_of::<SquashOptionInfo>(),
595 56usize,
596 concat!("Size of: ", stringify!(SquashOptionInfo))
597 );
598 assert_eq!(
599 ::std::mem::align_of::<SquashOptionInfo>(),
600 8usize,
601 concat!("Alignment of ", stringify!(SquashOptionInfo))
602 );
603 assert_eq!(
604 unsafe { &(*(::std::ptr::null::<SquashOptionInfo>())).name as *const _ as usize },
605 0usize,
606 concat!(
607 "Offset of field: ",
608 stringify!(SquashOptionInfo),
609 "::",
610 stringify!(name)
611 )
612 );
613 assert_eq!(
614 unsafe { &(*(::std::ptr::null::<SquashOptionInfo>())).type_ as *const _ as usize },
615 8usize,
616 concat!(
617 "Offset of field: ",
618 stringify!(SquashOptionInfo),
619 "::",
620 stringify!(type_)
621 )
622 );
623 assert_eq!(
624 unsafe { &(*(::std::ptr::null::<SquashOptionInfo>())).info as *const _ as usize },
625 16usize,
626 concat!(
627 "Offset of field: ",
628 stringify!(SquashOptionInfo),
629 "::",
630 stringify!(info)
631 )
632 );
633 assert_eq!(
634 unsafe { &(*(::std::ptr::null::<SquashOptionInfo>())).default_value as *const _ as usize },
635 48usize,
636 concat!(
637 "Offset of field: ",
638 stringify!(SquashOptionInfo),
639 "::",
640 stringify!(default_value)
641 )
642 );
643}
644impl ::std::fmt::Debug for SquashOptionInfo {
645 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
646 write!(
647 f,
648 "SquashOptionInfo {{ name: {:?}, type: {:?}, info: {:?}, default_value: {:?} }}",
649 self.name, self.type_, self.info, self.default_value
650 )
651 }
652}
653extern "C" {
654 pub fn squash_options_new(codec: *mut SquashCodec, ...) -> *mut SquashOptions;
655}
656extern "C" {
657 pub fn squash_options_newv(codec: *mut SquashCodec, options: va_list) -> *mut SquashOptions;
658}
659extern "C" {
660 pub fn squash_options_newa(
661 codec: *mut SquashCodec,
662 keys: *const *const ::std::os::raw::c_char,
663 values: *const *const ::std::os::raw::c_char,
664 ) -> *mut SquashOptions;
665}
666extern "C" {
667 pub fn squash_options_get_string(
668 options: *mut SquashOptions,
669 codec: *mut SquashCodec,
670 key: *const ::std::os::raw::c_char,
671 ) -> *const ::std::os::raw::c_char;
672}
673extern "C" {
674 pub fn squash_options_get_bool(
675 options: *mut SquashOptions,
676 codec: *mut SquashCodec,
677 key: *const ::std::os::raw::c_char,
678 ) -> bool;
679}
680extern "C" {
681 pub fn squash_options_get_int(
682 options: *mut SquashOptions,
683 codec: *mut SquashCodec,
684 key: *const ::std::os::raw::c_char,
685 ) -> ::std::os::raw::c_int;
686}
687extern "C" {
688 pub fn squash_options_get_size(
689 options: *mut SquashOptions,
690 codec: *mut SquashCodec,
691 key: *const ::std::os::raw::c_char,
692 ) -> usize;
693}
694extern "C" {
695 pub fn squash_options_get_string_at(
696 options: *mut SquashOptions,
697 codec: *mut SquashCodec,
698 index: usize,
699 ) -> *const ::std::os::raw::c_char;
700}
701extern "C" {
702 pub fn squash_options_get_bool_at(
703 options: *mut SquashOptions,
704 codec: *mut SquashCodec,
705 index: usize,
706 ) -> bool;
707}
708extern "C" {
709 pub fn squash_options_get_int_at(
710 options: *mut SquashOptions,
711 codec: *mut SquashCodec,
712 index: usize,
713 ) -> ::std::os::raw::c_int;
714}
715extern "C" {
716 pub fn squash_options_get_size_at(
717 options: *mut SquashOptions,
718 codec: *mut SquashCodec,
719 index: usize,
720 ) -> usize;
721}
722extern "C" {
723 pub fn squash_options_set_string(
724 options: *mut SquashOptions,
725 key: *const ::std::os::raw::c_char,
726 value: *const ::std::os::raw::c_char,
727 ) -> SquashStatus::Type;
728}
729extern "C" {
730 pub fn squash_options_set_bool(
731 options: *mut SquashOptions,
732 key: *const ::std::os::raw::c_char,
733 value: bool,
734 ) -> SquashStatus::Type;
735}
736extern "C" {
737 pub fn squash_options_set_int(
738 options: *mut SquashOptions,
739 key: *const ::std::os::raw::c_char,
740 value: ::std::os::raw::c_int,
741 ) -> SquashStatus::Type;
742}
743extern "C" {
744 pub fn squash_options_set_size(
745 options: *mut SquashOptions,
746 key: *const ::std::os::raw::c_char,
747 value: usize,
748 ) -> SquashStatus::Type;
749}
750extern "C" {
751 pub fn squash_options_set_string_at(
752 options: *mut SquashOptions,
753 index: usize,
754 value: *const ::std::os::raw::c_char,
755 ) -> SquashStatus::Type;
756}
757extern "C" {
758 pub fn squash_options_set_bool_at(
759 options: *mut SquashOptions,
760 index: usize,
761 value: bool,
762 ) -> SquashStatus::Type;
763}
764extern "C" {
765 pub fn squash_options_set_int_at(
766 options: *mut SquashOptions,
767 index: usize,
768 value: ::std::os::raw::c_int,
769 ) -> SquashStatus::Type;
770}
771extern "C" {
772 pub fn squash_options_set_size_at(
773 options: *mut SquashOptions,
774 index: usize,
775 value: usize,
776 ) -> SquashStatus::Type;
777}
778extern "C" {
779 pub fn squash_options_parse(options: *mut SquashOptions, ...) -> SquashStatus::Type;
780}
781extern "C" {
782 pub fn squash_options_parsev(
783 options: *mut SquashOptions,
784 options_list: va_list,
785 ) -> SquashStatus::Type;
786}
787extern "C" {
788 pub fn squash_options_parsea(
789 options: *mut SquashOptions,
790 keys: *const *const ::std::os::raw::c_char,
791 values: *const *const ::std::os::raw::c_char,
792 ) -> SquashStatus::Type;
793}
794extern "C" {
795 pub fn squash_options_parse_option(
796 options: *mut SquashOptions,
797 key: *const ::std::os::raw::c_char,
798 value: *const ::std::os::raw::c_char,
799 ) -> SquashStatus::Type;
800}
801extern "C" {
802 pub fn squash_options_init(
803 options: *mut ::std::os::raw::c_void,
804 codec: *mut SquashCodec,
805 destroy_notify: SquashDestroyNotify,
806 );
807}
808extern "C" {
809 pub fn squash_options_destroy(options: *mut ::std::os::raw::c_void);
810}
811extern "C" {
812 pub fn squash_options_neww(codec: *mut SquashCodec, ...) -> *mut SquashOptions;
813}
814extern "C" {
815 pub fn squash_options_newvw(codec: *mut SquashCodec, options: va_list) -> *mut SquashOptions;
816}
817extern "C" {
818 pub fn squash_options_newaw(
819 codec: *mut SquashCodec,
820 keys: *const *const wchar_t,
821 values: *const *const wchar_t,
822 ) -> *mut SquashOptions;
823}
824extern "C" {
825 pub fn squash_options_get_stringw(
826 options: *mut SquashOptions,
827 codec: *mut SquashCodec,
828 key: *const wchar_t,
829 ) -> *mut wchar_t;
830}
831extern "C" {
832 pub fn squash_options_get_boolw(
833 options: *mut SquashOptions,
834 codec: *mut SquashCodec,
835 key: *const wchar_t,
836 ) -> bool;
837}
838extern "C" {
839 pub fn squash_options_get_intw(
840 options: *mut SquashOptions,
841 codec: *mut SquashCodec,
842 key: *const wchar_t,
843 ) -> ::std::os::raw::c_int;
844}
845extern "C" {
846 pub fn squash_options_get_sizew(
847 options: *mut SquashOptions,
848 codec: *mut SquashCodec,
849 key: *const wchar_t,
850 ) -> usize;
851}
852extern "C" {
853 pub fn squash_options_parsew(options: *mut SquashOptions, ...) -> SquashStatus::Type;
854}
855extern "C" {
856 pub fn squash_options_parsevw(
857 options: *mut SquashOptions,
858 options_list: va_list,
859 ) -> SquashStatus::Type;
860}
861extern "C" {
862 pub fn squash_options_parseaw(
863 options: *mut SquashOptions,
864 keys: *const *const wchar_t,
865 values: *const *const wchar_t,
866 ) -> SquashStatus::Type;
867}
868extern "C" {
869 pub fn squash_options_parse_optionw(
870 options: *mut SquashOptions,
871 key: *const wchar_t,
872 value: *const wchar_t,
873 ) -> SquashStatus::Type;
874}
875#[repr(C)]
876#[derive(Debug, Copy, Clone)]
877pub struct SquashStreamPrivate {
878 _unused: [u8; 0],
879}
880pub mod SquashStreamType {
881 pub type Type = u32;
882 pub const SQUASH_STREAM_COMPRESS: Type = 1;
883 pub const SQUASH_STREAM_DECOMPRESS: Type = 2;
884}
885pub mod SquashStreamState {
886 pub type Type = u32;
887 pub const SQUASH_STREAM_STATE_IDLE: Type = 0;
888 pub const SQUASH_STREAM_STATE_RUNNING: Type = 1;
889 pub const SQUASH_STREAM_STATE_FLUSHING: Type = 2;
890 pub const SQUASH_STREAM_STATE_FINISHING: Type = 3;
891 pub const SQUASH_STREAM_STATE_FINISHED: Type = 4;
892}
893pub mod SquashOperation {
894 pub type Type = u32;
895 pub const SQUASH_OPERATION_PROCESS: Type = 1;
896 pub const SQUASH_OPERATION_FLUSH: Type = 2;
897 pub const SQUASH_OPERATION_FINISH: Type = 3;
898 pub const SQUASH_OPERATION_TERMINATE: Type = 4;
899}
900#[repr(C)]
901#[derive(Debug, Copy, Clone)]
902pub struct SquashStream {
903 pub base_object: SquashObject,
904 pub priv_: *mut SquashStreamPrivate,
905 pub next_in: *const u8,
906 pub avail_in: usize,
907 pub total_in: usize,
908 pub next_out: *mut u8,
909 pub avail_out: usize,
910 pub total_out: usize,
911 pub codec: *mut SquashCodec,
912 pub options: *mut SquashOptions,
913 pub stream_type: SquashStreamType::Type,
914 pub state: SquashStreamState::Type,
915 pub user_data: *mut ::std::os::raw::c_void,
916 pub destroy_user_data: SquashDestroyNotify,
917}
918#[test]
919fn bindgen_test_layout_SquashStream() {
920 assert_eq!(
921 ::std::mem::size_of::<SquashStream>(),
922 112usize,
923 concat!("Size of: ", stringify!(SquashStream))
924 );
925 assert_eq!(
926 ::std::mem::align_of::<SquashStream>(),
927 8usize,
928 concat!("Alignment of ", stringify!(SquashStream))
929 );
930 assert_eq!(
931 unsafe { &(*(::std::ptr::null::<SquashStream>())).base_object as *const _ as usize },
932 0usize,
933 concat!(
934 "Offset of field: ",
935 stringify!(SquashStream),
936 "::",
937 stringify!(base_object)
938 )
939 );
940 assert_eq!(
941 unsafe { &(*(::std::ptr::null::<SquashStream>())).priv_ as *const _ as usize },
942 16usize,
943 concat!(
944 "Offset of field: ",
945 stringify!(SquashStream),
946 "::",
947 stringify!(priv_)
948 )
949 );
950 assert_eq!(
951 unsafe { &(*(::std::ptr::null::<SquashStream>())).next_in as *const _ as usize },
952 24usize,
953 concat!(
954 "Offset of field: ",
955 stringify!(SquashStream),
956 "::",
957 stringify!(next_in)
958 )
959 );
960 assert_eq!(
961 unsafe { &(*(::std::ptr::null::<SquashStream>())).avail_in as *const _ as usize },
962 32usize,
963 concat!(
964 "Offset of field: ",
965 stringify!(SquashStream),
966 "::",
967 stringify!(avail_in)
968 )
969 );
970 assert_eq!(
971 unsafe { &(*(::std::ptr::null::<SquashStream>())).total_in as *const _ as usize },
972 40usize,
973 concat!(
974 "Offset of field: ",
975 stringify!(SquashStream),
976 "::",
977 stringify!(total_in)
978 )
979 );
980 assert_eq!(
981 unsafe { &(*(::std::ptr::null::<SquashStream>())).next_out as *const _ as usize },
982 48usize,
983 concat!(
984 "Offset of field: ",
985 stringify!(SquashStream),
986 "::",
987 stringify!(next_out)
988 )
989 );
990 assert_eq!(
991 unsafe { &(*(::std::ptr::null::<SquashStream>())).avail_out as *const _ as usize },
992 56usize,
993 concat!(
994 "Offset of field: ",
995 stringify!(SquashStream),
996 "::",
997 stringify!(avail_out)
998 )
999 );
1000 assert_eq!(
1001 unsafe { &(*(::std::ptr::null::<SquashStream>())).total_out as *const _ as usize },
1002 64usize,
1003 concat!(
1004 "Offset of field: ",
1005 stringify!(SquashStream),
1006 "::",
1007 stringify!(total_out)
1008 )
1009 );
1010 assert_eq!(
1011 unsafe { &(*(::std::ptr::null::<SquashStream>())).codec as *const _ as usize },
1012 72usize,
1013 concat!(
1014 "Offset of field: ",
1015 stringify!(SquashStream),
1016 "::",
1017 stringify!(codec)
1018 )
1019 );
1020 assert_eq!(
1021 unsafe { &(*(::std::ptr::null::<SquashStream>())).options as *const _ as usize },
1022 80usize,
1023 concat!(
1024 "Offset of field: ",
1025 stringify!(SquashStream),
1026 "::",
1027 stringify!(options)
1028 )
1029 );
1030 assert_eq!(
1031 unsafe { &(*(::std::ptr::null::<SquashStream>())).stream_type as *const _ as usize },
1032 88usize,
1033 concat!(
1034 "Offset of field: ",
1035 stringify!(SquashStream),
1036 "::",
1037 stringify!(stream_type)
1038 )
1039 );
1040 assert_eq!(
1041 unsafe { &(*(::std::ptr::null::<SquashStream>())).state as *const _ as usize },
1042 92usize,
1043 concat!(
1044 "Offset of field: ",
1045 stringify!(SquashStream),
1046 "::",
1047 stringify!(state)
1048 )
1049 );
1050 assert_eq!(
1051 unsafe { &(*(::std::ptr::null::<SquashStream>())).user_data as *const _ as usize },
1052 96usize,
1053 concat!(
1054 "Offset of field: ",
1055 stringify!(SquashStream),
1056 "::",
1057 stringify!(user_data)
1058 )
1059 );
1060 assert_eq!(
1061 unsafe { &(*(::std::ptr::null::<SquashStream>())).destroy_user_data as *const _ as usize },
1062 104usize,
1063 concat!(
1064 "Offset of field: ",
1065 stringify!(SquashStream),
1066 "::",
1067 stringify!(destroy_user_data)
1068 )
1069 );
1070}
1071extern "C" {
1072 pub fn squash_stream_new(
1073 codec: *mut SquashCodec,
1074 stream_type: SquashStreamType::Type,
1075 ...
1076 ) -> *mut SquashStream;
1077}
1078extern "C" {
1079 pub fn squash_stream_newv(
1080 codec: *mut SquashCodec,
1081 stream_type: SquashStreamType::Type,
1082 options: va_list,
1083 ) -> *mut SquashStream;
1084}
1085extern "C" {
1086 pub fn squash_stream_newa(
1087 codec: *mut SquashCodec,
1088 stream_type: SquashStreamType::Type,
1089 keys: *const *const ::std::os::raw::c_char,
1090 values: *const *const ::std::os::raw::c_char,
1091 ) -> *mut SquashStream;
1092}
1093extern "C" {
1094 pub fn squash_stream_new_with_options(
1095 codec: *mut SquashCodec,
1096 stream_type: SquashStreamType::Type,
1097 options: *mut SquashOptions,
1098 ) -> *mut SquashStream;
1099}
1100extern "C" {
1101 pub fn squash_stream_process(stream: *mut SquashStream) -> SquashStatus::Type;
1102}
1103extern "C" {
1104 pub fn squash_stream_flush(stream: *mut SquashStream) -> SquashStatus::Type;
1105}
1106extern "C" {
1107 pub fn squash_stream_finish(stream: *mut SquashStream) -> SquashStatus::Type;
1108}
1109extern "C" {
1110 pub fn squash_stream_init(
1111 stream: *mut ::std::os::raw::c_void,
1112 codec: *mut SquashCodec,
1113 stream_type: SquashStreamType::Type,
1114 options: *mut SquashOptions,
1115 destroy_notify: SquashDestroyNotify,
1116 );
1117}
1118extern "C" {
1119 pub fn squash_stream_destroy(stream: *mut ::std::os::raw::c_void);
1120}
1121extern "C" {
1122 pub fn squash_file_open(
1123 codec: *mut SquashCodec,
1124 filename: *const ::std::os::raw::c_char,
1125 mode: *const ::std::os::raw::c_char,
1126 ...
1127 ) -> *mut SquashFile;
1128}
1129extern "C" {
1130 pub fn squash_file_open_with_options(
1131 codec: *mut SquashCodec,
1132 filename: *const ::std::os::raw::c_char,
1133 mode: *const ::std::os::raw::c_char,
1134 options: *mut SquashOptions,
1135 ) -> *mut SquashFile;
1136}
1137extern "C" {
1138 pub fn squash_file_steal(codec: *mut SquashCodec, fp: *mut FILE, ...) -> *mut SquashFile;
1139}
1140extern "C" {
1141 pub fn squash_file_steal_with_options(
1142 codec: *mut SquashCodec,
1143 fp: *mut FILE,
1144 options: *mut SquashOptions,
1145 ) -> *mut SquashFile;
1146}
1147extern "C" {
1148 pub fn squash_file_read(
1149 file: *mut SquashFile,
1150 decompressed_size: *mut usize,
1151 decompressed: *mut u8,
1152 ) -> SquashStatus::Type;
1153}
1154extern "C" {
1155 pub fn squash_file_write(
1156 file: *mut SquashFile,
1157 uncompressed_size: usize,
1158 uncompressed: *const u8,
1159 ) -> SquashStatus::Type;
1160}
1161extern "C" {
1162 pub fn squash_file_printf(
1163 file: *mut SquashFile,
1164 format: *const ::std::os::raw::c_char,
1165 ...
1166 ) -> SquashStatus::Type;
1167}
1168extern "C" {
1169 pub fn squash_file_vprintf(
1170 file: *mut SquashFile,
1171 format: *const ::std::os::raw::c_char,
1172 ap: va_list,
1173 ) -> SquashStatus::Type;
1174}
1175extern "C" {
1176 pub fn squash_file_flush(file: *mut SquashFile) -> SquashStatus::Type;
1177}
1178extern "C" {
1179 pub fn squash_file_close(file: *mut SquashFile) -> SquashStatus::Type;
1180}
1181extern "C" {
1182 pub fn squash_file_free(file: *mut SquashFile, fp: *mut *mut FILE) -> SquashStatus::Type;
1183}
1184extern "C" {
1185 pub fn squash_file_eof(file: *mut SquashFile) -> bool;
1186}
1187extern "C" {
1188 pub fn squash_file_error(file: *mut SquashFile) -> SquashStatus::Type;
1189}
1190extern "C" {
1191 pub fn squash_file_lock(file: *mut SquashFile);
1192}
1193extern "C" {
1194 pub fn squash_file_unlock(file: *mut SquashFile);
1195}
1196extern "C" {
1197 pub fn squash_file_read_unlocked(
1198 file: *mut SquashFile,
1199 decompressed_size: *mut usize,
1200 decompressed: *mut u8,
1201 ) -> SquashStatus::Type;
1202}
1203extern "C" {
1204 pub fn squash_file_write_unlocked(
1205 file: *mut SquashFile,
1206 uncompressed_size: usize,
1207 uncompressed: *const u8,
1208 ) -> SquashStatus::Type;
1209}
1210extern "C" {
1211 pub fn squash_file_flush_unlocked(file: *mut SquashFile) -> SquashStatus::Type;
1212}
1213extern "C" {
1214 pub fn squash_file_wopen(
1215 codec: *mut SquashCodec,
1216 filename: *const wchar_t,
1217 mode: *const wchar_t,
1218 ...
1219 ) -> *mut SquashFile;
1220}
1221extern "C" {
1222 pub fn squash_file_wopen_with_options(
1223 codec: *mut SquashCodec,
1224 filename: *const wchar_t,
1225 mode: *const wchar_t,
1226 options: *mut SquashOptions,
1227 ) -> *mut SquashFile;
1228}
1229extern "C" {
1230 pub fn squash_file_wprintf(
1231 file: *mut SquashFile,
1232 format: *const wchar_t,
1233 ...
1234 ) -> SquashStatus::Type;
1235}
1236extern "C" {
1237 pub fn squash_file_vwprintf(
1238 file: *mut SquashFile,
1239 format: *const wchar_t,
1240 ap: va_list,
1241 ) -> SquashStatus::Type;
1242}
1243impl SquashLicense {
1244 pub const SQUASH_LICENSE_UNKNOWN: SquashLicense = SquashLicense(0);
1245}
1246impl SquashLicense {
1247 pub const SQUASH_LICENSE_PERMISSIVE: SquashLicense = SquashLicense(16777216);
1248}
1249impl SquashLicense {
1250 pub const SQUASH_LICENSE_STRONG_COPYLEFT: SquashLicense = SquashLicense(33554432);
1251}
1252impl SquashLicense {
1253 pub const SQUASH_LICENSE_WEAK_COPYLEFT: SquashLicense = SquashLicense(67108864);
1254}
1255impl SquashLicense {
1256 pub const SQUASH_LICENSE_PROPRIETARY: SquashLicense = SquashLicense(134217728);
1257}
1258impl SquashLicense {
1259 pub const SQUASH_LICENSE_TYPE_MASK: SquashLicense = SquashLicense(-16777216);
1260}
1261impl SquashLicense {
1262 pub const SQUASH_LICENSE_COPYLEFT_INCOMPATIBLE: SquashLicense = SquashLicense(65536);
1263}
1264impl SquashLicense {
1265 pub const SQUASH_LICENSE_OR_GREATER: SquashLicense = SquashLicense(131072);
1266}
1267impl SquashLicense {
1268 pub const SQUASH_LICENSE_FLAGS_MASK: SquashLicense = SquashLicense(16711680);
1269}
1270impl SquashLicense {
1271 pub const SQUASH_LICENSE_PUBLIC_DOMAIN: SquashLicense = SquashLicense(16777217);
1272}
1273impl SquashLicense {
1274 pub const SQUASH_LICENSE_BSD2: SquashLicense = SquashLicense(16777218);
1275}
1276impl SquashLicense {
1277 pub const SQUASH_LICENSE_BSD3: SquashLicense = SquashLicense(16777219);
1278}
1279impl SquashLicense {
1280 pub const SQUASH_LICENSE_BSD4: SquashLicense = SquashLicense(16842756);
1281}
1282impl SquashLicense {
1283 pub const SQUASH_LICENSE_MIT: SquashLicense = SquashLicense(16777221);
1284}
1285impl SquashLicense {
1286 pub const SQUASH_LICENSE_ZLIB: SquashLicense = SquashLicense(16777222);
1287}
1288impl SquashLicense {
1289 pub const SQUASH_LICENSE_WTFPL: SquashLicense = SquashLicense(16777223);
1290}
1291impl SquashLicense {
1292 pub const SQUASH_LICENSE_X11: SquashLicense = SquashLicense(16777224);
1293}
1294impl SquashLicense {
1295 pub const SQUASH_LICENSE_APACHE: SquashLicense = SquashLicense(16777225);
1296}
1297impl SquashLicense {
1298 pub const SQUASH_LICENSE_APACHE2: SquashLicense = SquashLicense(16777226);
1299}
1300impl SquashLicense {
1301 pub const SQUASH_LICENSE_CDDL: SquashLicense = SquashLicense(16842763);
1302}
1303impl SquashLicense {
1304 pub const SQUASH_LICENSE_MSPL: SquashLicense = SquashLicense(16842764);
1305}
1306impl SquashLicense {
1307 pub const SQUASH_LICENSE_ISC: SquashLicense = SquashLicense(16777229);
1308}
1309impl SquashLicense {
1310 pub const SQUASH_LICENSE_MPL: SquashLicense = SquashLicense(67108865);
1311}
1312impl SquashLicense {
1313 pub const SQUASH_LICENSE_LGPL2P1: SquashLicense = SquashLicense(67108866);
1314}
1315impl SquashLicense {
1316 pub const SQUASH_LICENSE_LGPL2P1_PLUS: SquashLicense = SquashLicense(67239938);
1317}
1318impl SquashLicense {
1319 pub const SQUASH_LICENSE_LGPL3: SquashLicense = SquashLicense(67108867);
1320}
1321impl SquashLicense {
1322 pub const SQUASH_LICENSE_LGPL3_PLUS: SquashLicense = SquashLicense(67239939);
1323}
1324impl SquashLicense {
1325 pub const SQUASH_LICENSE_GPL1: SquashLicense = SquashLicense(33554433);
1326}
1327impl SquashLicense {
1328 pub const SQUASH_LICENSE_GPL1_PLUS: SquashLicense = SquashLicense(33685505);
1329}
1330impl SquashLicense {
1331 pub const SQUASH_LICENSE_GPL2: SquashLicense = SquashLicense(33554434);
1332}
1333impl SquashLicense {
1334 pub const SQUASH_LICENSE_GPL2_PLUS: SquashLicense = SquashLicense(33685506);
1335}
1336impl SquashLicense {
1337 pub const SQUASH_LICENSE_GPL3: SquashLicense = SquashLicense(33554435);
1338}
1339impl SquashLicense {
1340 pub const SQUASH_LICENSE_GPL3_PLUS: SquashLicense = SquashLicense(33685507);
1341}
1342impl ::std::ops::BitOr<SquashLicense> for SquashLicense {
1343 type Output = Self;
1344 #[inline]
1345 fn bitor(self, other: Self) -> Self {
1346 SquashLicense(self.0 | other.0)
1347 }
1348}
1349impl ::std::ops::BitOrAssign for SquashLicense {
1350 #[inline]
1351 fn bitor_assign(&mut self, rhs: SquashLicense) {
1352 self.0 |= rhs.0;
1353 }
1354}
1355impl ::std::ops::BitAnd<SquashLicense> for SquashLicense {
1356 type Output = Self;
1357 #[inline]
1358 fn bitand(self, other: Self) -> Self {
1359 SquashLicense(self.0 & other.0)
1360 }
1361}
1362impl ::std::ops::BitAndAssign for SquashLicense {
1363 #[inline]
1364 fn bitand_assign(&mut self, rhs: SquashLicense) {
1365 self.0 &= rhs.0;
1366 }
1367}
1368#[repr(transparent)]
1369#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1370pub struct SquashLicense(pub i32);
1371extern "C" {
1372 pub fn squash_license_from_string(license: *const ::std::os::raw::c_char) -> SquashLicense;
1373}
1374extern "C" {
1375 pub fn squash_license_to_string(license: SquashLicense) -> *const ::std::os::raw::c_char;
1376}
1377impl SquashCodecInfo {
1378 pub const SQUASH_CODEC_INFO_CAN_FLUSH: SquashCodecInfo = SquashCodecInfo(1);
1379}
1380impl SquashCodecInfo {
1381 pub const SQUASH_CODEC_INFO_DECOMPRESS_UNSAFE: SquashCodecInfo = SquashCodecInfo(2);
1382}
1383impl SquashCodecInfo {
1384 pub const SQUASH_CODEC_INFO_WRAP_SIZE: SquashCodecInfo = SquashCodecInfo(4);
1385}
1386impl SquashCodecInfo {
1387 pub const SQUASH_CODEC_INFO_AUTO_MASK: SquashCodecInfo = SquashCodecInfo(16711680);
1388}
1389impl SquashCodecInfo {
1390 pub const SQUASH_CODEC_INFO_VALID: SquashCodecInfo = SquashCodecInfo(65536);
1391}
1392impl SquashCodecInfo {
1393 pub const SQUASH_CODEC_INFO_KNOWS_UNCOMPRESSED_SIZE: SquashCodecInfo = SquashCodecInfo(131072);
1394}
1395impl SquashCodecInfo {
1396 pub const SQUASH_CODEC_INFO_NATIVE_STREAMING: SquashCodecInfo = SquashCodecInfo(262144);
1397}
1398impl SquashCodecInfo {
1399 pub const SQUASH_CODEC_INFO_MASK: SquashCodecInfo = SquashCodecInfo(16777215);
1400}
1401impl ::std::ops::BitOr<SquashCodecInfo> for SquashCodecInfo {
1402 type Output = Self;
1403 #[inline]
1404 fn bitor(self, other: Self) -> Self {
1405 SquashCodecInfo(self.0 | other.0)
1406 }
1407}
1408impl ::std::ops::BitOrAssign for SquashCodecInfo {
1409 #[inline]
1410 fn bitor_assign(&mut self, rhs: SquashCodecInfo) {
1411 self.0 |= rhs.0;
1412 }
1413}
1414impl ::std::ops::BitAnd<SquashCodecInfo> for SquashCodecInfo {
1415 type Output = Self;
1416 #[inline]
1417 fn bitand(self, other: Self) -> Self {
1418 SquashCodecInfo(self.0 & other.0)
1419 }
1420}
1421impl ::std::ops::BitAndAssign for SquashCodecInfo {
1422 #[inline]
1423 fn bitand_assign(&mut self, rhs: SquashCodecInfo) {
1424 self.0 &= rhs.0;
1425 }
1426}
1427#[repr(transparent)]
1428#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1429pub struct SquashCodecInfo(pub u32);
1430pub type SquashReadFunc = ::std::option::Option<
1431 unsafe extern "C" fn(
1432 data_size: *mut usize,
1433 data: *mut u8,
1434 user_data: *mut ::std::os::raw::c_void,
1435 ) -> SquashStatus::Type,
1436>;
1437pub type SquashWriteFunc = ::std::option::Option<
1438 unsafe extern "C" fn(
1439 data_size: *mut usize,
1440 data: *const u8,
1441 user_data: *mut ::std::os::raw::c_void,
1442 ) -> SquashStatus::Type,
1443>;
1444#[repr(C)]
1445#[derive(Debug, Copy, Clone)]
1446pub struct SquashCodecImpl {
1447 pub info: SquashCodecInfo,
1448 pub options: *const SquashOptionInfo,
1449 pub create_stream: ::std::option::Option<
1450 unsafe extern "C" fn(
1451 codec: *mut SquashCodec,
1452 stream_type: SquashStreamType::Type,
1453 options: *mut SquashOptions,
1454 ) -> *mut SquashStream,
1455 >,
1456 pub process_stream: ::std::option::Option<
1457 unsafe extern "C" fn(
1458 stream: *mut SquashStream,
1459 operation: SquashOperation::Type,
1460 ) -> SquashStatus::Type,
1461 >,
1462 pub splice: ::std::option::Option<
1463 unsafe extern "C" fn(
1464 codec: *mut SquashCodec,
1465 options: *mut SquashOptions,
1466 stream_type: SquashStreamType::Type,
1467 read_cb: SquashReadFunc,
1468 write_cb: SquashWriteFunc,
1469 user_data: *mut ::std::os::raw::c_void,
1470 ) -> SquashStatus::Type,
1471 >,
1472 pub decompress_buffer: ::std::option::Option<
1473 unsafe extern "C" fn(
1474 codec: *mut SquashCodec,
1475 decompressed_size: *mut usize,
1476 decompressed: *mut u8,
1477 compressed_size: usize,
1478 compressed: *const u8,
1479 options: *mut SquashOptions,
1480 ) -> SquashStatus::Type,
1481 >,
1482 pub compress_buffer: ::std::option::Option<
1483 unsafe extern "C" fn(
1484 codec: *mut SquashCodec,
1485 compressed_size: *mut usize,
1486 compressed: *mut u8,
1487 uncompressed_size: usize,
1488 uncompressed: *const u8,
1489 options: *mut SquashOptions,
1490 ) -> SquashStatus::Type,
1491 >,
1492 pub compress_buffer_unsafe: ::std::option::Option<
1493 unsafe extern "C" fn(
1494 codec: *mut SquashCodec,
1495 compressed_size: *mut usize,
1496 compressed: *mut u8,
1497 uncompressed_size: usize,
1498 uncompressed: *const u8,
1499 options: *mut SquashOptions,
1500 ) -> SquashStatus::Type,
1501 >,
1502 pub get_uncompressed_size: ::std::option::Option<
1503 unsafe extern "C" fn(
1504 codec: *mut SquashCodec,
1505 compressed_size: usize,
1506 compressed: *const u8,
1507 ) -> usize,
1508 >,
1509 pub get_max_compressed_size: ::std::option::Option<
1510 unsafe extern "C" fn(codec: *mut SquashCodec, uncompressed_size: usize) -> usize,
1511 >,
1512 pub _reserved1: ::std::option::Option<unsafe extern "C" fn()>,
1513 pub _reserved2: ::std::option::Option<unsafe extern "C" fn()>,
1514 pub _reserved3: ::std::option::Option<unsafe extern "C" fn()>,
1515 pub _reserved4: ::std::option::Option<unsafe extern "C" fn()>,
1516 pub _reserved5: ::std::option::Option<unsafe extern "C" fn()>,
1517 pub _reserved6: ::std::option::Option<unsafe extern "C" fn()>,
1518 pub _reserved7: ::std::option::Option<unsafe extern "C" fn()>,
1519 pub _reserved8: ::std::option::Option<unsafe extern "C" fn()>,
1520}
1521#[test]
1522fn bindgen_test_layout_SquashCodecImpl() {
1523 assert_eq!(
1524 ::std::mem::size_of::<SquashCodecImpl>(),
1525 144usize,
1526 concat!("Size of: ", stringify!(SquashCodecImpl))
1527 );
1528 assert_eq!(
1529 ::std::mem::align_of::<SquashCodecImpl>(),
1530 8usize,
1531 concat!("Alignment of ", stringify!(SquashCodecImpl))
1532 );
1533 assert_eq!(
1534 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>())).info as *const _ as usize },
1535 0usize,
1536 concat!(
1537 "Offset of field: ",
1538 stringify!(SquashCodecImpl),
1539 "::",
1540 stringify!(info)
1541 )
1542 );
1543 assert_eq!(
1544 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>())).options as *const _ as usize },
1545 8usize,
1546 concat!(
1547 "Offset of field: ",
1548 stringify!(SquashCodecImpl),
1549 "::",
1550 stringify!(options)
1551 )
1552 );
1553 assert_eq!(
1554 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>())).create_stream as *const _ as usize },
1555 16usize,
1556 concat!(
1557 "Offset of field: ",
1558 stringify!(SquashCodecImpl),
1559 "::",
1560 stringify!(create_stream)
1561 )
1562 );
1563 assert_eq!(
1564 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>())).process_stream as *const _ as usize },
1565 24usize,
1566 concat!(
1567 "Offset of field: ",
1568 stringify!(SquashCodecImpl),
1569 "::",
1570 stringify!(process_stream)
1571 )
1572 );
1573 assert_eq!(
1574 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>())).splice as *const _ as usize },
1575 32usize,
1576 concat!(
1577 "Offset of field: ",
1578 stringify!(SquashCodecImpl),
1579 "::",
1580 stringify!(splice)
1581 )
1582 );
1583 assert_eq!(
1584 unsafe {
1585 &(*(::std::ptr::null::<SquashCodecImpl>())).decompress_buffer as *const _ as usize
1586 },
1587 40usize,
1588 concat!(
1589 "Offset of field: ",
1590 stringify!(SquashCodecImpl),
1591 "::",
1592 stringify!(decompress_buffer)
1593 )
1594 );
1595 assert_eq!(
1596 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>())).compress_buffer as *const _ as usize },
1597 48usize,
1598 concat!(
1599 "Offset of field: ",
1600 stringify!(SquashCodecImpl),
1601 "::",
1602 stringify!(compress_buffer)
1603 )
1604 );
1605 assert_eq!(
1606 unsafe {
1607 &(*(::std::ptr::null::<SquashCodecImpl>())).compress_buffer_unsafe as *const _ as usize
1608 },
1609 56usize,
1610 concat!(
1611 "Offset of field: ",
1612 stringify!(SquashCodecImpl),
1613 "::",
1614 stringify!(compress_buffer_unsafe)
1615 )
1616 );
1617 assert_eq!(
1618 unsafe {
1619 &(*(::std::ptr::null::<SquashCodecImpl>())).get_uncompressed_size as *const _ as usize
1620 },
1621 64usize,
1622 concat!(
1623 "Offset of field: ",
1624 stringify!(SquashCodecImpl),
1625 "::",
1626 stringify!(get_uncompressed_size)
1627 )
1628 );
1629 assert_eq!(
1630 unsafe {
1631 &(*(::std::ptr::null::<SquashCodecImpl>())).get_max_compressed_size as *const _ as usize
1632 },
1633 72usize,
1634 concat!(
1635 "Offset of field: ",
1636 stringify!(SquashCodecImpl),
1637 "::",
1638 stringify!(get_max_compressed_size)
1639 )
1640 );
1641 assert_eq!(
1642 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>()))._reserved1 as *const _ as usize },
1643 80usize,
1644 concat!(
1645 "Offset of field: ",
1646 stringify!(SquashCodecImpl),
1647 "::",
1648 stringify!(_reserved1)
1649 )
1650 );
1651 assert_eq!(
1652 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>()))._reserved2 as *const _ as usize },
1653 88usize,
1654 concat!(
1655 "Offset of field: ",
1656 stringify!(SquashCodecImpl),
1657 "::",
1658 stringify!(_reserved2)
1659 )
1660 );
1661 assert_eq!(
1662 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>()))._reserved3 as *const _ as usize },
1663 96usize,
1664 concat!(
1665 "Offset of field: ",
1666 stringify!(SquashCodecImpl),
1667 "::",
1668 stringify!(_reserved3)
1669 )
1670 );
1671 assert_eq!(
1672 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>()))._reserved4 as *const _ as usize },
1673 104usize,
1674 concat!(
1675 "Offset of field: ",
1676 stringify!(SquashCodecImpl),
1677 "::",
1678 stringify!(_reserved4)
1679 )
1680 );
1681 assert_eq!(
1682 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>()))._reserved5 as *const _ as usize },
1683 112usize,
1684 concat!(
1685 "Offset of field: ",
1686 stringify!(SquashCodecImpl),
1687 "::",
1688 stringify!(_reserved5)
1689 )
1690 );
1691 assert_eq!(
1692 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>()))._reserved6 as *const _ as usize },
1693 120usize,
1694 concat!(
1695 "Offset of field: ",
1696 stringify!(SquashCodecImpl),
1697 "::",
1698 stringify!(_reserved6)
1699 )
1700 );
1701 assert_eq!(
1702 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>()))._reserved7 as *const _ as usize },
1703 128usize,
1704 concat!(
1705 "Offset of field: ",
1706 stringify!(SquashCodecImpl),
1707 "::",
1708 stringify!(_reserved7)
1709 )
1710 );
1711 assert_eq!(
1712 unsafe { &(*(::std::ptr::null::<SquashCodecImpl>()))._reserved8 as *const _ as usize },
1713 136usize,
1714 concat!(
1715 "Offset of field: ",
1716 stringify!(SquashCodecImpl),
1717 "::",
1718 stringify!(_reserved8)
1719 )
1720 );
1721}
1722pub type SquashCodecForeachFunc = ::std::option::Option<
1723 unsafe extern "C" fn(codec: *mut SquashCodec, data: *mut ::std::os::raw::c_void),
1724>;
1725extern "C" {
1726 pub fn squash_codec_init(codec: *mut SquashCodec) -> SquashStatus::Type;
1727}
1728extern "C" {
1729 pub fn squash_codec_get_name(codec: *mut SquashCodec) -> *const ::std::os::raw::c_char;
1730}
1731extern "C" {
1732 pub fn squash_codec_get_priority(codec: *mut SquashCodec) -> ::std::os::raw::c_uint;
1733}
1734extern "C" {
1735 pub fn squash_codec_get_plugin(codec: *mut SquashCodec) -> *mut SquashPlugin;
1736}
1737extern "C" {
1738 pub fn squash_codec_get_context(codec: *mut SquashCodec) -> *mut SquashContext;
1739}
1740extern "C" {
1741 pub fn squash_codec_get_extension(codec: *mut SquashCodec) -> *const ::std::os::raw::c_char;
1742}
1743extern "C" {
1744 pub fn squash_codec_get_uncompressed_size(
1745 codec: *mut SquashCodec,
1746 compressed_size: usize,
1747 compressed: *const u8,
1748 ) -> usize;
1749}
1750extern "C" {
1751 pub fn squash_codec_get_max_compressed_size(
1752 codec: *mut SquashCodec,
1753 uncompressed_size: usize,
1754 ) -> usize;
1755}
1756extern "C" {
1757 pub fn squash_codec_create_stream(
1758 codec: *mut SquashCodec,
1759 stream_type: SquashStreamType::Type,
1760 ...
1761 ) -> *mut SquashStream;
1762}
1763extern "C" {
1764 pub fn squash_codec_create_stream_with_options(
1765 codec: *mut SquashCodec,
1766 stream_type: SquashStreamType::Type,
1767 options: *mut SquashOptions,
1768 ) -> *mut SquashStream;
1769}
1770extern "C" {
1771 pub fn squash_codec_compress(
1772 codec: *mut SquashCodec,
1773 compressed_size: *mut usize,
1774 compressed: *mut u8,
1775 uncompressed_size: usize,
1776 uncompressed: *const u8,
1777 ...
1778 ) -> SquashStatus::Type;
1779}
1780extern "C" {
1781 pub fn squash_codec_compress_with_options(
1782 codec: *mut SquashCodec,
1783 compressed_size: *mut usize,
1784 compressed: *mut u8,
1785 uncompressed_size: usize,
1786 uncompressed: *const u8,
1787 options: *mut SquashOptions,
1788 ) -> SquashStatus::Type;
1789}
1790extern "C" {
1791 pub fn squash_codec_decompress(
1792 codec: *mut SquashCodec,
1793 decompressed_size: *mut usize,
1794 decompressed: *mut u8,
1795 compressed_size: usize,
1796 compressed: *const u8,
1797 ...
1798 ) -> SquashStatus::Type;
1799}
1800extern "C" {
1801 pub fn squash_codec_decompress_with_options(
1802 codec: *mut SquashCodec,
1803 decompressed_size: *mut usize,
1804 decompressed: *mut u8,
1805 compressed_size: usize,
1806 compressed: *const u8,
1807 options: *mut SquashOptions,
1808 ) -> SquashStatus::Type;
1809}
1810extern "C" {
1811 pub fn squash_codec_get_info(codec: *mut SquashCodec) -> SquashCodecInfo;
1812}
1813extern "C" {
1814 pub fn squash_codec_get_option_info(codec: *mut SquashCodec) -> *const SquashOptionInfo;
1815}
1816extern "C" {
1817 pub fn squash_splice(
1818 codec: *mut SquashCodec,
1819 stream_type: SquashStreamType::Type,
1820 fp_out: *mut FILE,
1821 fp_in: *mut FILE,
1822 size: usize,
1823 ...
1824 ) -> SquashStatus::Type;
1825}
1826extern "C" {
1827 pub fn squash_splice_with_options(
1828 codec: *mut SquashCodec,
1829 stream_type: SquashStreamType::Type,
1830 fp_out: *mut FILE,
1831 fp_in: *mut FILE,
1832 size: usize,
1833 options: *mut SquashOptions,
1834 ) -> SquashStatus::Type;
1835}
1836extern "C" {
1837 pub fn squash_splice_custom(
1838 codec: *mut SquashCodec,
1839 stream_type: SquashStreamType::Type,
1840 write_cb: SquashWriteFunc,
1841 read_cb: SquashReadFunc,
1842 user_data: *mut ::std::os::raw::c_void,
1843 size: usize,
1844 ...
1845 ) -> SquashStatus::Type;
1846}
1847extern "C" {
1848 pub fn squash_splice_custom_with_options(
1849 codec: *mut SquashCodec,
1850 stream_type: SquashStreamType::Type,
1851 write_cb: SquashWriteFunc,
1852 read_cb: SquashReadFunc,
1853 user_data: *mut ::std::os::raw::c_void,
1854 size: usize,
1855 options: *mut SquashOptions,
1856 ) -> SquashStatus::Type;
1857}
1858extern "C" {
1859 pub fn squash_plugin_init(plugin: *mut SquashPlugin) -> SquashStatus::Type;
1860}
1861extern "C" {
1862 pub fn squash_plugin_get_name(plugin: *mut SquashPlugin) -> *const ::std::os::raw::c_char;
1863}
1864extern "C" {
1865 pub fn squash_plugin_get_licenses(plugin: *mut SquashPlugin) -> *mut SquashLicense;
1866}
1867extern "C" {
1868 pub fn squash_plugin_get_codec(
1869 plugin: *mut SquashPlugin,
1870 codec: *const ::std::os::raw::c_char,
1871 ) -> *mut SquashCodec;
1872}
1873pub type SquashPluginForeachFunc = ::std::option::Option<
1874 unsafe extern "C" fn(plugin: *mut SquashPlugin, data: *mut ::std::os::raw::c_void),
1875>;
1876extern "C" {
1877 pub fn squash_plugin_foreach_codec(
1878 plugin: *mut SquashPlugin,
1879 func: SquashCodecForeachFunc,
1880 data: *mut ::std::os::raw::c_void,
1881 );
1882}
1883#[repr(C)]
1884#[derive(Debug, Copy, Clone)]
1885pub struct SquashMemoryFuncs {
1886 pub malloc:
1887 ::std::option::Option<unsafe extern "C" fn(size: usize) -> *mut ::std::os::raw::c_void>,
1888 pub realloc: ::std::option::Option<
1889 unsafe extern "C" fn(
1890 ptr: *mut ::std::os::raw::c_void,
1891 size: usize,
1892 ) -> *mut ::std::os::raw::c_void,
1893 >,
1894 pub calloc: ::std::option::Option<
1895 unsafe extern "C" fn(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void,
1896 >,
1897 pub free: ::std::option::Option<unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void)>,
1898 pub aligned_alloc: ::std::option::Option<
1899 unsafe extern "C" fn(alignment: usize, size: usize) -> *mut ::std::os::raw::c_void,
1900 >,
1901 pub aligned_free: ::std::option::Option<unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void)>,
1902}
1903#[test]
1904fn bindgen_test_layout_SquashMemoryFuncs() {
1905 assert_eq!(
1906 ::std::mem::size_of::<SquashMemoryFuncs>(),
1907 48usize,
1908 concat!("Size of: ", stringify!(SquashMemoryFuncs))
1909 );
1910 assert_eq!(
1911 ::std::mem::align_of::<SquashMemoryFuncs>(),
1912 8usize,
1913 concat!("Alignment of ", stringify!(SquashMemoryFuncs))
1914 );
1915 assert_eq!(
1916 unsafe { &(*(::std::ptr::null::<SquashMemoryFuncs>())).malloc as *const _ as usize },
1917 0usize,
1918 concat!(
1919 "Offset of field: ",
1920 stringify!(SquashMemoryFuncs),
1921 "::",
1922 stringify!(malloc)
1923 )
1924 );
1925 assert_eq!(
1926 unsafe { &(*(::std::ptr::null::<SquashMemoryFuncs>())).realloc as *const _ as usize },
1927 8usize,
1928 concat!(
1929 "Offset of field: ",
1930 stringify!(SquashMemoryFuncs),
1931 "::",
1932 stringify!(realloc)
1933 )
1934 );
1935 assert_eq!(
1936 unsafe { &(*(::std::ptr::null::<SquashMemoryFuncs>())).calloc as *const _ as usize },
1937 16usize,
1938 concat!(
1939 "Offset of field: ",
1940 stringify!(SquashMemoryFuncs),
1941 "::",
1942 stringify!(calloc)
1943 )
1944 );
1945 assert_eq!(
1946 unsafe { &(*(::std::ptr::null::<SquashMemoryFuncs>())).free as *const _ as usize },
1947 24usize,
1948 concat!(
1949 "Offset of field: ",
1950 stringify!(SquashMemoryFuncs),
1951 "::",
1952 stringify!(free)
1953 )
1954 );
1955 assert_eq!(
1956 unsafe { &(*(::std::ptr::null::<SquashMemoryFuncs>())).aligned_alloc as *const _ as usize },
1957 32usize,
1958 concat!(
1959 "Offset of field: ",
1960 stringify!(SquashMemoryFuncs),
1961 "::",
1962 stringify!(aligned_alloc)
1963 )
1964 );
1965 assert_eq!(
1966 unsafe { &(*(::std::ptr::null::<SquashMemoryFuncs>())).aligned_free as *const _ as usize },
1967 40usize,
1968 concat!(
1969 "Offset of field: ",
1970 stringify!(SquashMemoryFuncs),
1971 "::",
1972 stringify!(aligned_free)
1973 )
1974 );
1975}
1976extern "C" {
1977 pub fn squash_set_memory_functions(memfn: SquashMemoryFuncs);
1978}
1979extern "C" {
1980 pub fn squash_malloc(size: usize) -> *mut ::std::os::raw::c_void;
1981}
1982extern "C" {
1983 pub fn squash_realloc(
1984 ptr: *mut ::std::os::raw::c_void,
1985 size: usize,
1986 ) -> *mut ::std::os::raw::c_void;
1987}
1988extern "C" {
1989 pub fn squash_calloc(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void;
1990}
1991extern "C" {
1992 pub fn squash_free(ptr: *mut ::std::os::raw::c_void);
1993}
1994extern "C" {
1995 pub fn squash_aligned_alloc(alignment: usize, size: usize) -> *mut ::std::os::raw::c_void;
1996}
1997extern "C" {
1998 pub fn squash_aligned_free(ptr: *mut ::std::os::raw::c_void);
1999}
2000extern "C" {
2001 pub fn squash_set_default_search_path(search_path: *const ::std::os::raw::c_char);
2002}
2003extern "C" {
2004 pub fn squash_context_get_default() -> *mut SquashContext;
2005}
2006extern "C" {
2007 pub fn squash_context_get_plugin(
2008 context: *mut SquashContext,
2009 plugin: *const ::std::os::raw::c_char,
2010 ) -> *mut SquashPlugin;
2011}
2012extern "C" {
2013 pub fn squash_context_get_codec(
2014 context: *mut SquashContext,
2015 codec: *const ::std::os::raw::c_char,
2016 ) -> *mut SquashCodec;
2017}
2018extern "C" {
2019 pub fn squash_context_foreach_plugin(
2020 context: *mut SquashContext,
2021 func: SquashPluginForeachFunc,
2022 data: *mut ::std::os::raw::c_void,
2023 );
2024}
2025extern "C" {
2026 pub fn squash_context_foreach_codec(
2027 context: *mut SquashContext,
2028 func: SquashCodecForeachFunc,
2029 data: *mut ::std::os::raw::c_void,
2030 );
2031}
2032extern "C" {
2033 pub fn squash_context_get_codec_from_extension(
2034 context: *mut SquashContext,
2035 extension: *const ::std::os::raw::c_char,
2036 ) -> *mut SquashCodec;
2037}
2038extern "C" {
2039 pub fn squash_get_plugin(plugin: *const ::std::os::raw::c_char) -> *mut SquashPlugin;
2040}
2041extern "C" {
2042 pub fn squash_get_codec(codec: *const ::std::os::raw::c_char) -> *mut SquashCodec;
2043}
2044extern "C" {
2045 pub fn squash_foreach_plugin(func: SquashPluginForeachFunc, data: *mut ::std::os::raw::c_void);
2046}
2047extern "C" {
2048 pub fn squash_foreach_codec(func: SquashCodecForeachFunc, data: *mut ::std::os::raw::c_void);
2049}
2050extern "C" {
2051 pub fn squash_get_codec_from_extension(
2052 extension: *const ::std::os::raw::c_char,
2053 ) -> *mut SquashCodec;
2054}
2055#[doc = " <div rustbindgen replaces=\"va_list\"></div>"]
2056#[doc = " <div rustbindgen opaque></div>"]
2057#[repr(C)]
2058#[repr(align(8))]
2059#[derive(Debug, Copy, Clone)]
2060pub struct va_list {
2061 pub _bindgen_opaque_blob: [u64; 3usize],
2062}
2063#[test]
2064fn bindgen_test_layout_va_list() {
2065 assert_eq!(
2066 ::std::mem::size_of::<va_list>(),
2067 24usize,
2068 concat!("Size of: ", stringify!(va_list))
2069 );
2070 assert_eq!(
2071 ::std::mem::align_of::<va_list>(),
2072 8usize,
2073 concat!("Alignment of ", stringify!(va_list))
2074 );
2075}