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