1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 pub fn get_bit(&self, index: usize) -> bool {
20 debug_assert!(index / 8 < self.storage.as_ref().len());
21 let byte_index = index / 8;
22 let byte = self.storage.as_ref()[byte_index];
23 let bit_index = if cfg!(target_endian = "big") {
24 7 - (index % 8)
25 } else {
26 index % 8
27 };
28 let mask = 1 << bit_index;
29 byte & mask == mask
30 }
31 #[inline]
32 pub fn set_bit(&mut self, index: usize, val: bool) {
33 debug_assert!(index / 8 < self.storage.as_ref().len());
34 let byte_index = index / 8;
35 let byte = &mut self.storage.as_mut()[byte_index];
36 let bit_index = if cfg!(target_endian = "big") {
37 7 - (index % 8)
38 } else {
39 index % 8
40 };
41 let mask = 1 << bit_index;
42 if val {
43 *byte |= mask;
44 } else {
45 *byte &= !mask;
46 }
47 }
48 #[inline]
49 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
50 debug_assert!(bit_width <= 64);
51 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
52 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
53 let mut val = 0;
54 for i in 0..(bit_width as usize) {
55 if self.get_bit(i + bit_offset) {
56 let index = if cfg!(target_endian = "big") {
57 bit_width as usize - 1 - i
58 } else {
59 i
60 };
61 val |= 1 << index;
62 }
63 }
64 val
65 }
66 #[inline]
67 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
68 debug_assert!(bit_width <= 64);
69 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
70 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
71 for i in 0..(bit_width as usize) {
72 let mask = 1 << i;
73 let val_bit_is_set = val & mask == mask;
74 let index = if cfg!(target_endian = "big") {
75 bit_width as usize - 1 - i
76 } else {
77 i
78 };
79 self.set_bit(index + bit_offset, val_bit_is_set);
80 }
81 }
82}
83pub const FLAC_API_VERSION_CURRENT: u32 = 13;
84pub const FLAC_API_VERSION_REVISION: u32 = 0;
85pub const FLAC_API_VERSION_AGE: u32 = 1;
86pub const FLAC__MAX_METADATA_TYPE_CODE: u32 = 126;
87pub const FLAC__MIN_BLOCK_SIZE: u32 = 16;
88pub const FLAC__MAX_BLOCK_SIZE: u32 = 65535;
89pub const FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ: u32 = 4608;
90pub const FLAC__MAX_CHANNELS: u32 = 8;
91pub const FLAC__MIN_BITS_PER_SAMPLE: u32 = 4;
92pub const FLAC__MAX_BITS_PER_SAMPLE: u32 = 32;
93pub const FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE: u32 = 32;
94pub const FLAC__MAX_SAMPLE_RATE: u32 = 1048575;
95pub const FLAC__MAX_LPC_ORDER: u32 = 32;
96pub const FLAC__SUBSET_MAX_LPC_ORDER_48000HZ: u32 = 12;
97pub const FLAC__MIN_QLP_COEFF_PRECISION: u32 = 5;
98pub const FLAC__MAX_QLP_COEFF_PRECISION: u32 = 15;
99pub const FLAC__MAX_FIXED_ORDER: u32 = 4;
100pub const FLAC__MAX_RICE_PARTITION_ORDER: u32 = 15;
101pub const FLAC__SUBSET_MAX_RICE_PARTITION_ORDER: u32 = 8;
102pub const FLAC__STREAM_SYNC_LENGTH: u32 = 4;
103pub const FLAC__STREAM_METADATA_STREAMINFO_LENGTH: u32 = 34;
104pub const FLAC__STREAM_METADATA_SEEKPOINT_LENGTH: u32 = 18;
105pub const FLAC__STREAM_METADATA_HEADER_LENGTH: u32 = 4;
106extern "C" {
107 pub static mut FLAC_API_SUPPORTS_OGG_FLAC: libc::c_int;
108}
109pub type __off_t = libc::c_long;
110pub type __off64_t = libc::c_long;
111pub type FLAC__int8 = i8;
112pub type FLAC__uint8 = u8;
113pub type FLAC__int16 = i16;
114pub type FLAC__int32 = i32;
115pub type FLAC__int64 = i64;
116pub type FLAC__uint16 = u16;
117pub type FLAC__uint32 = u32;
118pub type FLAC__uint64 = u64;
119pub type FLAC__bool = libc::c_int;
120pub type FLAC__byte = FLAC__uint8;
121pub type off_t = __off_t;
122pub type FLAC__IOHandle = *mut libc::c_void;
123pub type FLAC__IOCallback_Read = ::core::option::Option<
124 unsafe extern "C" fn(
125 ptr: *mut libc::c_void,
126 size: usize,
127 nmemb: usize,
128 handle: FLAC__IOHandle,
129 ) -> usize,
130>;
131pub type FLAC__IOCallback_Write = ::core::option::Option<
132 unsafe extern "C" fn(
133 ptr: *const libc::c_void,
134 size: usize,
135 nmemb: usize,
136 handle: FLAC__IOHandle,
137 ) -> usize,
138>;
139pub type FLAC__IOCallback_Seek = ::core::option::Option<
140 unsafe extern "C" fn(
141 handle: FLAC__IOHandle,
142 offset: FLAC__int64,
143 whence: libc::c_int,
144 ) -> libc::c_int,
145>;
146pub type FLAC__IOCallback_Tell =
147 ::core::option::Option<unsafe extern "C" fn(handle: FLAC__IOHandle) -> FLAC__int64>;
148pub type FLAC__IOCallback_Eof =
149 ::core::option::Option<unsafe extern "C" fn(handle: FLAC__IOHandle) -> libc::c_int>;
150pub type FLAC__IOCallback_Close =
151 ::core::option::Option<unsafe extern "C" fn(handle: FLAC__IOHandle) -> libc::c_int>;
152#[repr(C)]
153#[derive(Debug, Copy, Clone)]
154pub struct FLAC__IOCallbacks {
155 pub read: FLAC__IOCallback_Read,
156 pub write: FLAC__IOCallback_Write,
157 pub seek: FLAC__IOCallback_Seek,
158 pub tell: FLAC__IOCallback_Tell,
159 pub eof: FLAC__IOCallback_Eof,
160 pub close: FLAC__IOCallback_Close,
161}
162#[test]
163fn bindgen_test_layout_FLAC__IOCallbacks() {
164 const UNINIT: ::core::mem::MaybeUninit<FLAC__IOCallbacks> = ::core::mem::MaybeUninit::uninit();
165 let ptr = UNINIT.as_ptr();
166 assert_eq!(
167 ::core::mem::size_of::<FLAC__IOCallbacks>(),
168 48usize,
169 concat!("Size of: ", stringify!(FLAC__IOCallbacks))
170 );
171 assert_eq!(
172 ::core::mem::align_of::<FLAC__IOCallbacks>(),
173 8usize,
174 concat!("Alignment of ", stringify!(FLAC__IOCallbacks))
175 );
176 assert_eq!(
177 unsafe { ::core::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
178 0usize,
179 concat!(
180 "Offset of field: ",
181 stringify!(FLAC__IOCallbacks),
182 "::",
183 stringify!(read)
184 )
185 );
186 assert_eq!(
187 unsafe { ::core::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
188 8usize,
189 concat!(
190 "Offset of field: ",
191 stringify!(FLAC__IOCallbacks),
192 "::",
193 stringify!(write)
194 )
195 );
196 assert_eq!(
197 unsafe { ::core::ptr::addr_of!((*ptr).seek) as usize - ptr as usize },
198 16usize,
199 concat!(
200 "Offset of field: ",
201 stringify!(FLAC__IOCallbacks),
202 "::",
203 stringify!(seek)
204 )
205 );
206 assert_eq!(
207 unsafe { ::core::ptr::addr_of!((*ptr).tell) as usize - ptr as usize },
208 24usize,
209 concat!(
210 "Offset of field: ",
211 stringify!(FLAC__IOCallbacks),
212 "::",
213 stringify!(tell)
214 )
215 );
216 assert_eq!(
217 unsafe { ::core::ptr::addr_of!((*ptr).eof) as usize - ptr as usize },
218 32usize,
219 concat!(
220 "Offset of field: ",
221 stringify!(FLAC__IOCallbacks),
222 "::",
223 stringify!(eof)
224 )
225 );
226 assert_eq!(
227 unsafe { ::core::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
228 40usize,
229 concat!(
230 "Offset of field: ",
231 stringify!(FLAC__IOCallbacks),
232 "::",
233 stringify!(close)
234 )
235 );
236}
237extern "C" {
238 pub static mut FLAC__VERSION_STRING: *const libc::c_char;
239}
240extern "C" {
241 pub static mut FLAC__VENDOR_STRING: *const libc::c_char;
242}
243extern "C" {
244 pub static FLAC__STREAM_SYNC_STRING: [FLAC__byte; 4usize];
245}
246extern "C" {
247 pub static FLAC__STREAM_SYNC: u32;
248}
249extern "C" {
250 pub static FLAC__STREAM_SYNC_LEN: u32;
251}
252pub const FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: FLAC__EntropyCodingMethodType = 0;
253pub const FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: FLAC__EntropyCodingMethodType = 1;
254pub type FLAC__EntropyCodingMethodType = libc::c_uint;
255extern "C" {
256 pub static FLAC__EntropyCodingMethodTypeString: [*const libc::c_char; 0usize];
257}
258#[repr(C)]
259#[derive(Debug, Copy, Clone)]
260pub struct FLAC__EntropyCodingMethod_PartitionedRiceContents {
261 pub parameters: *mut u32,
262 pub raw_bits: *mut u32,
263 pub capacity_by_order: u32,
264}
265#[test]
266fn bindgen_test_layout_FLAC__EntropyCodingMethod_PartitionedRiceContents() {
267 const UNINIT: ::core::mem::MaybeUninit<FLAC__EntropyCodingMethod_PartitionedRiceContents> =
268 ::core::mem::MaybeUninit::uninit();
269 let ptr = UNINIT.as_ptr();
270 assert_eq!(
271 ::core::mem::size_of::<FLAC__EntropyCodingMethod_PartitionedRiceContents>(),
272 24usize,
273 concat!(
274 "Size of: ",
275 stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents)
276 )
277 );
278 assert_eq!(
279 ::core::mem::align_of::<FLAC__EntropyCodingMethod_PartitionedRiceContents>(),
280 8usize,
281 concat!(
282 "Alignment of ",
283 stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents)
284 )
285 );
286 assert_eq!(
287 unsafe { ::core::ptr::addr_of!((*ptr).parameters) as usize - ptr as usize },
288 0usize,
289 concat!(
290 "Offset of field: ",
291 stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents),
292 "::",
293 stringify!(parameters)
294 )
295 );
296 assert_eq!(
297 unsafe { ::core::ptr::addr_of!((*ptr).raw_bits) as usize - ptr as usize },
298 8usize,
299 concat!(
300 "Offset of field: ",
301 stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents),
302 "::",
303 stringify!(raw_bits)
304 )
305 );
306 assert_eq!(
307 unsafe { ::core::ptr::addr_of!((*ptr).capacity_by_order) as usize - ptr as usize },
308 16usize,
309 concat!(
310 "Offset of field: ",
311 stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents),
312 "::",
313 stringify!(capacity_by_order)
314 )
315 );
316}
317#[repr(C)]
318#[derive(Debug, Copy, Clone)]
319pub struct FLAC__EntropyCodingMethod_PartitionedRice {
320 pub order: u32,
321 pub contents: *const FLAC__EntropyCodingMethod_PartitionedRiceContents,
322}
323#[test]
324fn bindgen_test_layout_FLAC__EntropyCodingMethod_PartitionedRice() {
325 const UNINIT: ::core::mem::MaybeUninit<FLAC__EntropyCodingMethod_PartitionedRice> =
326 ::core::mem::MaybeUninit::uninit();
327 let ptr = UNINIT.as_ptr();
328 assert_eq!(
329 ::core::mem::size_of::<FLAC__EntropyCodingMethod_PartitionedRice>(),
330 16usize,
331 concat!(
332 "Size of: ",
333 stringify!(FLAC__EntropyCodingMethod_PartitionedRice)
334 )
335 );
336 assert_eq!(
337 ::core::mem::align_of::<FLAC__EntropyCodingMethod_PartitionedRice>(),
338 8usize,
339 concat!(
340 "Alignment of ",
341 stringify!(FLAC__EntropyCodingMethod_PartitionedRice)
342 )
343 );
344 assert_eq!(
345 unsafe { ::core::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
346 0usize,
347 concat!(
348 "Offset of field: ",
349 stringify!(FLAC__EntropyCodingMethod_PartitionedRice),
350 "::",
351 stringify!(order)
352 )
353 );
354 assert_eq!(
355 unsafe { ::core::ptr::addr_of!((*ptr).contents) as usize - ptr as usize },
356 8usize,
357 concat!(
358 "Offset of field: ",
359 stringify!(FLAC__EntropyCodingMethod_PartitionedRice),
360 "::",
361 stringify!(contents)
362 )
363 );
364}
365extern "C" {
366 pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN: u32;
367}
368extern "C" {
369 pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN: u32;
370}
371extern "C" {
372 pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN: u32;
373}
374extern "C" {
375 pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN: u32;
376}
377extern "C" {
378 pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER: u32;
379}
380extern "C" {
381 pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER: u32;
382}
383#[repr(C)]
384#[derive(Copy, Clone)]
385pub struct FLAC__EntropyCodingMethod {
386 pub type_: FLAC__EntropyCodingMethodType,
387 pub data: FLAC__EntropyCodingMethod__bindgen_ty_1,
388}
389#[repr(C)]
390#[derive(Copy, Clone)]
391pub union FLAC__EntropyCodingMethod__bindgen_ty_1 {
392 pub partitioned_rice: FLAC__EntropyCodingMethod_PartitionedRice,
393}
394#[test]
395fn bindgen_test_layout_FLAC__EntropyCodingMethod__bindgen_ty_1() {
396 const UNINIT: ::core::mem::MaybeUninit<FLAC__EntropyCodingMethod__bindgen_ty_1> =
397 ::core::mem::MaybeUninit::uninit();
398 let ptr = UNINIT.as_ptr();
399 assert_eq!(
400 ::core::mem::size_of::<FLAC__EntropyCodingMethod__bindgen_ty_1>(),
401 16usize,
402 concat!(
403 "Size of: ",
404 stringify!(FLAC__EntropyCodingMethod__bindgen_ty_1)
405 )
406 );
407 assert_eq!(
408 ::core::mem::align_of::<FLAC__EntropyCodingMethod__bindgen_ty_1>(),
409 8usize,
410 concat!(
411 "Alignment of ",
412 stringify!(FLAC__EntropyCodingMethod__bindgen_ty_1)
413 )
414 );
415 assert_eq!(
416 unsafe { ::core::ptr::addr_of!((*ptr).partitioned_rice) as usize - ptr as usize },
417 0usize,
418 concat!(
419 "Offset of field: ",
420 stringify!(FLAC__EntropyCodingMethod__bindgen_ty_1),
421 "::",
422 stringify!(partitioned_rice)
423 )
424 );
425}
426#[test]
427fn bindgen_test_layout_FLAC__EntropyCodingMethod() {
428 const UNINIT: ::core::mem::MaybeUninit<FLAC__EntropyCodingMethod> =
429 ::core::mem::MaybeUninit::uninit();
430 let ptr = UNINIT.as_ptr();
431 assert_eq!(
432 ::core::mem::size_of::<FLAC__EntropyCodingMethod>(),
433 24usize,
434 concat!("Size of: ", stringify!(FLAC__EntropyCodingMethod))
435 );
436 assert_eq!(
437 ::core::mem::align_of::<FLAC__EntropyCodingMethod>(),
438 8usize,
439 concat!("Alignment of ", stringify!(FLAC__EntropyCodingMethod))
440 );
441 assert_eq!(
442 unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
443 0usize,
444 concat!(
445 "Offset of field: ",
446 stringify!(FLAC__EntropyCodingMethod),
447 "::",
448 stringify!(type_)
449 )
450 );
451 assert_eq!(
452 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
453 8usize,
454 concat!(
455 "Offset of field: ",
456 stringify!(FLAC__EntropyCodingMethod),
457 "::",
458 stringify!(data)
459 )
460 );
461}
462extern "C" {
463 pub static FLAC__ENTROPY_CODING_METHOD_TYPE_LEN: u32;
464}
465pub const FLAC__SUBFRAME_TYPE_CONSTANT: FLAC__SubframeType = 0;
466pub const FLAC__SUBFRAME_TYPE_VERBATIM: FLAC__SubframeType = 1;
467pub const FLAC__SUBFRAME_TYPE_FIXED: FLAC__SubframeType = 2;
468pub const FLAC__SUBFRAME_TYPE_LPC: FLAC__SubframeType = 3;
469pub type FLAC__SubframeType = libc::c_uint;
470extern "C" {
471 pub static FLAC__SubframeTypeString: [*const libc::c_char; 0usize];
472}
473#[repr(C)]
474#[derive(Debug, Copy, Clone)]
475pub struct FLAC__Subframe_Constant {
476 pub value: FLAC__int64,
477}
478#[test]
479fn bindgen_test_layout_FLAC__Subframe_Constant() {
480 const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_Constant> =
481 ::core::mem::MaybeUninit::uninit();
482 let ptr = UNINIT.as_ptr();
483 assert_eq!(
484 ::core::mem::size_of::<FLAC__Subframe_Constant>(),
485 8usize,
486 concat!("Size of: ", stringify!(FLAC__Subframe_Constant))
487 );
488 assert_eq!(
489 ::core::mem::align_of::<FLAC__Subframe_Constant>(),
490 8usize,
491 concat!("Alignment of ", stringify!(FLAC__Subframe_Constant))
492 );
493 assert_eq!(
494 unsafe { ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
495 0usize,
496 concat!(
497 "Offset of field: ",
498 stringify!(FLAC__Subframe_Constant),
499 "::",
500 stringify!(value)
501 )
502 );
503}
504pub const FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32: FLAC__VerbatimSubframeDataType = 0;
505pub const FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64: FLAC__VerbatimSubframeDataType = 1;
506pub type FLAC__VerbatimSubframeDataType = libc::c_uint;
507#[repr(C)]
508#[derive(Copy, Clone)]
509pub struct FLAC__Subframe_Verbatim {
510 pub data: FLAC__Subframe_Verbatim__bindgen_ty_1,
511 pub data_type: FLAC__VerbatimSubframeDataType,
512}
513#[repr(C)]
514#[derive(Copy, Clone)]
515pub union FLAC__Subframe_Verbatim__bindgen_ty_1 {
516 pub int32: *const FLAC__int32,
517 pub int64: *const FLAC__int64,
518}
519#[test]
520fn bindgen_test_layout_FLAC__Subframe_Verbatim__bindgen_ty_1() {
521 const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_Verbatim__bindgen_ty_1> =
522 ::core::mem::MaybeUninit::uninit();
523 let ptr = UNINIT.as_ptr();
524 assert_eq!(
525 ::core::mem::size_of::<FLAC__Subframe_Verbatim__bindgen_ty_1>(),
526 8usize,
527 concat!(
528 "Size of: ",
529 stringify!(FLAC__Subframe_Verbatim__bindgen_ty_1)
530 )
531 );
532 assert_eq!(
533 ::core::mem::align_of::<FLAC__Subframe_Verbatim__bindgen_ty_1>(),
534 8usize,
535 concat!(
536 "Alignment of ",
537 stringify!(FLAC__Subframe_Verbatim__bindgen_ty_1)
538 )
539 );
540 assert_eq!(
541 unsafe { ::core::ptr::addr_of!((*ptr).int32) as usize - ptr as usize },
542 0usize,
543 concat!(
544 "Offset of field: ",
545 stringify!(FLAC__Subframe_Verbatim__bindgen_ty_1),
546 "::",
547 stringify!(int32)
548 )
549 );
550 assert_eq!(
551 unsafe { ::core::ptr::addr_of!((*ptr).int64) as usize - ptr as usize },
552 0usize,
553 concat!(
554 "Offset of field: ",
555 stringify!(FLAC__Subframe_Verbatim__bindgen_ty_1),
556 "::",
557 stringify!(int64)
558 )
559 );
560}
561#[test]
562fn bindgen_test_layout_FLAC__Subframe_Verbatim() {
563 const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_Verbatim> =
564 ::core::mem::MaybeUninit::uninit();
565 let ptr = UNINIT.as_ptr();
566 assert_eq!(
567 ::core::mem::size_of::<FLAC__Subframe_Verbatim>(),
568 16usize,
569 concat!("Size of: ", stringify!(FLAC__Subframe_Verbatim))
570 );
571 assert_eq!(
572 ::core::mem::align_of::<FLAC__Subframe_Verbatim>(),
573 8usize,
574 concat!("Alignment of ", stringify!(FLAC__Subframe_Verbatim))
575 );
576 assert_eq!(
577 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
578 0usize,
579 concat!(
580 "Offset of field: ",
581 stringify!(FLAC__Subframe_Verbatim),
582 "::",
583 stringify!(data)
584 )
585 );
586 assert_eq!(
587 unsafe { ::core::ptr::addr_of!((*ptr).data_type) as usize - ptr as usize },
588 8usize,
589 concat!(
590 "Offset of field: ",
591 stringify!(FLAC__Subframe_Verbatim),
592 "::",
593 stringify!(data_type)
594 )
595 );
596}
597#[repr(C)]
598#[derive(Copy, Clone)]
599pub struct FLAC__Subframe_Fixed {
600 pub entropy_coding_method: FLAC__EntropyCodingMethod,
601 pub order: u32,
602 pub warmup: [FLAC__int64; 4usize],
603 pub residual: *const FLAC__int32,
604}
605#[test]
606fn bindgen_test_layout_FLAC__Subframe_Fixed() {
607 const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_Fixed> =
608 ::core::mem::MaybeUninit::uninit();
609 let ptr = UNINIT.as_ptr();
610 assert_eq!(
611 ::core::mem::size_of::<FLAC__Subframe_Fixed>(),
612 72usize,
613 concat!("Size of: ", stringify!(FLAC__Subframe_Fixed))
614 );
615 assert_eq!(
616 ::core::mem::align_of::<FLAC__Subframe_Fixed>(),
617 8usize,
618 concat!("Alignment of ", stringify!(FLAC__Subframe_Fixed))
619 );
620 assert_eq!(
621 unsafe { ::core::ptr::addr_of!((*ptr).entropy_coding_method) as usize - ptr as usize },
622 0usize,
623 concat!(
624 "Offset of field: ",
625 stringify!(FLAC__Subframe_Fixed),
626 "::",
627 stringify!(entropy_coding_method)
628 )
629 );
630 assert_eq!(
631 unsafe { ::core::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
632 24usize,
633 concat!(
634 "Offset of field: ",
635 stringify!(FLAC__Subframe_Fixed),
636 "::",
637 stringify!(order)
638 )
639 );
640 assert_eq!(
641 unsafe { ::core::ptr::addr_of!((*ptr).warmup) as usize - ptr as usize },
642 32usize,
643 concat!(
644 "Offset of field: ",
645 stringify!(FLAC__Subframe_Fixed),
646 "::",
647 stringify!(warmup)
648 )
649 );
650 assert_eq!(
651 unsafe { ::core::ptr::addr_of!((*ptr).residual) as usize - ptr as usize },
652 64usize,
653 concat!(
654 "Offset of field: ",
655 stringify!(FLAC__Subframe_Fixed),
656 "::",
657 stringify!(residual)
658 )
659 );
660}
661#[repr(C)]
662#[derive(Copy, Clone)]
663pub struct FLAC__Subframe_LPC {
664 pub entropy_coding_method: FLAC__EntropyCodingMethod,
665 pub order: u32,
666 pub qlp_coeff_precision: u32,
667 pub quantization_level: libc::c_int,
668 pub qlp_coeff: [FLAC__int32; 32usize],
669 pub warmup: [FLAC__int64; 32usize],
670 pub residual: *const FLAC__int32,
671}
672#[test]
673fn bindgen_test_layout_FLAC__Subframe_LPC() {
674 const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_LPC> = ::core::mem::MaybeUninit::uninit();
675 let ptr = UNINIT.as_ptr();
676 assert_eq!(
677 ::core::mem::size_of::<FLAC__Subframe_LPC>(),
678 432usize,
679 concat!("Size of: ", stringify!(FLAC__Subframe_LPC))
680 );
681 assert_eq!(
682 ::core::mem::align_of::<FLAC__Subframe_LPC>(),
683 8usize,
684 concat!("Alignment of ", stringify!(FLAC__Subframe_LPC))
685 );
686 assert_eq!(
687 unsafe { ::core::ptr::addr_of!((*ptr).entropy_coding_method) as usize - ptr as usize },
688 0usize,
689 concat!(
690 "Offset of field: ",
691 stringify!(FLAC__Subframe_LPC),
692 "::",
693 stringify!(entropy_coding_method)
694 )
695 );
696 assert_eq!(
697 unsafe { ::core::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
698 24usize,
699 concat!(
700 "Offset of field: ",
701 stringify!(FLAC__Subframe_LPC),
702 "::",
703 stringify!(order)
704 )
705 );
706 assert_eq!(
707 unsafe { ::core::ptr::addr_of!((*ptr).qlp_coeff_precision) as usize - ptr as usize },
708 28usize,
709 concat!(
710 "Offset of field: ",
711 stringify!(FLAC__Subframe_LPC),
712 "::",
713 stringify!(qlp_coeff_precision)
714 )
715 );
716 assert_eq!(
717 unsafe { ::core::ptr::addr_of!((*ptr).quantization_level) as usize - ptr as usize },
718 32usize,
719 concat!(
720 "Offset of field: ",
721 stringify!(FLAC__Subframe_LPC),
722 "::",
723 stringify!(quantization_level)
724 )
725 );
726 assert_eq!(
727 unsafe { ::core::ptr::addr_of!((*ptr).qlp_coeff) as usize - ptr as usize },
728 36usize,
729 concat!(
730 "Offset of field: ",
731 stringify!(FLAC__Subframe_LPC),
732 "::",
733 stringify!(qlp_coeff)
734 )
735 );
736 assert_eq!(
737 unsafe { ::core::ptr::addr_of!((*ptr).warmup) as usize - ptr as usize },
738 168usize,
739 concat!(
740 "Offset of field: ",
741 stringify!(FLAC__Subframe_LPC),
742 "::",
743 stringify!(warmup)
744 )
745 );
746 assert_eq!(
747 unsafe { ::core::ptr::addr_of!((*ptr).residual) as usize - ptr as usize },
748 424usize,
749 concat!(
750 "Offset of field: ",
751 stringify!(FLAC__Subframe_LPC),
752 "::",
753 stringify!(residual)
754 )
755 );
756}
757extern "C" {
758 pub static FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN: u32;
759}
760extern "C" {
761 pub static FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN: u32;
762}
763#[repr(C)]
764#[derive(Copy, Clone)]
765pub struct FLAC__Subframe {
766 pub type_: FLAC__SubframeType,
767 pub data: FLAC__Subframe__bindgen_ty_1,
768 pub wasted_bits: u32,
769}
770#[repr(C)]
771#[derive(Copy, Clone)]
772pub union FLAC__Subframe__bindgen_ty_1 {
773 pub constant: FLAC__Subframe_Constant,
774 pub fixed: FLAC__Subframe_Fixed,
775 pub lpc: FLAC__Subframe_LPC,
776 pub verbatim: FLAC__Subframe_Verbatim,
777}
778#[test]
779fn bindgen_test_layout_FLAC__Subframe__bindgen_ty_1() {
780 const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe__bindgen_ty_1> =
781 ::core::mem::MaybeUninit::uninit();
782 let ptr = UNINIT.as_ptr();
783 assert_eq!(
784 ::core::mem::size_of::<FLAC__Subframe__bindgen_ty_1>(),
785 432usize,
786 concat!("Size of: ", stringify!(FLAC__Subframe__bindgen_ty_1))
787 );
788 assert_eq!(
789 ::core::mem::align_of::<FLAC__Subframe__bindgen_ty_1>(),
790 8usize,
791 concat!("Alignment of ", stringify!(FLAC__Subframe__bindgen_ty_1))
792 );
793 assert_eq!(
794 unsafe { ::core::ptr::addr_of!((*ptr).constant) as usize - ptr as usize },
795 0usize,
796 concat!(
797 "Offset of field: ",
798 stringify!(FLAC__Subframe__bindgen_ty_1),
799 "::",
800 stringify!(constant)
801 )
802 );
803 assert_eq!(
804 unsafe { ::core::ptr::addr_of!((*ptr).fixed) as usize - ptr as usize },
805 0usize,
806 concat!(
807 "Offset of field: ",
808 stringify!(FLAC__Subframe__bindgen_ty_1),
809 "::",
810 stringify!(fixed)
811 )
812 );
813 assert_eq!(
814 unsafe { ::core::ptr::addr_of!((*ptr).lpc) as usize - ptr as usize },
815 0usize,
816 concat!(
817 "Offset of field: ",
818 stringify!(FLAC__Subframe__bindgen_ty_1),
819 "::",
820 stringify!(lpc)
821 )
822 );
823 assert_eq!(
824 unsafe { ::core::ptr::addr_of!((*ptr).verbatim) as usize - ptr as usize },
825 0usize,
826 concat!(
827 "Offset of field: ",
828 stringify!(FLAC__Subframe__bindgen_ty_1),
829 "::",
830 stringify!(verbatim)
831 )
832 );
833}
834#[test]
835fn bindgen_test_layout_FLAC__Subframe() {
836 const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe> = ::core::mem::MaybeUninit::uninit();
837 let ptr = UNINIT.as_ptr();
838 assert_eq!(
839 ::core::mem::size_of::<FLAC__Subframe>(),
840 448usize,
841 concat!("Size of: ", stringify!(FLAC__Subframe))
842 );
843 assert_eq!(
844 ::core::mem::align_of::<FLAC__Subframe>(),
845 8usize,
846 concat!("Alignment of ", stringify!(FLAC__Subframe))
847 );
848 assert_eq!(
849 unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
850 0usize,
851 concat!(
852 "Offset of field: ",
853 stringify!(FLAC__Subframe),
854 "::",
855 stringify!(type_)
856 )
857 );
858 assert_eq!(
859 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
860 8usize,
861 concat!(
862 "Offset of field: ",
863 stringify!(FLAC__Subframe),
864 "::",
865 stringify!(data)
866 )
867 );
868 assert_eq!(
869 unsafe { ::core::ptr::addr_of!((*ptr).wasted_bits) as usize - ptr as usize },
870 440usize,
871 concat!(
872 "Offset of field: ",
873 stringify!(FLAC__Subframe),
874 "::",
875 stringify!(wasted_bits)
876 )
877 );
878}
879extern "C" {
880 pub static FLAC__SUBFRAME_ZERO_PAD_LEN: u32;
881}
882extern "C" {
883 pub static FLAC__SUBFRAME_TYPE_LEN: u32;
884}
885extern "C" {
886 pub static FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN: u32;
887}
888extern "C" {
889 pub static FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK: u32;
890}
891extern "C" {
892 pub static FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK: u32;
893}
894extern "C" {
895 pub static FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK: u32;
896}
897extern "C" {
898 pub static FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK: u32;
899}
900pub const FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: FLAC__ChannelAssignment = 0;
901pub const FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: FLAC__ChannelAssignment = 1;
902pub const FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: FLAC__ChannelAssignment = 2;
903pub const FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: FLAC__ChannelAssignment = 3;
904pub type FLAC__ChannelAssignment = libc::c_uint;
905extern "C" {
906 pub static FLAC__ChannelAssignmentString: [*const libc::c_char; 0usize];
907}
908pub const FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER: FLAC__FrameNumberType = 0;
909pub const FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER: FLAC__FrameNumberType = 1;
910pub type FLAC__FrameNumberType = libc::c_uint;
911extern "C" {
912 pub static FLAC__FrameNumberTypeString: [*const libc::c_char; 0usize];
913}
914#[repr(C)]
915#[derive(Copy, Clone)]
916pub struct FLAC__FrameHeader {
917 pub blocksize: u32,
918 pub sample_rate: u32,
919 pub channels: u32,
920 pub channel_assignment: FLAC__ChannelAssignment,
921 pub bits_per_sample: u32,
922 pub number_type: FLAC__FrameNumberType,
923 pub number: FLAC__FrameHeader__bindgen_ty_1,
924 pub crc: FLAC__uint8,
925}
926#[repr(C)]
927#[derive(Copy, Clone)]
928pub union FLAC__FrameHeader__bindgen_ty_1 {
929 pub frame_number: FLAC__uint32,
930 pub sample_number: FLAC__uint64,
931}
932#[test]
933fn bindgen_test_layout_FLAC__FrameHeader__bindgen_ty_1() {
934 const UNINIT: ::core::mem::MaybeUninit<FLAC__FrameHeader__bindgen_ty_1> =
935 ::core::mem::MaybeUninit::uninit();
936 let ptr = UNINIT.as_ptr();
937 assert_eq!(
938 ::core::mem::size_of::<FLAC__FrameHeader__bindgen_ty_1>(),
939 8usize,
940 concat!("Size of: ", stringify!(FLAC__FrameHeader__bindgen_ty_1))
941 );
942 assert_eq!(
943 ::core::mem::align_of::<FLAC__FrameHeader__bindgen_ty_1>(),
944 8usize,
945 concat!("Alignment of ", stringify!(FLAC__FrameHeader__bindgen_ty_1))
946 );
947 assert_eq!(
948 unsafe { ::core::ptr::addr_of!((*ptr).frame_number) as usize - ptr as usize },
949 0usize,
950 concat!(
951 "Offset of field: ",
952 stringify!(FLAC__FrameHeader__bindgen_ty_1),
953 "::",
954 stringify!(frame_number)
955 )
956 );
957 assert_eq!(
958 unsafe { ::core::ptr::addr_of!((*ptr).sample_number) as usize - ptr as usize },
959 0usize,
960 concat!(
961 "Offset of field: ",
962 stringify!(FLAC__FrameHeader__bindgen_ty_1),
963 "::",
964 stringify!(sample_number)
965 )
966 );
967}
968#[test]
969fn bindgen_test_layout_FLAC__FrameHeader() {
970 const UNINIT: ::core::mem::MaybeUninit<FLAC__FrameHeader> = ::core::mem::MaybeUninit::uninit();
971 let ptr = UNINIT.as_ptr();
972 assert_eq!(
973 ::core::mem::size_of::<FLAC__FrameHeader>(),
974 40usize,
975 concat!("Size of: ", stringify!(FLAC__FrameHeader))
976 );
977 assert_eq!(
978 ::core::mem::align_of::<FLAC__FrameHeader>(),
979 8usize,
980 concat!("Alignment of ", stringify!(FLAC__FrameHeader))
981 );
982 assert_eq!(
983 unsafe { ::core::ptr::addr_of!((*ptr).blocksize) as usize - ptr as usize },
984 0usize,
985 concat!(
986 "Offset of field: ",
987 stringify!(FLAC__FrameHeader),
988 "::",
989 stringify!(blocksize)
990 )
991 );
992 assert_eq!(
993 unsafe { ::core::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
994 4usize,
995 concat!(
996 "Offset of field: ",
997 stringify!(FLAC__FrameHeader),
998 "::",
999 stringify!(sample_rate)
1000 )
1001 );
1002 assert_eq!(
1003 unsafe { ::core::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
1004 8usize,
1005 concat!(
1006 "Offset of field: ",
1007 stringify!(FLAC__FrameHeader),
1008 "::",
1009 stringify!(channels)
1010 )
1011 );
1012 assert_eq!(
1013 unsafe { ::core::ptr::addr_of!((*ptr).channel_assignment) as usize - ptr as usize },
1014 12usize,
1015 concat!(
1016 "Offset of field: ",
1017 stringify!(FLAC__FrameHeader),
1018 "::",
1019 stringify!(channel_assignment)
1020 )
1021 );
1022 assert_eq!(
1023 unsafe { ::core::ptr::addr_of!((*ptr).bits_per_sample) as usize - ptr as usize },
1024 16usize,
1025 concat!(
1026 "Offset of field: ",
1027 stringify!(FLAC__FrameHeader),
1028 "::",
1029 stringify!(bits_per_sample)
1030 )
1031 );
1032 assert_eq!(
1033 unsafe { ::core::ptr::addr_of!((*ptr).number_type) as usize - ptr as usize },
1034 20usize,
1035 concat!(
1036 "Offset of field: ",
1037 stringify!(FLAC__FrameHeader),
1038 "::",
1039 stringify!(number_type)
1040 )
1041 );
1042 assert_eq!(
1043 unsafe { ::core::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
1044 24usize,
1045 concat!(
1046 "Offset of field: ",
1047 stringify!(FLAC__FrameHeader),
1048 "::",
1049 stringify!(number)
1050 )
1051 );
1052 assert_eq!(
1053 unsafe { ::core::ptr::addr_of!((*ptr).crc) as usize - ptr as usize },
1054 32usize,
1055 concat!(
1056 "Offset of field: ",
1057 stringify!(FLAC__FrameHeader),
1058 "::",
1059 stringify!(crc)
1060 )
1061 );
1062}
1063extern "C" {
1064 pub static FLAC__FRAME_HEADER_SYNC: u32;
1065}
1066extern "C" {
1067 pub static FLAC__FRAME_HEADER_SYNC_LEN: u32;
1068}
1069extern "C" {
1070 pub static FLAC__FRAME_HEADER_RESERVED_LEN: u32;
1071}
1072extern "C" {
1073 pub static FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN: u32;
1074}
1075extern "C" {
1076 pub static FLAC__FRAME_HEADER_BLOCK_SIZE_LEN: u32;
1077}
1078extern "C" {
1079 pub static FLAC__FRAME_HEADER_SAMPLE_RATE_LEN: u32;
1080}
1081extern "C" {
1082 pub static FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN: u32;
1083}
1084extern "C" {
1085 pub static FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN: u32;
1086}
1087extern "C" {
1088 pub static FLAC__FRAME_HEADER_ZERO_PAD_LEN: u32;
1089}
1090extern "C" {
1091 pub static FLAC__FRAME_HEADER_CRC_LEN: u32;
1092}
1093#[repr(C)]
1094#[derive(Debug, Copy, Clone)]
1095pub struct FLAC__FrameFooter {
1096 pub crc: FLAC__uint16,
1097}
1098#[test]
1099fn bindgen_test_layout_FLAC__FrameFooter() {
1100 const UNINIT: ::core::mem::MaybeUninit<FLAC__FrameFooter> = ::core::mem::MaybeUninit::uninit();
1101 let ptr = UNINIT.as_ptr();
1102 assert_eq!(
1103 ::core::mem::size_of::<FLAC__FrameFooter>(),
1104 2usize,
1105 concat!("Size of: ", stringify!(FLAC__FrameFooter))
1106 );
1107 assert_eq!(
1108 ::core::mem::align_of::<FLAC__FrameFooter>(),
1109 2usize,
1110 concat!("Alignment of ", stringify!(FLAC__FrameFooter))
1111 );
1112 assert_eq!(
1113 unsafe { ::core::ptr::addr_of!((*ptr).crc) as usize - ptr as usize },
1114 0usize,
1115 concat!(
1116 "Offset of field: ",
1117 stringify!(FLAC__FrameFooter),
1118 "::",
1119 stringify!(crc)
1120 )
1121 );
1122}
1123extern "C" {
1124 pub static FLAC__FRAME_FOOTER_CRC_LEN: u32;
1125}
1126#[repr(C)]
1127#[derive(Copy, Clone)]
1128pub struct FLAC__Frame {
1129 pub header: FLAC__FrameHeader,
1130 pub subframes: [FLAC__Subframe; 8usize],
1131 pub footer: FLAC__FrameFooter,
1132}
1133#[test]
1134fn bindgen_test_layout_FLAC__Frame() {
1135 const UNINIT: ::core::mem::MaybeUninit<FLAC__Frame> = ::core::mem::MaybeUninit::uninit();
1136 let ptr = UNINIT.as_ptr();
1137 assert_eq!(
1138 ::core::mem::size_of::<FLAC__Frame>(),
1139 3632usize,
1140 concat!("Size of: ", stringify!(FLAC__Frame))
1141 );
1142 assert_eq!(
1143 ::core::mem::align_of::<FLAC__Frame>(),
1144 8usize,
1145 concat!("Alignment of ", stringify!(FLAC__Frame))
1146 );
1147 assert_eq!(
1148 unsafe { ::core::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
1149 0usize,
1150 concat!(
1151 "Offset of field: ",
1152 stringify!(FLAC__Frame),
1153 "::",
1154 stringify!(header)
1155 )
1156 );
1157 assert_eq!(
1158 unsafe { ::core::ptr::addr_of!((*ptr).subframes) as usize - ptr as usize },
1159 40usize,
1160 concat!(
1161 "Offset of field: ",
1162 stringify!(FLAC__Frame),
1163 "::",
1164 stringify!(subframes)
1165 )
1166 );
1167 assert_eq!(
1168 unsafe { ::core::ptr::addr_of!((*ptr).footer) as usize - ptr as usize },
1169 3624usize,
1170 concat!(
1171 "Offset of field: ",
1172 stringify!(FLAC__Frame),
1173 "::",
1174 stringify!(footer)
1175 )
1176 );
1177}
1178pub const FLAC__METADATA_TYPE_STREAMINFO: FLAC__MetadataType = 0;
1179pub const FLAC__METADATA_TYPE_PADDING: FLAC__MetadataType = 1;
1180pub const FLAC__METADATA_TYPE_APPLICATION: FLAC__MetadataType = 2;
1181pub const FLAC__METADATA_TYPE_SEEKTABLE: FLAC__MetadataType = 3;
1182pub const FLAC__METADATA_TYPE_VORBIS_COMMENT: FLAC__MetadataType = 4;
1183pub const FLAC__METADATA_TYPE_CUESHEET: FLAC__MetadataType = 5;
1184pub const FLAC__METADATA_TYPE_PICTURE: FLAC__MetadataType = 6;
1185pub const FLAC__METADATA_TYPE_UNDEFINED: FLAC__MetadataType = 7;
1186pub const FLAC__MAX_METADATA_TYPE: FLAC__MetadataType = 126;
1187pub type FLAC__MetadataType = libc::c_uint;
1188extern "C" {
1189 pub static FLAC__MetadataTypeString: [*const libc::c_char; 0usize];
1190}
1191#[repr(C)]
1192#[derive(Debug, Copy, Clone)]
1193pub struct FLAC__StreamMetadata_StreamInfo {
1194 pub min_blocksize: u32,
1195 pub max_blocksize: u32,
1196 pub min_framesize: u32,
1197 pub max_framesize: u32,
1198 pub sample_rate: u32,
1199 pub channels: u32,
1200 pub bits_per_sample: u32,
1201 pub total_samples: FLAC__uint64,
1202 pub md5sum: [FLAC__byte; 16usize],
1203}
1204#[test]
1205fn bindgen_test_layout_FLAC__StreamMetadata_StreamInfo() {
1206 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_StreamInfo> =
1207 ::core::mem::MaybeUninit::uninit();
1208 let ptr = UNINIT.as_ptr();
1209 assert_eq!(
1210 ::core::mem::size_of::<FLAC__StreamMetadata_StreamInfo>(),
1211 56usize,
1212 concat!("Size of: ", stringify!(FLAC__StreamMetadata_StreamInfo))
1213 );
1214 assert_eq!(
1215 ::core::mem::align_of::<FLAC__StreamMetadata_StreamInfo>(),
1216 8usize,
1217 concat!("Alignment of ", stringify!(FLAC__StreamMetadata_StreamInfo))
1218 );
1219 assert_eq!(
1220 unsafe { ::core::ptr::addr_of!((*ptr).min_blocksize) as usize - ptr as usize },
1221 0usize,
1222 concat!(
1223 "Offset of field: ",
1224 stringify!(FLAC__StreamMetadata_StreamInfo),
1225 "::",
1226 stringify!(min_blocksize)
1227 )
1228 );
1229 assert_eq!(
1230 unsafe { ::core::ptr::addr_of!((*ptr).max_blocksize) as usize - ptr as usize },
1231 4usize,
1232 concat!(
1233 "Offset of field: ",
1234 stringify!(FLAC__StreamMetadata_StreamInfo),
1235 "::",
1236 stringify!(max_blocksize)
1237 )
1238 );
1239 assert_eq!(
1240 unsafe { ::core::ptr::addr_of!((*ptr).min_framesize) as usize - ptr as usize },
1241 8usize,
1242 concat!(
1243 "Offset of field: ",
1244 stringify!(FLAC__StreamMetadata_StreamInfo),
1245 "::",
1246 stringify!(min_framesize)
1247 )
1248 );
1249 assert_eq!(
1250 unsafe { ::core::ptr::addr_of!((*ptr).max_framesize) as usize - ptr as usize },
1251 12usize,
1252 concat!(
1253 "Offset of field: ",
1254 stringify!(FLAC__StreamMetadata_StreamInfo),
1255 "::",
1256 stringify!(max_framesize)
1257 )
1258 );
1259 assert_eq!(
1260 unsafe { ::core::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
1261 16usize,
1262 concat!(
1263 "Offset of field: ",
1264 stringify!(FLAC__StreamMetadata_StreamInfo),
1265 "::",
1266 stringify!(sample_rate)
1267 )
1268 );
1269 assert_eq!(
1270 unsafe { ::core::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
1271 20usize,
1272 concat!(
1273 "Offset of field: ",
1274 stringify!(FLAC__StreamMetadata_StreamInfo),
1275 "::",
1276 stringify!(channels)
1277 )
1278 );
1279 assert_eq!(
1280 unsafe { ::core::ptr::addr_of!((*ptr).bits_per_sample) as usize - ptr as usize },
1281 24usize,
1282 concat!(
1283 "Offset of field: ",
1284 stringify!(FLAC__StreamMetadata_StreamInfo),
1285 "::",
1286 stringify!(bits_per_sample)
1287 )
1288 );
1289 assert_eq!(
1290 unsafe { ::core::ptr::addr_of!((*ptr).total_samples) as usize - ptr as usize },
1291 32usize,
1292 concat!(
1293 "Offset of field: ",
1294 stringify!(FLAC__StreamMetadata_StreamInfo),
1295 "::",
1296 stringify!(total_samples)
1297 )
1298 );
1299 assert_eq!(
1300 unsafe { ::core::ptr::addr_of!((*ptr).md5sum) as usize - ptr as usize },
1301 40usize,
1302 concat!(
1303 "Offset of field: ",
1304 stringify!(FLAC__StreamMetadata_StreamInfo),
1305 "::",
1306 stringify!(md5sum)
1307 )
1308 );
1309}
1310extern "C" {
1311 pub static FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN: u32;
1312}
1313extern "C" {
1314 pub static FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN: u32;
1315}
1316extern "C" {
1317 pub static FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN: u32;
1318}
1319extern "C" {
1320 pub static FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN: u32;
1321}
1322extern "C" {
1323 pub static FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN: u32;
1324}
1325extern "C" {
1326 pub static FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN: u32;
1327}
1328extern "C" {
1329 pub static FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN: u32;
1330}
1331extern "C" {
1332 pub static FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN: u32;
1333}
1334extern "C" {
1335 pub static FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN: u32;
1336}
1337#[repr(C)]
1338#[derive(Debug, Copy, Clone)]
1339pub struct FLAC__StreamMetadata_Padding {
1340 pub dummy: libc::c_int,
1341}
1342#[test]
1343fn bindgen_test_layout_FLAC__StreamMetadata_Padding() {
1344 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_Padding> =
1345 ::core::mem::MaybeUninit::uninit();
1346 let ptr = UNINIT.as_ptr();
1347 assert_eq!(
1348 ::core::mem::size_of::<FLAC__StreamMetadata_Padding>(),
1349 4usize,
1350 concat!("Size of: ", stringify!(FLAC__StreamMetadata_Padding))
1351 );
1352 assert_eq!(
1353 ::core::mem::align_of::<FLAC__StreamMetadata_Padding>(),
1354 4usize,
1355 concat!("Alignment of ", stringify!(FLAC__StreamMetadata_Padding))
1356 );
1357 assert_eq!(
1358 unsafe { ::core::ptr::addr_of!((*ptr).dummy) as usize - ptr as usize },
1359 0usize,
1360 concat!(
1361 "Offset of field: ",
1362 stringify!(FLAC__StreamMetadata_Padding),
1363 "::",
1364 stringify!(dummy)
1365 )
1366 );
1367}
1368#[repr(C)]
1369#[derive(Debug, Copy, Clone)]
1370pub struct FLAC__StreamMetadata_Application {
1371 pub id: [FLAC__byte; 4usize],
1372 pub data: *mut FLAC__byte,
1373}
1374#[test]
1375fn bindgen_test_layout_FLAC__StreamMetadata_Application() {
1376 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_Application> =
1377 ::core::mem::MaybeUninit::uninit();
1378 let ptr = UNINIT.as_ptr();
1379 assert_eq!(
1380 ::core::mem::size_of::<FLAC__StreamMetadata_Application>(),
1381 16usize,
1382 concat!("Size of: ", stringify!(FLAC__StreamMetadata_Application))
1383 );
1384 assert_eq!(
1385 ::core::mem::align_of::<FLAC__StreamMetadata_Application>(),
1386 8usize,
1387 concat!(
1388 "Alignment of ",
1389 stringify!(FLAC__StreamMetadata_Application)
1390 )
1391 );
1392 assert_eq!(
1393 unsafe { ::core::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
1394 0usize,
1395 concat!(
1396 "Offset of field: ",
1397 stringify!(FLAC__StreamMetadata_Application),
1398 "::",
1399 stringify!(id)
1400 )
1401 );
1402 assert_eq!(
1403 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
1404 8usize,
1405 concat!(
1406 "Offset of field: ",
1407 stringify!(FLAC__StreamMetadata_Application),
1408 "::",
1409 stringify!(data)
1410 )
1411 );
1412}
1413extern "C" {
1414 pub static FLAC__STREAM_METADATA_APPLICATION_ID_LEN: u32;
1415}
1416#[repr(C)]
1417#[derive(Debug, Copy, Clone)]
1418pub struct FLAC__StreamMetadata_SeekPoint {
1419 pub sample_number: FLAC__uint64,
1420 pub stream_offset: FLAC__uint64,
1421 pub frame_samples: u32,
1422}
1423#[test]
1424fn bindgen_test_layout_FLAC__StreamMetadata_SeekPoint() {
1425 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_SeekPoint> =
1426 ::core::mem::MaybeUninit::uninit();
1427 let ptr = UNINIT.as_ptr();
1428 assert_eq!(
1429 ::core::mem::size_of::<FLAC__StreamMetadata_SeekPoint>(),
1430 24usize,
1431 concat!("Size of: ", stringify!(FLAC__StreamMetadata_SeekPoint))
1432 );
1433 assert_eq!(
1434 ::core::mem::align_of::<FLAC__StreamMetadata_SeekPoint>(),
1435 8usize,
1436 concat!("Alignment of ", stringify!(FLAC__StreamMetadata_SeekPoint))
1437 );
1438 assert_eq!(
1439 unsafe { ::core::ptr::addr_of!((*ptr).sample_number) as usize - ptr as usize },
1440 0usize,
1441 concat!(
1442 "Offset of field: ",
1443 stringify!(FLAC__StreamMetadata_SeekPoint),
1444 "::",
1445 stringify!(sample_number)
1446 )
1447 );
1448 assert_eq!(
1449 unsafe { ::core::ptr::addr_of!((*ptr).stream_offset) as usize - ptr as usize },
1450 8usize,
1451 concat!(
1452 "Offset of field: ",
1453 stringify!(FLAC__StreamMetadata_SeekPoint),
1454 "::",
1455 stringify!(stream_offset)
1456 )
1457 );
1458 assert_eq!(
1459 unsafe { ::core::ptr::addr_of!((*ptr).frame_samples) as usize - ptr as usize },
1460 16usize,
1461 concat!(
1462 "Offset of field: ",
1463 stringify!(FLAC__StreamMetadata_SeekPoint),
1464 "::",
1465 stringify!(frame_samples)
1466 )
1467 );
1468}
1469extern "C" {
1470 pub static FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN: u32;
1471}
1472extern "C" {
1473 pub static FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN: u32;
1474}
1475extern "C" {
1476 pub static FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN: u32;
1477}
1478extern "C" {
1479 pub static FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER: FLAC__uint64;
1480}
1481#[repr(C)]
1482#[derive(Debug, Copy, Clone)]
1483pub struct FLAC__StreamMetadata_SeekTable {
1484 pub num_points: u32,
1485 pub points: *mut FLAC__StreamMetadata_SeekPoint,
1486}
1487#[test]
1488fn bindgen_test_layout_FLAC__StreamMetadata_SeekTable() {
1489 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_SeekTable> =
1490 ::core::mem::MaybeUninit::uninit();
1491 let ptr = UNINIT.as_ptr();
1492 assert_eq!(
1493 ::core::mem::size_of::<FLAC__StreamMetadata_SeekTable>(),
1494 16usize,
1495 concat!("Size of: ", stringify!(FLAC__StreamMetadata_SeekTable))
1496 );
1497 assert_eq!(
1498 ::core::mem::align_of::<FLAC__StreamMetadata_SeekTable>(),
1499 8usize,
1500 concat!("Alignment of ", stringify!(FLAC__StreamMetadata_SeekTable))
1501 );
1502 assert_eq!(
1503 unsafe { ::core::ptr::addr_of!((*ptr).num_points) as usize - ptr as usize },
1504 0usize,
1505 concat!(
1506 "Offset of field: ",
1507 stringify!(FLAC__StreamMetadata_SeekTable),
1508 "::",
1509 stringify!(num_points)
1510 )
1511 );
1512 assert_eq!(
1513 unsafe { ::core::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
1514 8usize,
1515 concat!(
1516 "Offset of field: ",
1517 stringify!(FLAC__StreamMetadata_SeekTable),
1518 "::",
1519 stringify!(points)
1520 )
1521 );
1522}
1523#[repr(C)]
1524#[derive(Debug, Copy, Clone)]
1525pub struct FLAC__StreamMetadata_VorbisComment_Entry {
1526 pub length: FLAC__uint32,
1527 pub entry: *mut FLAC__byte,
1528}
1529#[test]
1530fn bindgen_test_layout_FLAC__StreamMetadata_VorbisComment_Entry() {
1531 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_VorbisComment_Entry> =
1532 ::core::mem::MaybeUninit::uninit();
1533 let ptr = UNINIT.as_ptr();
1534 assert_eq!(
1535 ::core::mem::size_of::<FLAC__StreamMetadata_VorbisComment_Entry>(),
1536 16usize,
1537 concat!(
1538 "Size of: ",
1539 stringify!(FLAC__StreamMetadata_VorbisComment_Entry)
1540 )
1541 );
1542 assert_eq!(
1543 ::core::mem::align_of::<FLAC__StreamMetadata_VorbisComment_Entry>(),
1544 8usize,
1545 concat!(
1546 "Alignment of ",
1547 stringify!(FLAC__StreamMetadata_VorbisComment_Entry)
1548 )
1549 );
1550 assert_eq!(
1551 unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
1552 0usize,
1553 concat!(
1554 "Offset of field: ",
1555 stringify!(FLAC__StreamMetadata_VorbisComment_Entry),
1556 "::",
1557 stringify!(length)
1558 )
1559 );
1560 assert_eq!(
1561 unsafe { ::core::ptr::addr_of!((*ptr).entry) as usize - ptr as usize },
1562 8usize,
1563 concat!(
1564 "Offset of field: ",
1565 stringify!(FLAC__StreamMetadata_VorbisComment_Entry),
1566 "::",
1567 stringify!(entry)
1568 )
1569 );
1570}
1571extern "C" {
1572 pub static FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN: u32;
1573}
1574#[repr(C)]
1575#[derive(Debug, Copy, Clone)]
1576pub struct FLAC__StreamMetadata_VorbisComment {
1577 pub vendor_string: FLAC__StreamMetadata_VorbisComment_Entry,
1578 pub num_comments: FLAC__uint32,
1579 pub comments: *mut FLAC__StreamMetadata_VorbisComment_Entry,
1580}
1581#[test]
1582fn bindgen_test_layout_FLAC__StreamMetadata_VorbisComment() {
1583 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_VorbisComment> =
1584 ::core::mem::MaybeUninit::uninit();
1585 let ptr = UNINIT.as_ptr();
1586 assert_eq!(
1587 ::core::mem::size_of::<FLAC__StreamMetadata_VorbisComment>(),
1588 32usize,
1589 concat!("Size of: ", stringify!(FLAC__StreamMetadata_VorbisComment))
1590 );
1591 assert_eq!(
1592 ::core::mem::align_of::<FLAC__StreamMetadata_VorbisComment>(),
1593 8usize,
1594 concat!(
1595 "Alignment of ",
1596 stringify!(FLAC__StreamMetadata_VorbisComment)
1597 )
1598 );
1599 assert_eq!(
1600 unsafe { ::core::ptr::addr_of!((*ptr).vendor_string) as usize - ptr as usize },
1601 0usize,
1602 concat!(
1603 "Offset of field: ",
1604 stringify!(FLAC__StreamMetadata_VorbisComment),
1605 "::",
1606 stringify!(vendor_string)
1607 )
1608 );
1609 assert_eq!(
1610 unsafe { ::core::ptr::addr_of!((*ptr).num_comments) as usize - ptr as usize },
1611 16usize,
1612 concat!(
1613 "Offset of field: ",
1614 stringify!(FLAC__StreamMetadata_VorbisComment),
1615 "::",
1616 stringify!(num_comments)
1617 )
1618 );
1619 assert_eq!(
1620 unsafe { ::core::ptr::addr_of!((*ptr).comments) as usize - ptr as usize },
1621 24usize,
1622 concat!(
1623 "Offset of field: ",
1624 stringify!(FLAC__StreamMetadata_VorbisComment),
1625 "::",
1626 stringify!(comments)
1627 )
1628 );
1629}
1630extern "C" {
1631 pub static FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN: u32;
1632}
1633#[repr(C)]
1634#[derive(Debug, Copy, Clone)]
1635pub struct FLAC__StreamMetadata_CueSheet_Index {
1636 pub offset: FLAC__uint64,
1637 pub number: FLAC__byte,
1638}
1639#[test]
1640fn bindgen_test_layout_FLAC__StreamMetadata_CueSheet_Index() {
1641 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_CueSheet_Index> =
1642 ::core::mem::MaybeUninit::uninit();
1643 let ptr = UNINIT.as_ptr();
1644 assert_eq!(
1645 ::core::mem::size_of::<FLAC__StreamMetadata_CueSheet_Index>(),
1646 16usize,
1647 concat!("Size of: ", stringify!(FLAC__StreamMetadata_CueSheet_Index))
1648 );
1649 assert_eq!(
1650 ::core::mem::align_of::<FLAC__StreamMetadata_CueSheet_Index>(),
1651 8usize,
1652 concat!(
1653 "Alignment of ",
1654 stringify!(FLAC__StreamMetadata_CueSheet_Index)
1655 )
1656 );
1657 assert_eq!(
1658 unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1659 0usize,
1660 concat!(
1661 "Offset of field: ",
1662 stringify!(FLAC__StreamMetadata_CueSheet_Index),
1663 "::",
1664 stringify!(offset)
1665 )
1666 );
1667 assert_eq!(
1668 unsafe { ::core::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
1669 8usize,
1670 concat!(
1671 "Offset of field: ",
1672 stringify!(FLAC__StreamMetadata_CueSheet_Index),
1673 "::",
1674 stringify!(number)
1675 )
1676 );
1677}
1678extern "C" {
1679 pub static FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN: u32;
1680}
1681extern "C" {
1682 pub static FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN: u32;
1683}
1684extern "C" {
1685 pub static FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN: u32;
1686}
1687#[repr(C)]
1688#[derive(Debug, Copy, Clone)]
1689pub struct FLAC__StreamMetadata_CueSheet_Track {
1690 pub offset: FLAC__uint64,
1691 pub number: FLAC__byte,
1692 pub isrc: [libc::c_char; 13usize],
1693 pub _bitfield_align_1: [u8; 0],
1694 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1695 pub num_indices: FLAC__byte,
1696 pub indices: *mut FLAC__StreamMetadata_CueSheet_Index,
1697}
1698#[test]
1699fn bindgen_test_layout_FLAC__StreamMetadata_CueSheet_Track() {
1700 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_CueSheet_Track> =
1701 ::core::mem::MaybeUninit::uninit();
1702 let ptr = UNINIT.as_ptr();
1703 assert_eq!(
1704 ::core::mem::size_of::<FLAC__StreamMetadata_CueSheet_Track>(),
1705 32usize,
1706 concat!("Size of: ", stringify!(FLAC__StreamMetadata_CueSheet_Track))
1707 );
1708 assert_eq!(
1709 ::core::mem::align_of::<FLAC__StreamMetadata_CueSheet_Track>(),
1710 8usize,
1711 concat!(
1712 "Alignment of ",
1713 stringify!(FLAC__StreamMetadata_CueSheet_Track)
1714 )
1715 );
1716 assert_eq!(
1717 unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1718 0usize,
1719 concat!(
1720 "Offset of field: ",
1721 stringify!(FLAC__StreamMetadata_CueSheet_Track),
1722 "::",
1723 stringify!(offset)
1724 )
1725 );
1726 assert_eq!(
1727 unsafe { ::core::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
1728 8usize,
1729 concat!(
1730 "Offset of field: ",
1731 stringify!(FLAC__StreamMetadata_CueSheet_Track),
1732 "::",
1733 stringify!(number)
1734 )
1735 );
1736 assert_eq!(
1737 unsafe { ::core::ptr::addr_of!((*ptr).isrc) as usize - ptr as usize },
1738 9usize,
1739 concat!(
1740 "Offset of field: ",
1741 stringify!(FLAC__StreamMetadata_CueSheet_Track),
1742 "::",
1743 stringify!(isrc)
1744 )
1745 );
1746 assert_eq!(
1747 unsafe { ::core::ptr::addr_of!((*ptr).num_indices) as usize - ptr as usize },
1748 23usize,
1749 concat!(
1750 "Offset of field: ",
1751 stringify!(FLAC__StreamMetadata_CueSheet_Track),
1752 "::",
1753 stringify!(num_indices)
1754 )
1755 );
1756 assert_eq!(
1757 unsafe { ::core::ptr::addr_of!((*ptr).indices) as usize - ptr as usize },
1758 24usize,
1759 concat!(
1760 "Offset of field: ",
1761 stringify!(FLAC__StreamMetadata_CueSheet_Track),
1762 "::",
1763 stringify!(indices)
1764 )
1765 );
1766}
1767impl FLAC__StreamMetadata_CueSheet_Track {
1768 #[inline]
1769 pub fn type_(&self) -> u32 {
1770 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1771 }
1772 #[inline]
1773 pub fn set_type(&mut self, val: u32) {
1774 unsafe {
1775 let val: u32 = ::core::mem::transmute(val);
1776 self._bitfield_1.set(0usize, 1u8, val as u64)
1777 }
1778 }
1779 #[inline]
1780 pub fn pre_emphasis(&self) -> u32 {
1781 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1782 }
1783 #[inline]
1784 pub fn set_pre_emphasis(&mut self, val: u32) {
1785 unsafe {
1786 let val: u32 = ::core::mem::transmute(val);
1787 self._bitfield_1.set(1usize, 1u8, val as u64)
1788 }
1789 }
1790 #[inline]
1791 pub fn new_bitfield_1(type_: u32, pre_emphasis: u32) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1792 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1793 __bindgen_bitfield_unit.set(0usize, 1u8, {
1794 let type_: u32 = unsafe { ::core::mem::transmute(type_) };
1795 type_ as u64
1796 });
1797 __bindgen_bitfield_unit.set(1usize, 1u8, {
1798 let pre_emphasis: u32 = unsafe { ::core::mem::transmute(pre_emphasis) };
1799 pre_emphasis as u64
1800 });
1801 __bindgen_bitfield_unit
1802 }
1803}
1804extern "C" {
1805 pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN: u32;
1806}
1807extern "C" {
1808 pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN: u32;
1809}
1810extern "C" {
1811 pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN: u32;
1812}
1813extern "C" {
1814 pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN: u32;
1815}
1816extern "C" {
1817 pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN: u32;
1818}
1819extern "C" {
1820 pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN: u32;
1821}
1822extern "C" {
1823 pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN: u32;
1824}
1825#[repr(C)]
1826#[derive(Debug, Copy, Clone)]
1827pub struct FLAC__StreamMetadata_CueSheet {
1828 pub media_catalog_number: [libc::c_char; 129usize],
1829 pub lead_in: FLAC__uint64,
1830 pub is_cd: FLAC__bool,
1831 pub num_tracks: u32,
1832 pub tracks: *mut FLAC__StreamMetadata_CueSheet_Track,
1833}
1834#[test]
1835fn bindgen_test_layout_FLAC__StreamMetadata_CueSheet() {
1836 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_CueSheet> =
1837 ::core::mem::MaybeUninit::uninit();
1838 let ptr = UNINIT.as_ptr();
1839 assert_eq!(
1840 ::core::mem::size_of::<FLAC__StreamMetadata_CueSheet>(),
1841 160usize,
1842 concat!("Size of: ", stringify!(FLAC__StreamMetadata_CueSheet))
1843 );
1844 assert_eq!(
1845 ::core::mem::align_of::<FLAC__StreamMetadata_CueSheet>(),
1846 8usize,
1847 concat!("Alignment of ", stringify!(FLAC__StreamMetadata_CueSheet))
1848 );
1849 assert_eq!(
1850 unsafe { ::core::ptr::addr_of!((*ptr).media_catalog_number) as usize - ptr as usize },
1851 0usize,
1852 concat!(
1853 "Offset of field: ",
1854 stringify!(FLAC__StreamMetadata_CueSheet),
1855 "::",
1856 stringify!(media_catalog_number)
1857 )
1858 );
1859 assert_eq!(
1860 unsafe { ::core::ptr::addr_of!((*ptr).lead_in) as usize - ptr as usize },
1861 136usize,
1862 concat!(
1863 "Offset of field: ",
1864 stringify!(FLAC__StreamMetadata_CueSheet),
1865 "::",
1866 stringify!(lead_in)
1867 )
1868 );
1869 assert_eq!(
1870 unsafe { ::core::ptr::addr_of!((*ptr).is_cd) as usize - ptr as usize },
1871 144usize,
1872 concat!(
1873 "Offset of field: ",
1874 stringify!(FLAC__StreamMetadata_CueSheet),
1875 "::",
1876 stringify!(is_cd)
1877 )
1878 );
1879 assert_eq!(
1880 unsafe { ::core::ptr::addr_of!((*ptr).num_tracks) as usize - ptr as usize },
1881 148usize,
1882 concat!(
1883 "Offset of field: ",
1884 stringify!(FLAC__StreamMetadata_CueSheet),
1885 "::",
1886 stringify!(num_tracks)
1887 )
1888 );
1889 assert_eq!(
1890 unsafe { ::core::ptr::addr_of!((*ptr).tracks) as usize - ptr as usize },
1891 152usize,
1892 concat!(
1893 "Offset of field: ",
1894 stringify!(FLAC__StreamMetadata_CueSheet),
1895 "::",
1896 stringify!(tracks)
1897 )
1898 );
1899}
1900extern "C" {
1901 pub static FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN: u32;
1902}
1903extern "C" {
1904 pub static FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN: u32;
1905}
1906extern "C" {
1907 pub static FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN: u32;
1908}
1909extern "C" {
1910 pub static FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN: u32;
1911}
1912extern "C" {
1913 pub static FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN: u32;
1914}
1915pub const FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER: FLAC__StreamMetadata_Picture_Type = 0;
1916pub const FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD: FLAC__StreamMetadata_Picture_Type =
1917 1;
1918pub const FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON: FLAC__StreamMetadata_Picture_Type = 2;
1919pub const FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER: FLAC__StreamMetadata_Picture_Type = 3;
1920pub const FLAC__STREAM_METADATA_PICTURE_TYPE_BACK_COVER: FLAC__StreamMetadata_Picture_Type = 4;
1921pub const FLAC__STREAM_METADATA_PICTURE_TYPE_LEAFLET_PAGE: FLAC__StreamMetadata_Picture_Type = 5;
1922pub const FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA: FLAC__StreamMetadata_Picture_Type = 6;
1923pub const FLAC__STREAM_METADATA_PICTURE_TYPE_LEAD_ARTIST: FLAC__StreamMetadata_Picture_Type = 7;
1924pub const FLAC__STREAM_METADATA_PICTURE_TYPE_ARTIST: FLAC__StreamMetadata_Picture_Type = 8;
1925pub const FLAC__STREAM_METADATA_PICTURE_TYPE_CONDUCTOR: FLAC__StreamMetadata_Picture_Type = 9;
1926pub const FLAC__STREAM_METADATA_PICTURE_TYPE_BAND: FLAC__StreamMetadata_Picture_Type = 10;
1927pub const FLAC__STREAM_METADATA_PICTURE_TYPE_COMPOSER: FLAC__StreamMetadata_Picture_Type = 11;
1928pub const FLAC__STREAM_METADATA_PICTURE_TYPE_LYRICIST: FLAC__StreamMetadata_Picture_Type = 12;
1929pub const FLAC__STREAM_METADATA_PICTURE_TYPE_RECORDING_LOCATION: FLAC__StreamMetadata_Picture_Type =
1930 13;
1931pub const FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_RECORDING: FLAC__StreamMetadata_Picture_Type =
1932 14;
1933pub const FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_PERFORMANCE: FLAC__StreamMetadata_Picture_Type =
1934 15;
1935pub const FLAC__STREAM_METADATA_PICTURE_TYPE_VIDEO_SCREEN_CAPTURE:
1936 FLAC__StreamMetadata_Picture_Type = 16;
1937pub const FLAC__STREAM_METADATA_PICTURE_TYPE_FISH: FLAC__StreamMetadata_Picture_Type = 17;
1938pub const FLAC__STREAM_METADATA_PICTURE_TYPE_ILLUSTRATION: FLAC__StreamMetadata_Picture_Type = 18;
1939pub const FLAC__STREAM_METADATA_PICTURE_TYPE_BAND_LOGOTYPE: FLAC__StreamMetadata_Picture_Type = 19;
1940pub const FLAC__STREAM_METADATA_PICTURE_TYPE_PUBLISHER_LOGOTYPE: FLAC__StreamMetadata_Picture_Type =
1941 20;
1942pub const FLAC__STREAM_METADATA_PICTURE_TYPE_UNDEFINED: FLAC__StreamMetadata_Picture_Type = 21;
1943pub type FLAC__StreamMetadata_Picture_Type = libc::c_uint;
1944extern "C" {
1945 pub static FLAC__StreamMetadata_Picture_TypeString: [*const libc::c_char; 0usize];
1946}
1947#[repr(C)]
1948#[derive(Debug, Copy, Clone)]
1949pub struct FLAC__StreamMetadata_Picture {
1950 pub type_: FLAC__StreamMetadata_Picture_Type,
1951 pub mime_type: *mut libc::c_char,
1952 pub description: *mut FLAC__byte,
1953 pub width: FLAC__uint32,
1954 pub height: FLAC__uint32,
1955 pub depth: FLAC__uint32,
1956 pub colors: FLAC__uint32,
1957 pub data_length: FLAC__uint32,
1958 pub data: *mut FLAC__byte,
1959}
1960#[test]
1961fn bindgen_test_layout_FLAC__StreamMetadata_Picture() {
1962 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_Picture> =
1963 ::core::mem::MaybeUninit::uninit();
1964 let ptr = UNINIT.as_ptr();
1965 assert_eq!(
1966 ::core::mem::size_of::<FLAC__StreamMetadata_Picture>(),
1967 56usize,
1968 concat!("Size of: ", stringify!(FLAC__StreamMetadata_Picture))
1969 );
1970 assert_eq!(
1971 ::core::mem::align_of::<FLAC__StreamMetadata_Picture>(),
1972 8usize,
1973 concat!("Alignment of ", stringify!(FLAC__StreamMetadata_Picture))
1974 );
1975 assert_eq!(
1976 unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
1977 0usize,
1978 concat!(
1979 "Offset of field: ",
1980 stringify!(FLAC__StreamMetadata_Picture),
1981 "::",
1982 stringify!(type_)
1983 )
1984 );
1985 assert_eq!(
1986 unsafe { ::core::ptr::addr_of!((*ptr).mime_type) as usize - ptr as usize },
1987 8usize,
1988 concat!(
1989 "Offset of field: ",
1990 stringify!(FLAC__StreamMetadata_Picture),
1991 "::",
1992 stringify!(mime_type)
1993 )
1994 );
1995 assert_eq!(
1996 unsafe { ::core::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
1997 16usize,
1998 concat!(
1999 "Offset of field: ",
2000 stringify!(FLAC__StreamMetadata_Picture),
2001 "::",
2002 stringify!(description)
2003 )
2004 );
2005 assert_eq!(
2006 unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
2007 24usize,
2008 concat!(
2009 "Offset of field: ",
2010 stringify!(FLAC__StreamMetadata_Picture),
2011 "::",
2012 stringify!(width)
2013 )
2014 );
2015 assert_eq!(
2016 unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
2017 28usize,
2018 concat!(
2019 "Offset of field: ",
2020 stringify!(FLAC__StreamMetadata_Picture),
2021 "::",
2022 stringify!(height)
2023 )
2024 );
2025 assert_eq!(
2026 unsafe { ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
2027 32usize,
2028 concat!(
2029 "Offset of field: ",
2030 stringify!(FLAC__StreamMetadata_Picture),
2031 "::",
2032 stringify!(depth)
2033 )
2034 );
2035 assert_eq!(
2036 unsafe { ::core::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
2037 36usize,
2038 concat!(
2039 "Offset of field: ",
2040 stringify!(FLAC__StreamMetadata_Picture),
2041 "::",
2042 stringify!(colors)
2043 )
2044 );
2045 assert_eq!(
2046 unsafe { ::core::ptr::addr_of!((*ptr).data_length) as usize - ptr as usize },
2047 40usize,
2048 concat!(
2049 "Offset of field: ",
2050 stringify!(FLAC__StreamMetadata_Picture),
2051 "::",
2052 stringify!(data_length)
2053 )
2054 );
2055 assert_eq!(
2056 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
2057 48usize,
2058 concat!(
2059 "Offset of field: ",
2060 stringify!(FLAC__StreamMetadata_Picture),
2061 "::",
2062 stringify!(data)
2063 )
2064 );
2065}
2066extern "C" {
2067 pub static FLAC__STREAM_METADATA_PICTURE_TYPE_LEN: u32;
2068}
2069extern "C" {
2070 pub static FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN: u32;
2071}
2072extern "C" {
2073 pub static FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN: u32;
2074}
2075extern "C" {
2076 pub static FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN: u32;
2077}
2078extern "C" {
2079 pub static FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN: u32;
2080}
2081extern "C" {
2082 pub static FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN: u32;
2083}
2084extern "C" {
2085 pub static FLAC__STREAM_METADATA_PICTURE_COLORS_LEN: u32;
2086}
2087extern "C" {
2088 pub static FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN: u32;
2089}
2090#[repr(C)]
2091#[derive(Debug, Copy, Clone)]
2092pub struct FLAC__StreamMetadata_Unknown {
2093 pub data: *mut FLAC__byte,
2094}
2095#[test]
2096fn bindgen_test_layout_FLAC__StreamMetadata_Unknown() {
2097 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_Unknown> =
2098 ::core::mem::MaybeUninit::uninit();
2099 let ptr = UNINIT.as_ptr();
2100 assert_eq!(
2101 ::core::mem::size_of::<FLAC__StreamMetadata_Unknown>(),
2102 8usize,
2103 concat!("Size of: ", stringify!(FLAC__StreamMetadata_Unknown))
2104 );
2105 assert_eq!(
2106 ::core::mem::align_of::<FLAC__StreamMetadata_Unknown>(),
2107 8usize,
2108 concat!("Alignment of ", stringify!(FLAC__StreamMetadata_Unknown))
2109 );
2110 assert_eq!(
2111 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
2112 0usize,
2113 concat!(
2114 "Offset of field: ",
2115 stringify!(FLAC__StreamMetadata_Unknown),
2116 "::",
2117 stringify!(data)
2118 )
2119 );
2120}
2121#[repr(C)]
2122#[derive(Copy, Clone)]
2123pub struct FLAC__StreamMetadata {
2124 pub type_: FLAC__MetadataType,
2125 pub is_last: FLAC__bool,
2126 pub length: u32,
2127 pub data: FLAC__StreamMetadata__bindgen_ty_1,
2128}
2129#[repr(C)]
2130#[derive(Copy, Clone)]
2131pub union FLAC__StreamMetadata__bindgen_ty_1 {
2132 pub stream_info: FLAC__StreamMetadata_StreamInfo,
2133 pub padding: FLAC__StreamMetadata_Padding,
2134 pub application: FLAC__StreamMetadata_Application,
2135 pub seek_table: FLAC__StreamMetadata_SeekTable,
2136 pub vorbis_comment: FLAC__StreamMetadata_VorbisComment,
2137 pub cue_sheet: FLAC__StreamMetadata_CueSheet,
2138 pub picture: FLAC__StreamMetadata_Picture,
2139 pub unknown: FLAC__StreamMetadata_Unknown,
2140}
2141#[test]
2142fn bindgen_test_layout_FLAC__StreamMetadata__bindgen_ty_1() {
2143 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata__bindgen_ty_1> =
2144 ::core::mem::MaybeUninit::uninit();
2145 let ptr = UNINIT.as_ptr();
2146 assert_eq!(
2147 ::core::mem::size_of::<FLAC__StreamMetadata__bindgen_ty_1>(),
2148 160usize,
2149 concat!("Size of: ", stringify!(FLAC__StreamMetadata__bindgen_ty_1))
2150 );
2151 assert_eq!(
2152 ::core::mem::align_of::<FLAC__StreamMetadata__bindgen_ty_1>(),
2153 8usize,
2154 concat!(
2155 "Alignment of ",
2156 stringify!(FLAC__StreamMetadata__bindgen_ty_1)
2157 )
2158 );
2159 assert_eq!(
2160 unsafe { ::core::ptr::addr_of!((*ptr).stream_info) as usize - ptr as usize },
2161 0usize,
2162 concat!(
2163 "Offset of field: ",
2164 stringify!(FLAC__StreamMetadata__bindgen_ty_1),
2165 "::",
2166 stringify!(stream_info)
2167 )
2168 );
2169 assert_eq!(
2170 unsafe { ::core::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
2171 0usize,
2172 concat!(
2173 "Offset of field: ",
2174 stringify!(FLAC__StreamMetadata__bindgen_ty_1),
2175 "::",
2176 stringify!(padding)
2177 )
2178 );
2179 assert_eq!(
2180 unsafe { ::core::ptr::addr_of!((*ptr).application) as usize - ptr as usize },
2181 0usize,
2182 concat!(
2183 "Offset of field: ",
2184 stringify!(FLAC__StreamMetadata__bindgen_ty_1),
2185 "::",
2186 stringify!(application)
2187 )
2188 );
2189 assert_eq!(
2190 unsafe { ::core::ptr::addr_of!((*ptr).seek_table) as usize - ptr as usize },
2191 0usize,
2192 concat!(
2193 "Offset of field: ",
2194 stringify!(FLAC__StreamMetadata__bindgen_ty_1),
2195 "::",
2196 stringify!(seek_table)
2197 )
2198 );
2199 assert_eq!(
2200 unsafe { ::core::ptr::addr_of!((*ptr).vorbis_comment) as usize - ptr as usize },
2201 0usize,
2202 concat!(
2203 "Offset of field: ",
2204 stringify!(FLAC__StreamMetadata__bindgen_ty_1),
2205 "::",
2206 stringify!(vorbis_comment)
2207 )
2208 );
2209 assert_eq!(
2210 unsafe { ::core::ptr::addr_of!((*ptr).cue_sheet) as usize - ptr as usize },
2211 0usize,
2212 concat!(
2213 "Offset of field: ",
2214 stringify!(FLAC__StreamMetadata__bindgen_ty_1),
2215 "::",
2216 stringify!(cue_sheet)
2217 )
2218 );
2219 assert_eq!(
2220 unsafe { ::core::ptr::addr_of!((*ptr).picture) as usize - ptr as usize },
2221 0usize,
2222 concat!(
2223 "Offset of field: ",
2224 stringify!(FLAC__StreamMetadata__bindgen_ty_1),
2225 "::",
2226 stringify!(picture)
2227 )
2228 );
2229 assert_eq!(
2230 unsafe { ::core::ptr::addr_of!((*ptr).unknown) as usize - ptr as usize },
2231 0usize,
2232 concat!(
2233 "Offset of field: ",
2234 stringify!(FLAC__StreamMetadata__bindgen_ty_1),
2235 "::",
2236 stringify!(unknown)
2237 )
2238 );
2239}
2240#[test]
2241fn bindgen_test_layout_FLAC__StreamMetadata() {
2242 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata> =
2243 ::core::mem::MaybeUninit::uninit();
2244 let ptr = UNINIT.as_ptr();
2245 assert_eq!(
2246 ::core::mem::size_of::<FLAC__StreamMetadata>(),
2247 176usize,
2248 concat!("Size of: ", stringify!(FLAC__StreamMetadata))
2249 );
2250 assert_eq!(
2251 ::core::mem::align_of::<FLAC__StreamMetadata>(),
2252 8usize,
2253 concat!("Alignment of ", stringify!(FLAC__StreamMetadata))
2254 );
2255 assert_eq!(
2256 unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
2257 0usize,
2258 concat!(
2259 "Offset of field: ",
2260 stringify!(FLAC__StreamMetadata),
2261 "::",
2262 stringify!(type_)
2263 )
2264 );
2265 assert_eq!(
2266 unsafe { ::core::ptr::addr_of!((*ptr).is_last) as usize - ptr as usize },
2267 4usize,
2268 concat!(
2269 "Offset of field: ",
2270 stringify!(FLAC__StreamMetadata),
2271 "::",
2272 stringify!(is_last)
2273 )
2274 );
2275 assert_eq!(
2276 unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
2277 8usize,
2278 concat!(
2279 "Offset of field: ",
2280 stringify!(FLAC__StreamMetadata),
2281 "::",
2282 stringify!(length)
2283 )
2284 );
2285 assert_eq!(
2286 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
2287 16usize,
2288 concat!(
2289 "Offset of field: ",
2290 stringify!(FLAC__StreamMetadata),
2291 "::",
2292 stringify!(data)
2293 )
2294 );
2295}
2296extern "C" {
2297 pub static FLAC__STREAM_METADATA_IS_LAST_LEN: u32;
2298}
2299extern "C" {
2300 pub static FLAC__STREAM_METADATA_TYPE_LEN: u32;
2301}
2302extern "C" {
2303 pub static FLAC__STREAM_METADATA_LENGTH_LEN: u32;
2304}
2305extern "C" {
2306 pub fn FLAC__format_sample_rate_is_valid(sample_rate: u32) -> FLAC__bool;
2307}
2308extern "C" {
2309 pub fn FLAC__format_blocksize_is_subset(blocksize: u32, sample_rate: u32) -> FLAC__bool;
2310}
2311extern "C" {
2312 pub fn FLAC__format_sample_rate_is_subset(sample_rate: u32) -> FLAC__bool;
2313}
2314extern "C" {
2315 pub fn FLAC__format_vorbiscomment_entry_name_is_legal(name: *const libc::c_char) -> FLAC__bool;
2316}
2317extern "C" {
2318 pub fn FLAC__format_vorbiscomment_entry_value_is_legal(
2319 value: *const FLAC__byte,
2320 length: u32,
2321 ) -> FLAC__bool;
2322}
2323extern "C" {
2324 pub fn FLAC__format_vorbiscomment_entry_is_legal(
2325 entry: *const FLAC__byte,
2326 length: u32,
2327 ) -> FLAC__bool;
2328}
2329extern "C" {
2330 pub fn FLAC__format_seektable_is_legal(
2331 seek_table: *const FLAC__StreamMetadata_SeekTable,
2332 ) -> FLAC__bool;
2333}
2334extern "C" {
2335 pub fn FLAC__format_seektable_sort(seek_table: *mut FLAC__StreamMetadata_SeekTable) -> u32;
2336}
2337extern "C" {
2338 pub fn FLAC__format_cuesheet_is_legal(
2339 cue_sheet: *const FLAC__StreamMetadata_CueSheet,
2340 check_cd_da_subset: FLAC__bool,
2341 violation: *mut *const libc::c_char,
2342 ) -> FLAC__bool;
2343}
2344extern "C" {
2345 pub fn FLAC__format_picture_is_legal(
2346 picture: *const FLAC__StreamMetadata_Picture,
2347 violation: *mut *const libc::c_char,
2348 ) -> FLAC__bool;
2349}
2350extern "C" {
2351 pub fn FLAC__metadata_get_streaminfo(
2352 filename: *const libc::c_char,
2353 streaminfo: *mut FLAC__StreamMetadata,
2354 ) -> FLAC__bool;
2355}
2356extern "C" {
2357 pub fn FLAC__metadata_get_tags(
2358 filename: *const libc::c_char,
2359 tags: *mut *mut FLAC__StreamMetadata,
2360 ) -> FLAC__bool;
2361}
2362extern "C" {
2363 pub fn FLAC__metadata_get_cuesheet(
2364 filename: *const libc::c_char,
2365 cuesheet: *mut *mut FLAC__StreamMetadata,
2366 ) -> FLAC__bool;
2367}
2368extern "C" {
2369 pub fn FLAC__metadata_get_picture(
2370 filename: *const libc::c_char,
2371 picture: *mut *mut FLAC__StreamMetadata,
2372 type_: FLAC__StreamMetadata_Picture_Type,
2373 mime_type: *const libc::c_char,
2374 description: *const FLAC__byte,
2375 max_width: u32,
2376 max_height: u32,
2377 max_depth: u32,
2378 max_colors: u32,
2379 ) -> FLAC__bool;
2380}
2381#[repr(C)]
2382#[derive(Debug, Copy, Clone)]
2383pub struct FLAC__Metadata_SimpleIterator {
2384 _unused: [u8; 0],
2385}
2386pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK: FLAC__Metadata_SimpleIteratorStatus = 0;
2387pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT: FLAC__Metadata_SimpleIteratorStatus =
2388 1;
2389pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE:
2390 FLAC__Metadata_SimpleIteratorStatus = 2;
2391pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE:
2392 FLAC__Metadata_SimpleIteratorStatus = 3;
2393pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE: FLAC__Metadata_SimpleIteratorStatus =
2394 4;
2395pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA: FLAC__Metadata_SimpleIteratorStatus =
2396 5;
2397pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR: FLAC__Metadata_SimpleIteratorStatus = 6;
2398pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR: FLAC__Metadata_SimpleIteratorStatus = 7;
2399pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR: FLAC__Metadata_SimpleIteratorStatus =
2400 8;
2401pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR: FLAC__Metadata_SimpleIteratorStatus =
2402 9;
2403pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR: FLAC__Metadata_SimpleIteratorStatus =
2404 10;
2405pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR:
2406 FLAC__Metadata_SimpleIteratorStatus = 11;
2407pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR:
2408 FLAC__Metadata_SimpleIteratorStatus = 12;
2409pub type FLAC__Metadata_SimpleIteratorStatus = libc::c_uint;
2410extern "C" {
2411 pub static FLAC__Metadata_SimpleIteratorStatusString: [*const libc::c_char; 0usize];
2412}
2413extern "C" {
2414 pub fn FLAC__metadata_simple_iterator_new() -> *mut FLAC__Metadata_SimpleIterator;
2415}
2416extern "C" {
2417 pub fn FLAC__metadata_simple_iterator_delete(iterator: *mut FLAC__Metadata_SimpleIterator);
2418}
2419extern "C" {
2420 pub fn FLAC__metadata_simple_iterator_status(
2421 iterator: *mut FLAC__Metadata_SimpleIterator,
2422 ) -> FLAC__Metadata_SimpleIteratorStatus;
2423}
2424extern "C" {
2425 pub fn FLAC__metadata_simple_iterator_init(
2426 iterator: *mut FLAC__Metadata_SimpleIterator,
2427 filename: *const libc::c_char,
2428 read_only: FLAC__bool,
2429 preserve_file_stats: FLAC__bool,
2430 ) -> FLAC__bool;
2431}
2432extern "C" {
2433 pub fn FLAC__metadata_simple_iterator_is_writable(
2434 iterator: *const FLAC__Metadata_SimpleIterator,
2435 ) -> FLAC__bool;
2436}
2437extern "C" {
2438 pub fn FLAC__metadata_simple_iterator_next(
2439 iterator: *mut FLAC__Metadata_SimpleIterator,
2440 ) -> FLAC__bool;
2441}
2442extern "C" {
2443 pub fn FLAC__metadata_simple_iterator_prev(
2444 iterator: *mut FLAC__Metadata_SimpleIterator,
2445 ) -> FLAC__bool;
2446}
2447extern "C" {
2448 pub fn FLAC__metadata_simple_iterator_is_last(
2449 iterator: *const FLAC__Metadata_SimpleIterator,
2450 ) -> FLAC__bool;
2451}
2452extern "C" {
2453 pub fn FLAC__metadata_simple_iterator_get_block_offset(
2454 iterator: *const FLAC__Metadata_SimpleIterator,
2455 ) -> off_t;
2456}
2457extern "C" {
2458 pub fn FLAC__metadata_simple_iterator_get_block_type(
2459 iterator: *const FLAC__Metadata_SimpleIterator,
2460 ) -> FLAC__MetadataType;
2461}
2462extern "C" {
2463 pub fn FLAC__metadata_simple_iterator_get_block_length(
2464 iterator: *const FLAC__Metadata_SimpleIterator,
2465 ) -> u32;
2466}
2467extern "C" {
2468 pub fn FLAC__metadata_simple_iterator_get_application_id(
2469 iterator: *mut FLAC__Metadata_SimpleIterator,
2470 id: *mut FLAC__byte,
2471 ) -> FLAC__bool;
2472}
2473extern "C" {
2474 pub fn FLAC__metadata_simple_iterator_get_block(
2475 iterator: *mut FLAC__Metadata_SimpleIterator,
2476 ) -> *mut FLAC__StreamMetadata;
2477}
2478extern "C" {
2479 pub fn FLAC__metadata_simple_iterator_set_block(
2480 iterator: *mut FLAC__Metadata_SimpleIterator,
2481 block: *mut FLAC__StreamMetadata,
2482 use_padding: FLAC__bool,
2483 ) -> FLAC__bool;
2484}
2485extern "C" {
2486 pub fn FLAC__metadata_simple_iterator_insert_block_after(
2487 iterator: *mut FLAC__Metadata_SimpleIterator,
2488 block: *mut FLAC__StreamMetadata,
2489 use_padding: FLAC__bool,
2490 ) -> FLAC__bool;
2491}
2492extern "C" {
2493 pub fn FLAC__metadata_simple_iterator_delete_block(
2494 iterator: *mut FLAC__Metadata_SimpleIterator,
2495 use_padding: FLAC__bool,
2496 ) -> FLAC__bool;
2497}
2498#[repr(C)]
2499#[derive(Debug, Copy, Clone)]
2500pub struct FLAC__Metadata_Chain {
2501 _unused: [u8; 0],
2502}
2503#[repr(C)]
2504#[derive(Debug, Copy, Clone)]
2505pub struct FLAC__Metadata_Iterator {
2506 _unused: [u8; 0],
2507}
2508pub const FLAC__METADATA_CHAIN_STATUS_OK: FLAC__Metadata_ChainStatus = 0;
2509pub const FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT: FLAC__Metadata_ChainStatus = 1;
2510pub const FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE: FLAC__Metadata_ChainStatus = 2;
2511pub const FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE: FLAC__Metadata_ChainStatus = 3;
2512pub const FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE: FLAC__Metadata_ChainStatus = 4;
2513pub const FLAC__METADATA_CHAIN_STATUS_BAD_METADATA: FLAC__Metadata_ChainStatus = 5;
2514pub const FLAC__METADATA_CHAIN_STATUS_READ_ERROR: FLAC__Metadata_ChainStatus = 6;
2515pub const FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR: FLAC__Metadata_ChainStatus = 7;
2516pub const FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR: FLAC__Metadata_ChainStatus = 8;
2517pub const FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR: FLAC__Metadata_ChainStatus = 9;
2518pub const FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR: FLAC__Metadata_ChainStatus = 10;
2519pub const FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR: FLAC__Metadata_ChainStatus = 11;
2520pub const FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR: FLAC__Metadata_ChainStatus = 12;
2521pub const FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS: FLAC__Metadata_ChainStatus = 13;
2522pub const FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH: FLAC__Metadata_ChainStatus = 14;
2523pub const FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL: FLAC__Metadata_ChainStatus = 15;
2524pub type FLAC__Metadata_ChainStatus = libc::c_uint;
2525extern "C" {
2526 pub static FLAC__Metadata_ChainStatusString: [*const libc::c_char; 0usize];
2527}
2528extern "C" {
2529 pub fn FLAC__metadata_chain_new() -> *mut FLAC__Metadata_Chain;
2530}
2531extern "C" {
2532 pub fn FLAC__metadata_chain_delete(chain: *mut FLAC__Metadata_Chain);
2533}
2534extern "C" {
2535 pub fn FLAC__metadata_chain_status(
2536 chain: *mut FLAC__Metadata_Chain,
2537 ) -> FLAC__Metadata_ChainStatus;
2538}
2539extern "C" {
2540 pub fn FLAC__metadata_chain_read(
2541 chain: *mut FLAC__Metadata_Chain,
2542 filename: *const libc::c_char,
2543 ) -> FLAC__bool;
2544}
2545extern "C" {
2546 pub fn FLAC__metadata_chain_read_ogg(
2547 chain: *mut FLAC__Metadata_Chain,
2548 filename: *const libc::c_char,
2549 ) -> FLAC__bool;
2550}
2551extern "C" {
2552 pub fn FLAC__metadata_chain_read_with_callbacks(
2553 chain: *mut FLAC__Metadata_Chain,
2554 handle: FLAC__IOHandle,
2555 callbacks: FLAC__IOCallbacks,
2556 ) -> FLAC__bool;
2557}
2558extern "C" {
2559 pub fn FLAC__metadata_chain_read_ogg_with_callbacks(
2560 chain: *mut FLAC__Metadata_Chain,
2561 handle: FLAC__IOHandle,
2562 callbacks: FLAC__IOCallbacks,
2563 ) -> FLAC__bool;
2564}
2565extern "C" {
2566 pub fn FLAC__metadata_chain_check_if_tempfile_needed(
2567 chain: *mut FLAC__Metadata_Chain,
2568 use_padding: FLAC__bool,
2569 ) -> FLAC__bool;
2570}
2571extern "C" {
2572 pub fn FLAC__metadata_chain_write(
2573 chain: *mut FLAC__Metadata_Chain,
2574 use_padding: FLAC__bool,
2575 preserve_file_stats: FLAC__bool,
2576 ) -> FLAC__bool;
2577}
2578extern "C" {
2579 pub fn FLAC__metadata_chain_write_with_callbacks(
2580 chain: *mut FLAC__Metadata_Chain,
2581 use_padding: FLAC__bool,
2582 handle: FLAC__IOHandle,
2583 callbacks: FLAC__IOCallbacks,
2584 ) -> FLAC__bool;
2585}
2586extern "C" {
2587 pub fn FLAC__metadata_chain_write_with_callbacks_and_tempfile(
2588 chain: *mut FLAC__Metadata_Chain,
2589 use_padding: FLAC__bool,
2590 handle: FLAC__IOHandle,
2591 callbacks: FLAC__IOCallbacks,
2592 temp_handle: FLAC__IOHandle,
2593 temp_callbacks: FLAC__IOCallbacks,
2594 ) -> FLAC__bool;
2595}
2596extern "C" {
2597 pub fn FLAC__metadata_chain_merge_padding(chain: *mut FLAC__Metadata_Chain);
2598}
2599extern "C" {
2600 pub fn FLAC__metadata_chain_sort_padding(chain: *mut FLAC__Metadata_Chain);
2601}
2602extern "C" {
2603 pub fn FLAC__metadata_iterator_new() -> *mut FLAC__Metadata_Iterator;
2604}
2605extern "C" {
2606 pub fn FLAC__metadata_iterator_delete(iterator: *mut FLAC__Metadata_Iterator);
2607}
2608extern "C" {
2609 pub fn FLAC__metadata_iterator_init(
2610 iterator: *mut FLAC__Metadata_Iterator,
2611 chain: *mut FLAC__Metadata_Chain,
2612 );
2613}
2614extern "C" {
2615 pub fn FLAC__metadata_iterator_next(iterator: *mut FLAC__Metadata_Iterator) -> FLAC__bool;
2616}
2617extern "C" {
2618 pub fn FLAC__metadata_iterator_prev(iterator: *mut FLAC__Metadata_Iterator) -> FLAC__bool;
2619}
2620extern "C" {
2621 pub fn FLAC__metadata_iterator_get_block_type(
2622 iterator: *const FLAC__Metadata_Iterator,
2623 ) -> FLAC__MetadataType;
2624}
2625extern "C" {
2626 pub fn FLAC__metadata_iterator_get_block(
2627 iterator: *mut FLAC__Metadata_Iterator,
2628 ) -> *mut FLAC__StreamMetadata;
2629}
2630extern "C" {
2631 pub fn FLAC__metadata_iterator_set_block(
2632 iterator: *mut FLAC__Metadata_Iterator,
2633 block: *mut FLAC__StreamMetadata,
2634 ) -> FLAC__bool;
2635}
2636extern "C" {
2637 pub fn FLAC__metadata_iterator_delete_block(
2638 iterator: *mut FLAC__Metadata_Iterator,
2639 replace_with_padding: FLAC__bool,
2640 ) -> FLAC__bool;
2641}
2642extern "C" {
2643 pub fn FLAC__metadata_iterator_insert_block_before(
2644 iterator: *mut FLAC__Metadata_Iterator,
2645 block: *mut FLAC__StreamMetadata,
2646 ) -> FLAC__bool;
2647}
2648extern "C" {
2649 pub fn FLAC__metadata_iterator_insert_block_after(
2650 iterator: *mut FLAC__Metadata_Iterator,
2651 block: *mut FLAC__StreamMetadata,
2652 ) -> FLAC__bool;
2653}
2654extern "C" {
2655 pub fn FLAC__metadata_object_new(type_: FLAC__MetadataType) -> *mut FLAC__StreamMetadata;
2656}
2657extern "C" {
2658 pub fn FLAC__metadata_object_clone(
2659 object: *const FLAC__StreamMetadata,
2660 ) -> *mut FLAC__StreamMetadata;
2661}
2662extern "C" {
2663 pub fn FLAC__metadata_object_delete(object: *mut FLAC__StreamMetadata);
2664}
2665extern "C" {
2666 pub fn FLAC__metadata_object_is_equal(
2667 block1: *const FLAC__StreamMetadata,
2668 block2: *const FLAC__StreamMetadata,
2669 ) -> FLAC__bool;
2670}
2671extern "C" {
2672 pub fn FLAC__metadata_object_application_set_data(
2673 object: *mut FLAC__StreamMetadata,
2674 data: *mut FLAC__byte,
2675 length: u32,
2676 copy: FLAC__bool,
2677 ) -> FLAC__bool;
2678}
2679extern "C" {
2680 pub fn FLAC__metadata_object_seektable_resize_points(
2681 object: *mut FLAC__StreamMetadata,
2682 new_num_points: u32,
2683 ) -> FLAC__bool;
2684}
2685extern "C" {
2686 pub fn FLAC__metadata_object_seektable_set_point(
2687 object: *mut FLAC__StreamMetadata,
2688 point_num: u32,
2689 point: FLAC__StreamMetadata_SeekPoint,
2690 );
2691}
2692extern "C" {
2693 pub fn FLAC__metadata_object_seektable_insert_point(
2694 object: *mut FLAC__StreamMetadata,
2695 point_num: u32,
2696 point: FLAC__StreamMetadata_SeekPoint,
2697 ) -> FLAC__bool;
2698}
2699extern "C" {
2700 pub fn FLAC__metadata_object_seektable_delete_point(
2701 object: *mut FLAC__StreamMetadata,
2702 point_num: u32,
2703 ) -> FLAC__bool;
2704}
2705extern "C" {
2706 pub fn FLAC__metadata_object_seektable_is_legal(
2707 object: *const FLAC__StreamMetadata,
2708 ) -> FLAC__bool;
2709}
2710extern "C" {
2711 pub fn FLAC__metadata_object_seektable_template_append_placeholders(
2712 object: *mut FLAC__StreamMetadata,
2713 num: u32,
2714 ) -> FLAC__bool;
2715}
2716extern "C" {
2717 pub fn FLAC__metadata_object_seektable_template_append_point(
2718 object: *mut FLAC__StreamMetadata,
2719 sample_number: FLAC__uint64,
2720 ) -> FLAC__bool;
2721}
2722extern "C" {
2723 pub fn FLAC__metadata_object_seektable_template_append_points(
2724 object: *mut FLAC__StreamMetadata,
2725 sample_numbers: *mut FLAC__uint64,
2726 num: u32,
2727 ) -> FLAC__bool;
2728}
2729extern "C" {
2730 pub fn FLAC__metadata_object_seektable_template_append_spaced_points(
2731 object: *mut FLAC__StreamMetadata,
2732 num: u32,
2733 total_samples: FLAC__uint64,
2734 ) -> FLAC__bool;
2735}
2736extern "C" {
2737 pub fn FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(
2738 object: *mut FLAC__StreamMetadata,
2739 samples: u32,
2740 total_samples: FLAC__uint64,
2741 ) -> FLAC__bool;
2742}
2743extern "C" {
2744 pub fn FLAC__metadata_object_seektable_template_sort(
2745 object: *mut FLAC__StreamMetadata,
2746 compact: FLAC__bool,
2747 ) -> FLAC__bool;
2748}
2749extern "C" {
2750 pub fn FLAC__metadata_object_vorbiscomment_set_vendor_string(
2751 object: *mut FLAC__StreamMetadata,
2752 entry: FLAC__StreamMetadata_VorbisComment_Entry,
2753 copy: FLAC__bool,
2754 ) -> FLAC__bool;
2755}
2756extern "C" {
2757 pub fn FLAC__metadata_object_vorbiscomment_resize_comments(
2758 object: *mut FLAC__StreamMetadata,
2759 new_num_comments: u32,
2760 ) -> FLAC__bool;
2761}
2762extern "C" {
2763 pub fn FLAC__metadata_object_vorbiscomment_set_comment(
2764 object: *mut FLAC__StreamMetadata,
2765 comment_num: u32,
2766 entry: FLAC__StreamMetadata_VorbisComment_Entry,
2767 copy: FLAC__bool,
2768 ) -> FLAC__bool;
2769}
2770extern "C" {
2771 pub fn FLAC__metadata_object_vorbiscomment_insert_comment(
2772 object: *mut FLAC__StreamMetadata,
2773 comment_num: u32,
2774 entry: FLAC__StreamMetadata_VorbisComment_Entry,
2775 copy: FLAC__bool,
2776 ) -> FLAC__bool;
2777}
2778extern "C" {
2779 pub fn FLAC__metadata_object_vorbiscomment_append_comment(
2780 object: *mut FLAC__StreamMetadata,
2781 entry: FLAC__StreamMetadata_VorbisComment_Entry,
2782 copy: FLAC__bool,
2783 ) -> FLAC__bool;
2784}
2785extern "C" {
2786 pub fn FLAC__metadata_object_vorbiscomment_replace_comment(
2787 object: *mut FLAC__StreamMetadata,
2788 entry: FLAC__StreamMetadata_VorbisComment_Entry,
2789 all: FLAC__bool,
2790 copy: FLAC__bool,
2791 ) -> FLAC__bool;
2792}
2793extern "C" {
2794 pub fn FLAC__metadata_object_vorbiscomment_delete_comment(
2795 object: *mut FLAC__StreamMetadata,
2796 comment_num: u32,
2797 ) -> FLAC__bool;
2798}
2799extern "C" {
2800 pub fn FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(
2801 entry: *mut FLAC__StreamMetadata_VorbisComment_Entry,
2802 field_name: *const libc::c_char,
2803 field_value: *const libc::c_char,
2804 ) -> FLAC__bool;
2805}
2806extern "C" {
2807 pub fn FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(
2808 entry: FLAC__StreamMetadata_VorbisComment_Entry,
2809 field_name: *mut *mut libc::c_char,
2810 field_value: *mut *mut libc::c_char,
2811 ) -> FLAC__bool;
2812}
2813extern "C" {
2814 pub fn FLAC__metadata_object_vorbiscomment_entry_matches(
2815 entry: FLAC__StreamMetadata_VorbisComment_Entry,
2816 field_name: *const libc::c_char,
2817 field_name_length: u32,
2818 ) -> FLAC__bool;
2819}
2820extern "C" {
2821 pub fn FLAC__metadata_object_vorbiscomment_find_entry_from(
2822 object: *const FLAC__StreamMetadata,
2823 offset: u32,
2824 field_name: *const libc::c_char,
2825 ) -> libc::c_int;
2826}
2827extern "C" {
2828 pub fn FLAC__metadata_object_vorbiscomment_remove_entry_matching(
2829 object: *mut FLAC__StreamMetadata,
2830 field_name: *const libc::c_char,
2831 ) -> libc::c_int;
2832}
2833extern "C" {
2834 pub fn FLAC__metadata_object_vorbiscomment_remove_entries_matching(
2835 object: *mut FLAC__StreamMetadata,
2836 field_name: *const libc::c_char,
2837 ) -> libc::c_int;
2838}
2839extern "C" {
2840 pub fn FLAC__metadata_object_cuesheet_track_new() -> *mut FLAC__StreamMetadata_CueSheet_Track;
2841}
2842extern "C" {
2843 pub fn FLAC__metadata_object_cuesheet_track_clone(
2844 object: *const FLAC__StreamMetadata_CueSheet_Track,
2845 ) -> *mut FLAC__StreamMetadata_CueSheet_Track;
2846}
2847extern "C" {
2848 pub fn FLAC__metadata_object_cuesheet_track_delete(
2849 object: *mut FLAC__StreamMetadata_CueSheet_Track,
2850 );
2851}
2852extern "C" {
2853 pub fn FLAC__metadata_object_cuesheet_track_resize_indices(
2854 object: *mut FLAC__StreamMetadata,
2855 track_num: u32,
2856 new_num_indices: u32,
2857 ) -> FLAC__bool;
2858}
2859extern "C" {
2860 pub fn FLAC__metadata_object_cuesheet_track_insert_index(
2861 object: *mut FLAC__StreamMetadata,
2862 track_num: u32,
2863 index_num: u32,
2864 index: FLAC__StreamMetadata_CueSheet_Index,
2865 ) -> FLAC__bool;
2866}
2867extern "C" {
2868 pub fn FLAC__metadata_object_cuesheet_track_insert_blank_index(
2869 object: *mut FLAC__StreamMetadata,
2870 track_num: u32,
2871 index_num: u32,
2872 ) -> FLAC__bool;
2873}
2874extern "C" {
2875 pub fn FLAC__metadata_object_cuesheet_track_delete_index(
2876 object: *mut FLAC__StreamMetadata,
2877 track_num: u32,
2878 index_num: u32,
2879 ) -> FLAC__bool;
2880}
2881extern "C" {
2882 pub fn FLAC__metadata_object_cuesheet_resize_tracks(
2883 object: *mut FLAC__StreamMetadata,
2884 new_num_tracks: u32,
2885 ) -> FLAC__bool;
2886}
2887extern "C" {
2888 pub fn FLAC__metadata_object_cuesheet_set_track(
2889 object: *mut FLAC__StreamMetadata,
2890 track_num: u32,
2891 track: *mut FLAC__StreamMetadata_CueSheet_Track,
2892 copy: FLAC__bool,
2893 ) -> FLAC__bool;
2894}
2895extern "C" {
2896 pub fn FLAC__metadata_object_cuesheet_insert_track(
2897 object: *mut FLAC__StreamMetadata,
2898 track_num: u32,
2899 track: *mut FLAC__StreamMetadata_CueSheet_Track,
2900 copy: FLAC__bool,
2901 ) -> FLAC__bool;
2902}
2903extern "C" {
2904 pub fn FLAC__metadata_object_cuesheet_insert_blank_track(
2905 object: *mut FLAC__StreamMetadata,
2906 track_num: u32,
2907 ) -> FLAC__bool;
2908}
2909extern "C" {
2910 pub fn FLAC__metadata_object_cuesheet_delete_track(
2911 object: *mut FLAC__StreamMetadata,
2912 track_num: u32,
2913 ) -> FLAC__bool;
2914}
2915extern "C" {
2916 pub fn FLAC__metadata_object_cuesheet_is_legal(
2917 object: *const FLAC__StreamMetadata,
2918 check_cd_da_subset: FLAC__bool,
2919 violation: *mut *const libc::c_char,
2920 ) -> FLAC__bool;
2921}
2922extern "C" {
2923 pub fn FLAC__metadata_object_cuesheet_calculate_cddb_id(
2924 object: *const FLAC__StreamMetadata,
2925 ) -> FLAC__uint32;
2926}
2927extern "C" {
2928 pub fn FLAC__metadata_object_picture_set_mime_type(
2929 object: *mut FLAC__StreamMetadata,
2930 mime_type: *mut libc::c_char,
2931 copy: FLAC__bool,
2932 ) -> FLAC__bool;
2933}
2934extern "C" {
2935 pub fn FLAC__metadata_object_picture_set_description(
2936 object: *mut FLAC__StreamMetadata,
2937 description: *mut FLAC__byte,
2938 copy: FLAC__bool,
2939 ) -> FLAC__bool;
2940}
2941extern "C" {
2942 pub fn FLAC__metadata_object_picture_set_data(
2943 object: *mut FLAC__StreamMetadata,
2944 data: *mut FLAC__byte,
2945 length: FLAC__uint32,
2946 copy: FLAC__bool,
2947 ) -> FLAC__bool;
2948}
2949extern "C" {
2950 pub fn FLAC__metadata_object_picture_is_legal(
2951 object: *const FLAC__StreamMetadata,
2952 violation: *mut *const libc::c_char,
2953 ) -> FLAC__bool;
2954}
2955extern "C" {
2956 pub fn FLAC__metadata_object_get_raw(object: *const FLAC__StreamMetadata) -> *mut FLAC__byte;
2957}
2958extern "C" {
2959 pub fn FLAC__metadata_object_set_raw(
2960 buffer: *mut FLAC__byte,
2961 length: FLAC__uint32,
2962 ) -> *mut FLAC__StreamMetadata;
2963}
2964pub const FLAC__STREAM_DECODER_SEARCH_FOR_METADATA: FLAC__StreamDecoderState = 0;
2965pub const FLAC__STREAM_DECODER_READ_METADATA: FLAC__StreamDecoderState = 1;
2966pub const FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC: FLAC__StreamDecoderState = 2;
2967pub const FLAC__STREAM_DECODER_READ_FRAME: FLAC__StreamDecoderState = 3;
2968pub const FLAC__STREAM_DECODER_END_OF_STREAM: FLAC__StreamDecoderState = 4;
2969pub const FLAC__STREAM_DECODER_OGG_ERROR: FLAC__StreamDecoderState = 5;
2970pub const FLAC__STREAM_DECODER_SEEK_ERROR: FLAC__StreamDecoderState = 6;
2971pub const FLAC__STREAM_DECODER_ABORTED: FLAC__StreamDecoderState = 7;
2972pub const FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR: FLAC__StreamDecoderState = 8;
2973pub const FLAC__STREAM_DECODER_UNINITIALIZED: FLAC__StreamDecoderState = 9;
2974pub type FLAC__StreamDecoderState = libc::c_uint;
2975extern "C" {
2976 pub static FLAC__StreamDecoderStateString: [*const libc::c_char; 0usize];
2977}
2978pub const FLAC__STREAM_DECODER_INIT_STATUS_OK: FLAC__StreamDecoderInitStatus = 0;
2979pub const FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER: FLAC__StreamDecoderInitStatus = 1;
2980pub const FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS: FLAC__StreamDecoderInitStatus = 2;
2981pub const FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR: FLAC__StreamDecoderInitStatus =
2982 3;
2983pub const FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE: FLAC__StreamDecoderInitStatus = 4;
2984pub const FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED: FLAC__StreamDecoderInitStatus = 5;
2985pub type FLAC__StreamDecoderInitStatus = libc::c_uint;
2986extern "C" {
2987 pub static FLAC__StreamDecoderInitStatusString: [*const libc::c_char; 0usize];
2988}
2989pub const FLAC__STREAM_DECODER_READ_STATUS_CONTINUE: FLAC__StreamDecoderReadStatus = 0;
2990pub const FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM: FLAC__StreamDecoderReadStatus = 1;
2991pub const FLAC__STREAM_DECODER_READ_STATUS_ABORT: FLAC__StreamDecoderReadStatus = 2;
2992pub type FLAC__StreamDecoderReadStatus = libc::c_uint;
2993extern "C" {
2994 pub static FLAC__StreamDecoderReadStatusString: [*const libc::c_char; 0usize];
2995}
2996pub const FLAC__STREAM_DECODER_SEEK_STATUS_OK: FLAC__StreamDecoderSeekStatus = 0;
2997pub const FLAC__STREAM_DECODER_SEEK_STATUS_ERROR: FLAC__StreamDecoderSeekStatus = 1;
2998pub const FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED: FLAC__StreamDecoderSeekStatus = 2;
2999pub type FLAC__StreamDecoderSeekStatus = libc::c_uint;
3000extern "C" {
3001 pub static FLAC__StreamDecoderSeekStatusString: [*const libc::c_char; 0usize];
3002}
3003pub const FLAC__STREAM_DECODER_TELL_STATUS_OK: FLAC__StreamDecoderTellStatus = 0;
3004pub const FLAC__STREAM_DECODER_TELL_STATUS_ERROR: FLAC__StreamDecoderTellStatus = 1;
3005pub const FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED: FLAC__StreamDecoderTellStatus = 2;
3006pub type FLAC__StreamDecoderTellStatus = libc::c_uint;
3007extern "C" {
3008 pub static FLAC__StreamDecoderTellStatusString: [*const libc::c_char; 0usize];
3009}
3010pub const FLAC__STREAM_DECODER_LENGTH_STATUS_OK: FLAC__StreamDecoderLengthStatus = 0;
3011pub const FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR: FLAC__StreamDecoderLengthStatus = 1;
3012pub const FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED: FLAC__StreamDecoderLengthStatus = 2;
3013pub type FLAC__StreamDecoderLengthStatus = libc::c_uint;
3014extern "C" {
3015 pub static FLAC__StreamDecoderLengthStatusString: [*const libc::c_char; 0usize];
3016}
3017pub const FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE: FLAC__StreamDecoderWriteStatus = 0;
3018pub const FLAC__STREAM_DECODER_WRITE_STATUS_ABORT: FLAC__StreamDecoderWriteStatus = 1;
3019pub type FLAC__StreamDecoderWriteStatus = libc::c_uint;
3020extern "C" {
3021 pub static FLAC__StreamDecoderWriteStatusString: [*const libc::c_char; 0usize];
3022}
3023pub const FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC: FLAC__StreamDecoderErrorStatus = 0;
3024pub const FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER: FLAC__StreamDecoderErrorStatus = 1;
3025pub const FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH: FLAC__StreamDecoderErrorStatus = 2;
3026pub const FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM: FLAC__StreamDecoderErrorStatus = 3;
3027pub const FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA: FLAC__StreamDecoderErrorStatus = 4;
3028pub type FLAC__StreamDecoderErrorStatus = libc::c_uint;
3029extern "C" {
3030 pub static FLAC__StreamDecoderErrorStatusString: [*const libc::c_char; 0usize];
3031}
3032#[repr(C)]
3033#[derive(Debug, Copy, Clone)]
3034pub struct FLAC__StreamDecoderProtected {
3035 _unused: [u8; 0],
3036}
3037#[repr(C)]
3038#[derive(Debug, Copy, Clone)]
3039pub struct FLAC__StreamDecoderPrivate {
3040 _unused: [u8; 0],
3041}
3042#[repr(C)]
3043#[derive(Debug, Copy, Clone)]
3044pub struct FLAC__StreamDecoder {
3045 pub protected_: *mut FLAC__StreamDecoderProtected,
3046 pub private_: *mut FLAC__StreamDecoderPrivate,
3047}
3048#[test]
3049fn bindgen_test_layout_FLAC__StreamDecoder() {
3050 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamDecoder> =
3051 ::core::mem::MaybeUninit::uninit();
3052 let ptr = UNINIT.as_ptr();
3053 assert_eq!(
3054 ::core::mem::size_of::<FLAC__StreamDecoder>(),
3055 16usize,
3056 concat!("Size of: ", stringify!(FLAC__StreamDecoder))
3057 );
3058 assert_eq!(
3059 ::core::mem::align_of::<FLAC__StreamDecoder>(),
3060 8usize,
3061 concat!("Alignment of ", stringify!(FLAC__StreamDecoder))
3062 );
3063 assert_eq!(
3064 unsafe { ::core::ptr::addr_of!((*ptr).protected_) as usize - ptr as usize },
3065 0usize,
3066 concat!(
3067 "Offset of field: ",
3068 stringify!(FLAC__StreamDecoder),
3069 "::",
3070 stringify!(protected_)
3071 )
3072 );
3073 assert_eq!(
3074 unsafe { ::core::ptr::addr_of!((*ptr).private_) as usize - ptr as usize },
3075 8usize,
3076 concat!(
3077 "Offset of field: ",
3078 stringify!(FLAC__StreamDecoder),
3079 "::",
3080 stringify!(private_)
3081 )
3082 );
3083}
3084pub type FLAC__StreamDecoderReadCallback = ::core::option::Option<
3085 unsafe extern "C" fn(
3086 decoder: *const FLAC__StreamDecoder,
3087 buffer: *mut FLAC__byte,
3088 bytes: *mut usize,
3089 client_data: *mut libc::c_void,
3090 ) -> FLAC__StreamDecoderReadStatus,
3091>;
3092pub type FLAC__StreamDecoderSeekCallback = ::core::option::Option<
3093 unsafe extern "C" fn(
3094 decoder: *const FLAC__StreamDecoder,
3095 absolute_byte_offset: FLAC__uint64,
3096 client_data: *mut libc::c_void,
3097 ) -> FLAC__StreamDecoderSeekStatus,
3098>;
3099pub type FLAC__StreamDecoderTellCallback = ::core::option::Option<
3100 unsafe extern "C" fn(
3101 decoder: *const FLAC__StreamDecoder,
3102 absolute_byte_offset: *mut FLAC__uint64,
3103 client_data: *mut libc::c_void,
3104 ) -> FLAC__StreamDecoderTellStatus,
3105>;
3106pub type FLAC__StreamDecoderLengthCallback = ::core::option::Option<
3107 unsafe extern "C" fn(
3108 decoder: *const FLAC__StreamDecoder,
3109 stream_length: *mut FLAC__uint64,
3110 client_data: *mut libc::c_void,
3111 ) -> FLAC__StreamDecoderLengthStatus,
3112>;
3113pub type FLAC__StreamDecoderEofCallback = ::core::option::Option<
3114 unsafe extern "C" fn(
3115 decoder: *const FLAC__StreamDecoder,
3116 client_data: *mut libc::c_void,
3117 ) -> FLAC__bool,
3118>;
3119pub type FLAC__StreamDecoderWriteCallback = ::core::option::Option<
3120 unsafe extern "C" fn(
3121 decoder: *const FLAC__StreamDecoder,
3122 frame: *const FLAC__Frame,
3123 buffer: *const *const FLAC__int32,
3124 client_data: *mut libc::c_void,
3125 ) -> FLAC__StreamDecoderWriteStatus,
3126>;
3127pub type FLAC__StreamDecoderMetadataCallback = ::core::option::Option<
3128 unsafe extern "C" fn(
3129 decoder: *const FLAC__StreamDecoder,
3130 metadata: *const FLAC__StreamMetadata,
3131 client_data: *mut libc::c_void,
3132 ),
3133>;
3134pub type FLAC__StreamDecoderErrorCallback = ::core::option::Option<
3135 unsafe extern "C" fn(
3136 decoder: *const FLAC__StreamDecoder,
3137 status: FLAC__StreamDecoderErrorStatus,
3138 client_data: *mut libc::c_void,
3139 ),
3140>;
3141extern "C" {
3142 pub fn FLAC__stream_decoder_new() -> *mut FLAC__StreamDecoder;
3143}
3144extern "C" {
3145 pub fn FLAC__stream_decoder_delete(decoder: *mut FLAC__StreamDecoder);
3146}
3147extern "C" {
3148 pub fn FLAC__stream_decoder_set_ogg_serial_number(
3149 decoder: *mut FLAC__StreamDecoder,
3150 serial_number: libc::c_long,
3151 ) -> FLAC__bool;
3152}
3153extern "C" {
3154 pub fn FLAC__stream_decoder_set_md5_checking(
3155 decoder: *mut FLAC__StreamDecoder,
3156 value: FLAC__bool,
3157 ) -> FLAC__bool;
3158}
3159extern "C" {
3160 pub fn FLAC__stream_decoder_set_metadata_respond(
3161 decoder: *mut FLAC__StreamDecoder,
3162 type_: FLAC__MetadataType,
3163 ) -> FLAC__bool;
3164}
3165extern "C" {
3166 pub fn FLAC__stream_decoder_set_metadata_respond_application(
3167 decoder: *mut FLAC__StreamDecoder,
3168 id: *const FLAC__byte,
3169 ) -> FLAC__bool;
3170}
3171extern "C" {
3172 pub fn FLAC__stream_decoder_set_metadata_respond_all(
3173 decoder: *mut FLAC__StreamDecoder,
3174 ) -> FLAC__bool;
3175}
3176extern "C" {
3177 pub fn FLAC__stream_decoder_set_metadata_ignore(
3178 decoder: *mut FLAC__StreamDecoder,
3179 type_: FLAC__MetadataType,
3180 ) -> FLAC__bool;
3181}
3182extern "C" {
3183 pub fn FLAC__stream_decoder_set_metadata_ignore_application(
3184 decoder: *mut FLAC__StreamDecoder,
3185 id: *const FLAC__byte,
3186 ) -> FLAC__bool;
3187}
3188extern "C" {
3189 pub fn FLAC__stream_decoder_set_metadata_ignore_all(
3190 decoder: *mut FLAC__StreamDecoder,
3191 ) -> FLAC__bool;
3192}
3193extern "C" {
3194 pub fn FLAC__stream_decoder_get_state(
3195 decoder: *const FLAC__StreamDecoder,
3196 ) -> FLAC__StreamDecoderState;
3197}
3198extern "C" {
3199 pub fn FLAC__stream_decoder_get_resolved_state_string(
3200 decoder: *const FLAC__StreamDecoder,
3201 ) -> *const libc::c_char;
3202}
3203extern "C" {
3204 pub fn FLAC__stream_decoder_get_md5_checking(decoder: *const FLAC__StreamDecoder)
3205 -> FLAC__bool;
3206}
3207extern "C" {
3208 pub fn FLAC__stream_decoder_get_total_samples(
3209 decoder: *const FLAC__StreamDecoder,
3210 ) -> FLAC__uint64;
3211}
3212extern "C" {
3213 pub fn FLAC__stream_decoder_get_channels(decoder: *const FLAC__StreamDecoder) -> u32;
3214}
3215extern "C" {
3216 pub fn FLAC__stream_decoder_get_channel_assignment(
3217 decoder: *const FLAC__StreamDecoder,
3218 ) -> FLAC__ChannelAssignment;
3219}
3220extern "C" {
3221 pub fn FLAC__stream_decoder_get_bits_per_sample(decoder: *const FLAC__StreamDecoder) -> u32;
3222}
3223extern "C" {
3224 pub fn FLAC__stream_decoder_get_sample_rate(decoder: *const FLAC__StreamDecoder) -> u32;
3225}
3226extern "C" {
3227 pub fn FLAC__stream_decoder_get_blocksize(decoder: *const FLAC__StreamDecoder) -> u32;
3228}
3229extern "C" {
3230 pub fn FLAC__stream_decoder_get_decode_position(
3231 decoder: *const FLAC__StreamDecoder,
3232 position: *mut FLAC__uint64,
3233 ) -> FLAC__bool;
3234}
3235extern "C" {
3236 pub fn FLAC__stream_decoder_get_client_data(
3237 decoder: *mut FLAC__StreamDecoder,
3238 ) -> *const libc::c_void;
3239}
3240extern "C" {
3241 pub fn FLAC__stream_decoder_init_stream(
3242 decoder: *mut FLAC__StreamDecoder,
3243 read_callback: FLAC__StreamDecoderReadCallback,
3244 seek_callback: FLAC__StreamDecoderSeekCallback,
3245 tell_callback: FLAC__StreamDecoderTellCallback,
3246 length_callback: FLAC__StreamDecoderLengthCallback,
3247 eof_callback: FLAC__StreamDecoderEofCallback,
3248 write_callback: FLAC__StreamDecoderWriteCallback,
3249 metadata_callback: FLAC__StreamDecoderMetadataCallback,
3250 error_callback: FLAC__StreamDecoderErrorCallback,
3251 client_data: *mut libc::c_void,
3252 ) -> FLAC__StreamDecoderInitStatus;
3253}
3254extern "C" {
3255 pub fn FLAC__stream_decoder_init_ogg_stream(
3256 decoder: *mut FLAC__StreamDecoder,
3257 read_callback: FLAC__StreamDecoderReadCallback,
3258 seek_callback: FLAC__StreamDecoderSeekCallback,
3259 tell_callback: FLAC__StreamDecoderTellCallback,
3260 length_callback: FLAC__StreamDecoderLengthCallback,
3261 eof_callback: FLAC__StreamDecoderEofCallback,
3262 write_callback: FLAC__StreamDecoderWriteCallback,
3263 metadata_callback: FLAC__StreamDecoderMetadataCallback,
3264 error_callback: FLAC__StreamDecoderErrorCallback,
3265 client_data: *mut libc::c_void,
3266 ) -> FLAC__StreamDecoderInitStatus;
3267}
3268extern "C" {
3269 pub fn FLAC__stream_decoder_init_FILE(
3270 decoder: *mut FLAC__StreamDecoder,
3271 file: *mut FILE,
3272 write_callback: FLAC__StreamDecoderWriteCallback,
3273 metadata_callback: FLAC__StreamDecoderMetadataCallback,
3274 error_callback: FLAC__StreamDecoderErrorCallback,
3275 client_data: *mut libc::c_void,
3276 ) -> FLAC__StreamDecoderInitStatus;
3277}
3278extern "C" {
3279 pub fn FLAC__stream_decoder_init_ogg_FILE(
3280 decoder: *mut FLAC__StreamDecoder,
3281 file: *mut FILE,
3282 write_callback: FLAC__StreamDecoderWriteCallback,
3283 metadata_callback: FLAC__StreamDecoderMetadataCallback,
3284 error_callback: FLAC__StreamDecoderErrorCallback,
3285 client_data: *mut libc::c_void,
3286 ) -> FLAC__StreamDecoderInitStatus;
3287}
3288extern "C" {
3289 pub fn FLAC__stream_decoder_init_file(
3290 decoder: *mut FLAC__StreamDecoder,
3291 filename: *const libc::c_char,
3292 write_callback: FLAC__StreamDecoderWriteCallback,
3293 metadata_callback: FLAC__StreamDecoderMetadataCallback,
3294 error_callback: FLAC__StreamDecoderErrorCallback,
3295 client_data: *mut libc::c_void,
3296 ) -> FLAC__StreamDecoderInitStatus;
3297}
3298extern "C" {
3299 pub fn FLAC__stream_decoder_init_ogg_file(
3300 decoder: *mut FLAC__StreamDecoder,
3301 filename: *const libc::c_char,
3302 write_callback: FLAC__StreamDecoderWriteCallback,
3303 metadata_callback: FLAC__StreamDecoderMetadataCallback,
3304 error_callback: FLAC__StreamDecoderErrorCallback,
3305 client_data: *mut libc::c_void,
3306 ) -> FLAC__StreamDecoderInitStatus;
3307}
3308extern "C" {
3309 pub fn FLAC__stream_decoder_finish(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
3310}
3311extern "C" {
3312 pub fn FLAC__stream_decoder_flush(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
3313}
3314extern "C" {
3315 pub fn FLAC__stream_decoder_reset(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
3316}
3317extern "C" {
3318 pub fn FLAC__stream_decoder_process_single(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
3319}
3320extern "C" {
3321 pub fn FLAC__stream_decoder_process_until_end_of_metadata(
3322 decoder: *mut FLAC__StreamDecoder,
3323 ) -> FLAC__bool;
3324}
3325extern "C" {
3326 pub fn FLAC__stream_decoder_process_until_end_of_stream(
3327 decoder: *mut FLAC__StreamDecoder,
3328 ) -> FLAC__bool;
3329}
3330extern "C" {
3331 pub fn FLAC__stream_decoder_skip_single_frame(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
3332}
3333extern "C" {
3334 pub fn FLAC__stream_decoder_seek_absolute(
3335 decoder: *mut FLAC__StreamDecoder,
3336 sample: FLAC__uint64,
3337 ) -> FLAC__bool;
3338}
3339pub const FLAC__STREAM_ENCODER_OK: FLAC__StreamEncoderState = 0;
3340pub const FLAC__STREAM_ENCODER_UNINITIALIZED: FLAC__StreamEncoderState = 1;
3341pub const FLAC__STREAM_ENCODER_OGG_ERROR: FLAC__StreamEncoderState = 2;
3342pub const FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR: FLAC__StreamEncoderState = 3;
3343pub const FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA: FLAC__StreamEncoderState = 4;
3344pub const FLAC__STREAM_ENCODER_CLIENT_ERROR: FLAC__StreamEncoderState = 5;
3345pub const FLAC__STREAM_ENCODER_IO_ERROR: FLAC__StreamEncoderState = 6;
3346pub const FLAC__STREAM_ENCODER_FRAMING_ERROR: FLAC__StreamEncoderState = 7;
3347pub const FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR: FLAC__StreamEncoderState = 8;
3348pub type FLAC__StreamEncoderState = libc::c_uint;
3349extern "C" {
3350 pub static FLAC__StreamEncoderStateString: [*const libc::c_char; 0usize];
3351}
3352pub const FLAC__STREAM_ENCODER_INIT_STATUS_OK: FLAC__StreamEncoderInitStatus = 0;
3353pub const FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR: FLAC__StreamEncoderInitStatus = 1;
3354pub const FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER: FLAC__StreamEncoderInitStatus = 2;
3355pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS: FLAC__StreamEncoderInitStatus = 3;
3356pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS:
3357 FLAC__StreamEncoderInitStatus = 4;
3358pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE: FLAC__StreamEncoderInitStatus =
3359 5;
3360pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE: FLAC__StreamEncoderInitStatus = 6;
3361pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE: FLAC__StreamEncoderInitStatus = 7;
3362pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER: FLAC__StreamEncoderInitStatus = 8;
3363pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION:
3364 FLAC__StreamEncoderInitStatus = 9;
3365pub const FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER:
3366 FLAC__StreamEncoderInitStatus = 10;
3367pub const FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE: FLAC__StreamEncoderInitStatus = 11;
3368pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA: FLAC__StreamEncoderInitStatus = 12;
3369pub const FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED: FLAC__StreamEncoderInitStatus = 13;
3370pub type FLAC__StreamEncoderInitStatus = libc::c_uint;
3371extern "C" {
3372 pub static FLAC__StreamEncoderInitStatusString: [*const libc::c_char; 0usize];
3373}
3374pub const FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE: FLAC__StreamEncoderReadStatus = 0;
3375pub const FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM: FLAC__StreamEncoderReadStatus = 1;
3376pub const FLAC__STREAM_ENCODER_READ_STATUS_ABORT: FLAC__StreamEncoderReadStatus = 2;
3377pub const FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED: FLAC__StreamEncoderReadStatus = 3;
3378pub type FLAC__StreamEncoderReadStatus = libc::c_uint;
3379extern "C" {
3380 pub static FLAC__StreamEncoderReadStatusString: [*const libc::c_char; 0usize];
3381}
3382pub const FLAC__STREAM_ENCODER_WRITE_STATUS_OK: FLAC__StreamEncoderWriteStatus = 0;
3383pub const FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR: FLAC__StreamEncoderWriteStatus = 1;
3384pub type FLAC__StreamEncoderWriteStatus = libc::c_uint;
3385extern "C" {
3386 pub static FLAC__StreamEncoderWriteStatusString: [*const libc::c_char; 0usize];
3387}
3388pub const FLAC__STREAM_ENCODER_SEEK_STATUS_OK: FLAC__StreamEncoderSeekStatus = 0;
3389pub const FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR: FLAC__StreamEncoderSeekStatus = 1;
3390pub const FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED: FLAC__StreamEncoderSeekStatus = 2;
3391pub type FLAC__StreamEncoderSeekStatus = libc::c_uint;
3392extern "C" {
3393 pub static FLAC__StreamEncoderSeekStatusString: [*const libc::c_char; 0usize];
3394}
3395pub const FLAC__STREAM_ENCODER_TELL_STATUS_OK: FLAC__StreamEncoderTellStatus = 0;
3396pub const FLAC__STREAM_ENCODER_TELL_STATUS_ERROR: FLAC__StreamEncoderTellStatus = 1;
3397pub const FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED: FLAC__StreamEncoderTellStatus = 2;
3398pub type FLAC__StreamEncoderTellStatus = libc::c_uint;
3399extern "C" {
3400 pub static FLAC__StreamEncoderTellStatusString: [*const libc::c_char; 0usize];
3401}
3402#[repr(C)]
3403#[derive(Debug, Copy, Clone)]
3404pub struct FLAC__StreamEncoderProtected {
3405 _unused: [u8; 0],
3406}
3407#[repr(C)]
3408#[derive(Debug, Copy, Clone)]
3409pub struct FLAC__StreamEncoderPrivate {
3410 _unused: [u8; 0],
3411}
3412#[repr(C)]
3413#[derive(Debug, Copy, Clone)]
3414pub struct FLAC__StreamEncoder {
3415 pub protected_: *mut FLAC__StreamEncoderProtected,
3416 pub private_: *mut FLAC__StreamEncoderPrivate,
3417}
3418#[test]
3419fn bindgen_test_layout_FLAC__StreamEncoder() {
3420 const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamEncoder> =
3421 ::core::mem::MaybeUninit::uninit();
3422 let ptr = UNINIT.as_ptr();
3423 assert_eq!(
3424 ::core::mem::size_of::<FLAC__StreamEncoder>(),
3425 16usize,
3426 concat!("Size of: ", stringify!(FLAC__StreamEncoder))
3427 );
3428 assert_eq!(
3429 ::core::mem::align_of::<FLAC__StreamEncoder>(),
3430 8usize,
3431 concat!("Alignment of ", stringify!(FLAC__StreamEncoder))
3432 );
3433 assert_eq!(
3434 unsafe { ::core::ptr::addr_of!((*ptr).protected_) as usize - ptr as usize },
3435 0usize,
3436 concat!(
3437 "Offset of field: ",
3438 stringify!(FLAC__StreamEncoder),
3439 "::",
3440 stringify!(protected_)
3441 )
3442 );
3443 assert_eq!(
3444 unsafe { ::core::ptr::addr_of!((*ptr).private_) as usize - ptr as usize },
3445 8usize,
3446 concat!(
3447 "Offset of field: ",
3448 stringify!(FLAC__StreamEncoder),
3449 "::",
3450 stringify!(private_)
3451 )
3452 );
3453}
3454pub type FLAC__StreamEncoderReadCallback = ::core::option::Option<
3455 unsafe extern "C" fn(
3456 encoder: *const FLAC__StreamEncoder,
3457 buffer: *mut FLAC__byte,
3458 bytes: *mut usize,
3459 client_data: *mut libc::c_void,
3460 ) -> FLAC__StreamEncoderReadStatus,
3461>;
3462pub type FLAC__StreamEncoderWriteCallback = ::core::option::Option<
3463 unsafe extern "C" fn(
3464 encoder: *const FLAC__StreamEncoder,
3465 buffer: *const FLAC__byte,
3466 bytes: usize,
3467 samples: u32,
3468 current_frame: u32,
3469 client_data: *mut libc::c_void,
3470 ) -> FLAC__StreamEncoderWriteStatus,
3471>;
3472pub type FLAC__StreamEncoderSeekCallback = ::core::option::Option<
3473 unsafe extern "C" fn(
3474 encoder: *const FLAC__StreamEncoder,
3475 absolute_byte_offset: FLAC__uint64,
3476 client_data: *mut libc::c_void,
3477 ) -> FLAC__StreamEncoderSeekStatus,
3478>;
3479pub type FLAC__StreamEncoderTellCallback = ::core::option::Option<
3480 unsafe extern "C" fn(
3481 encoder: *const FLAC__StreamEncoder,
3482 absolute_byte_offset: *mut FLAC__uint64,
3483 client_data: *mut libc::c_void,
3484 ) -> FLAC__StreamEncoderTellStatus,
3485>;
3486pub type FLAC__StreamEncoderMetadataCallback = ::core::option::Option<
3487 unsafe extern "C" fn(
3488 encoder: *const FLAC__StreamEncoder,
3489 metadata: *const FLAC__StreamMetadata,
3490 client_data: *mut libc::c_void,
3491 ),
3492>;
3493pub type FLAC__StreamEncoderProgressCallback = ::core::option::Option<
3494 unsafe extern "C" fn(
3495 encoder: *const FLAC__StreamEncoder,
3496 bytes_written: FLAC__uint64,
3497 samples_written: FLAC__uint64,
3498 frames_written: u32,
3499 total_frames_estimate: u32,
3500 client_data: *mut libc::c_void,
3501 ),
3502>;
3503extern "C" {
3504 pub fn FLAC__stream_encoder_new() -> *mut FLAC__StreamEncoder;
3505}
3506extern "C" {
3507 pub fn FLAC__stream_encoder_delete(encoder: *mut FLAC__StreamEncoder);
3508}
3509extern "C" {
3510 pub fn FLAC__stream_encoder_set_ogg_serial_number(
3511 encoder: *mut FLAC__StreamEncoder,
3512 serial_number: libc::c_long,
3513 ) -> FLAC__bool;
3514}
3515extern "C" {
3516 pub fn FLAC__stream_encoder_set_verify(
3517 encoder: *mut FLAC__StreamEncoder,
3518 value: FLAC__bool,
3519 ) -> FLAC__bool;
3520}
3521extern "C" {
3522 pub fn FLAC__stream_encoder_set_streamable_subset(
3523 encoder: *mut FLAC__StreamEncoder,
3524 value: FLAC__bool,
3525 ) -> FLAC__bool;
3526}
3527extern "C" {
3528 pub fn FLAC__stream_encoder_set_channels(
3529 encoder: *mut FLAC__StreamEncoder,
3530 value: u32,
3531 ) -> FLAC__bool;
3532}
3533extern "C" {
3534 pub fn FLAC__stream_encoder_set_bits_per_sample(
3535 encoder: *mut FLAC__StreamEncoder,
3536 value: u32,
3537 ) -> FLAC__bool;
3538}
3539extern "C" {
3540 pub fn FLAC__stream_encoder_set_sample_rate(
3541 encoder: *mut FLAC__StreamEncoder,
3542 value: u32,
3543 ) -> FLAC__bool;
3544}
3545extern "C" {
3546 pub fn FLAC__stream_encoder_set_compression_level(
3547 encoder: *mut FLAC__StreamEncoder,
3548 value: u32,
3549 ) -> FLAC__bool;
3550}
3551extern "C" {
3552 pub fn FLAC__stream_encoder_set_blocksize(
3553 encoder: *mut FLAC__StreamEncoder,
3554 value: u32,
3555 ) -> FLAC__bool;
3556}
3557extern "C" {
3558 pub fn FLAC__stream_encoder_set_do_mid_side_stereo(
3559 encoder: *mut FLAC__StreamEncoder,
3560 value: FLAC__bool,
3561 ) -> FLAC__bool;
3562}
3563extern "C" {
3564 pub fn FLAC__stream_encoder_set_loose_mid_side_stereo(
3565 encoder: *mut FLAC__StreamEncoder,
3566 value: FLAC__bool,
3567 ) -> FLAC__bool;
3568}
3569extern "C" {
3570 pub fn FLAC__stream_encoder_set_apodization(
3571 encoder: *mut FLAC__StreamEncoder,
3572 specification: *const libc::c_char,
3573 ) -> FLAC__bool;
3574}
3575extern "C" {
3576 pub fn FLAC__stream_encoder_set_max_lpc_order(
3577 encoder: *mut FLAC__StreamEncoder,
3578 value: u32,
3579 ) -> FLAC__bool;
3580}
3581extern "C" {
3582 pub fn FLAC__stream_encoder_set_qlp_coeff_precision(
3583 encoder: *mut FLAC__StreamEncoder,
3584 value: u32,
3585 ) -> FLAC__bool;
3586}
3587extern "C" {
3588 pub fn FLAC__stream_encoder_set_do_qlp_coeff_prec_search(
3589 encoder: *mut FLAC__StreamEncoder,
3590 value: FLAC__bool,
3591 ) -> FLAC__bool;
3592}
3593extern "C" {
3594 pub fn FLAC__stream_encoder_set_do_escape_coding(
3595 encoder: *mut FLAC__StreamEncoder,
3596 value: FLAC__bool,
3597 ) -> FLAC__bool;
3598}
3599extern "C" {
3600 pub fn FLAC__stream_encoder_set_do_exhaustive_model_search(
3601 encoder: *mut FLAC__StreamEncoder,
3602 value: FLAC__bool,
3603 ) -> FLAC__bool;
3604}
3605extern "C" {
3606 pub fn FLAC__stream_encoder_set_min_residual_partition_order(
3607 encoder: *mut FLAC__StreamEncoder,
3608 value: u32,
3609 ) -> FLAC__bool;
3610}
3611extern "C" {
3612 pub fn FLAC__stream_encoder_set_max_residual_partition_order(
3613 encoder: *mut FLAC__StreamEncoder,
3614 value: u32,
3615 ) -> FLAC__bool;
3616}
3617extern "C" {
3618 pub fn FLAC__stream_encoder_set_rice_parameter_search_dist(
3619 encoder: *mut FLAC__StreamEncoder,
3620 value: u32,
3621 ) -> FLAC__bool;
3622}
3623extern "C" {
3624 pub fn FLAC__stream_encoder_set_total_samples_estimate(
3625 encoder: *mut FLAC__StreamEncoder,
3626 value: FLAC__uint64,
3627 ) -> FLAC__bool;
3628}
3629extern "C" {
3630 pub fn FLAC__stream_encoder_set_metadata(
3631 encoder: *mut FLAC__StreamEncoder,
3632 metadata: *mut *mut FLAC__StreamMetadata,
3633 num_blocks: u32,
3634 ) -> FLAC__bool;
3635}
3636extern "C" {
3637 pub fn FLAC__stream_encoder_set_limit_min_bitrate(
3638 encoder: *mut FLAC__StreamEncoder,
3639 value: FLAC__bool,
3640 ) -> FLAC__bool;
3641}
3642extern "C" {
3643 pub fn FLAC__stream_encoder_get_state(
3644 encoder: *const FLAC__StreamEncoder,
3645 ) -> FLAC__StreamEncoderState;
3646}
3647extern "C" {
3648 pub fn FLAC__stream_encoder_get_verify_decoder_state(
3649 encoder: *const FLAC__StreamEncoder,
3650 ) -> FLAC__StreamDecoderState;
3651}
3652extern "C" {
3653 pub fn FLAC__stream_encoder_get_resolved_state_string(
3654 encoder: *const FLAC__StreamEncoder,
3655 ) -> *const libc::c_char;
3656}
3657extern "C" {
3658 pub fn FLAC__stream_encoder_get_verify_decoder_error_stats(
3659 encoder: *const FLAC__StreamEncoder,
3660 absolute_sample: *mut FLAC__uint64,
3661 frame_number: *mut u32,
3662 channel: *mut u32,
3663 sample: *mut u32,
3664 expected: *mut FLAC__int32,
3665 got: *mut FLAC__int32,
3666 );
3667}
3668extern "C" {
3669 pub fn FLAC__stream_encoder_get_verify(encoder: *const FLAC__StreamEncoder) -> FLAC__bool;
3670}
3671extern "C" {
3672 pub fn FLAC__stream_encoder_get_streamable_subset(
3673 encoder: *const FLAC__StreamEncoder,
3674 ) -> FLAC__bool;
3675}
3676extern "C" {
3677 pub fn FLAC__stream_encoder_get_channels(encoder: *const FLAC__StreamEncoder) -> u32;
3678}
3679extern "C" {
3680 pub fn FLAC__stream_encoder_get_bits_per_sample(encoder: *const FLAC__StreamEncoder) -> u32;
3681}
3682extern "C" {
3683 pub fn FLAC__stream_encoder_get_sample_rate(encoder: *const FLAC__StreamEncoder) -> u32;
3684}
3685extern "C" {
3686 pub fn FLAC__stream_encoder_get_blocksize(encoder: *const FLAC__StreamEncoder) -> u32;
3687}
3688extern "C" {
3689 pub fn FLAC__stream_encoder_get_do_mid_side_stereo(
3690 encoder: *const FLAC__StreamEncoder,
3691 ) -> FLAC__bool;
3692}
3693extern "C" {
3694 pub fn FLAC__stream_encoder_get_loose_mid_side_stereo(
3695 encoder: *const FLAC__StreamEncoder,
3696 ) -> FLAC__bool;
3697}
3698extern "C" {
3699 pub fn FLAC__stream_encoder_get_max_lpc_order(encoder: *const FLAC__StreamEncoder) -> u32;
3700}
3701extern "C" {
3702 pub fn FLAC__stream_encoder_get_qlp_coeff_precision(encoder: *const FLAC__StreamEncoder)
3703 -> u32;
3704}
3705extern "C" {
3706 pub fn FLAC__stream_encoder_get_do_qlp_coeff_prec_search(
3707 encoder: *const FLAC__StreamEncoder,
3708 ) -> FLAC__bool;
3709}
3710extern "C" {
3711 pub fn FLAC__stream_encoder_get_do_escape_coding(
3712 encoder: *const FLAC__StreamEncoder,
3713 ) -> FLAC__bool;
3714}
3715extern "C" {
3716 pub fn FLAC__stream_encoder_get_do_exhaustive_model_search(
3717 encoder: *const FLAC__StreamEncoder,
3718 ) -> FLAC__bool;
3719}
3720extern "C" {
3721 pub fn FLAC__stream_encoder_get_min_residual_partition_order(
3722 encoder: *const FLAC__StreamEncoder,
3723 ) -> u32;
3724}
3725extern "C" {
3726 pub fn FLAC__stream_encoder_get_max_residual_partition_order(
3727 encoder: *const FLAC__StreamEncoder,
3728 ) -> u32;
3729}
3730extern "C" {
3731 pub fn FLAC__stream_encoder_get_rice_parameter_search_dist(
3732 encoder: *const FLAC__StreamEncoder,
3733 ) -> u32;
3734}
3735extern "C" {
3736 pub fn FLAC__stream_encoder_get_total_samples_estimate(
3737 encoder: *const FLAC__StreamEncoder,
3738 ) -> FLAC__uint64;
3739}
3740extern "C" {
3741 pub fn FLAC__stream_encoder_get_limit_min_bitrate(
3742 encoder: *const FLAC__StreamEncoder,
3743 ) -> FLAC__bool;
3744}
3745extern "C" {
3746 pub fn FLAC__stream_encoder_init_stream(
3747 encoder: *mut FLAC__StreamEncoder,
3748 write_callback: FLAC__StreamEncoderWriteCallback,
3749 seek_callback: FLAC__StreamEncoderSeekCallback,
3750 tell_callback: FLAC__StreamEncoderTellCallback,
3751 metadata_callback: FLAC__StreamEncoderMetadataCallback,
3752 client_data: *mut libc::c_void,
3753 ) -> FLAC__StreamEncoderInitStatus;
3754}
3755extern "C" {
3756 pub fn FLAC__stream_encoder_init_ogg_stream(
3757 encoder: *mut FLAC__StreamEncoder,
3758 read_callback: FLAC__StreamEncoderReadCallback,
3759 write_callback: FLAC__StreamEncoderWriteCallback,
3760 seek_callback: FLAC__StreamEncoderSeekCallback,
3761 tell_callback: FLAC__StreamEncoderTellCallback,
3762 metadata_callback: FLAC__StreamEncoderMetadataCallback,
3763 client_data: *mut libc::c_void,
3764 ) -> FLAC__StreamEncoderInitStatus;
3765}
3766extern "C" {
3767 pub fn FLAC__stream_encoder_init_FILE(
3768 encoder: *mut FLAC__StreamEncoder,
3769 file: *mut FILE,
3770 progress_callback: FLAC__StreamEncoderProgressCallback,
3771 client_data: *mut libc::c_void,
3772 ) -> FLAC__StreamEncoderInitStatus;
3773}
3774extern "C" {
3775 pub fn FLAC__stream_encoder_init_ogg_FILE(
3776 encoder: *mut FLAC__StreamEncoder,
3777 file: *mut FILE,
3778 progress_callback: FLAC__StreamEncoderProgressCallback,
3779 client_data: *mut libc::c_void,
3780 ) -> FLAC__StreamEncoderInitStatus;
3781}
3782extern "C" {
3783 pub fn FLAC__stream_encoder_init_file(
3784 encoder: *mut FLAC__StreamEncoder,
3785 filename: *const libc::c_char,
3786 progress_callback: FLAC__StreamEncoderProgressCallback,
3787 client_data: *mut libc::c_void,
3788 ) -> FLAC__StreamEncoderInitStatus;
3789}
3790extern "C" {
3791 pub fn FLAC__stream_encoder_init_ogg_file(
3792 encoder: *mut FLAC__StreamEncoder,
3793 filename: *const libc::c_char,
3794 progress_callback: FLAC__StreamEncoderProgressCallback,
3795 client_data: *mut libc::c_void,
3796 ) -> FLAC__StreamEncoderInitStatus;
3797}
3798extern "C" {
3799 pub fn FLAC__stream_encoder_finish(encoder: *mut FLAC__StreamEncoder) -> FLAC__bool;
3800}
3801extern "C" {
3802 pub fn FLAC__stream_encoder_process(
3803 encoder: *mut FLAC__StreamEncoder,
3804 buffer: *const *const FLAC__int32,
3805 samples: u32,
3806 ) -> FLAC__bool;
3807}
3808extern "C" {
3809 pub fn FLAC__stream_encoder_process_interleaved(
3810 encoder: *mut FLAC__StreamEncoder,
3811 buffer: *const FLAC__int32,
3812 samples: u32,
3813 ) -> FLAC__bool;
3814}