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