#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
pub const FLAC_API_VERSION_CURRENT: u32 = 12;
pub const FLAC_API_VERSION_REVISION: u32 = 0;
pub const FLAC_API_VERSION_AGE: u32 = 0;
pub const FLAC__MAX_METADATA_TYPE_CODE: u32 = 126;
pub const FLAC__MIN_BLOCK_SIZE: u32 = 16;
pub const FLAC__MAX_BLOCK_SIZE: u32 = 65535;
pub const FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ: u32 = 4608;
pub const FLAC__MAX_CHANNELS: u32 = 8;
pub const FLAC__MIN_BITS_PER_SAMPLE: u32 = 4;
pub const FLAC__MAX_BITS_PER_SAMPLE: u32 = 32;
pub const FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE: u32 = 32;
pub const FLAC__MAX_SAMPLE_RATE: u32 = 1048575;
pub const FLAC__MAX_LPC_ORDER: u32 = 32;
pub const FLAC__SUBSET_MAX_LPC_ORDER_48000HZ: u32 = 12;
pub const FLAC__MIN_QLP_COEFF_PRECISION: u32 = 5;
pub const FLAC__MAX_QLP_COEFF_PRECISION: u32 = 15;
pub const FLAC__MAX_FIXED_ORDER: u32 = 4;
pub const FLAC__MAX_RICE_PARTITION_ORDER: u32 = 15;
pub const FLAC__SUBSET_MAX_RICE_PARTITION_ORDER: u32 = 8;
pub const FLAC__STREAM_SYNC_LENGTH: u32 = 4;
pub const FLAC__STREAM_METADATA_STREAMINFO_LENGTH: u32 = 34;
pub const FLAC__STREAM_METADATA_SEEKPOINT_LENGTH: u32 = 18;
pub const FLAC__STREAM_METADATA_HEADER_LENGTH: u32 = 4;
extern "C" {
pub static mut FLAC_API_SUPPORTS_OGG_FLAC: libc::c_int;
}
pub type __off_t = libc::c_long;
pub type __off64_t = libc::c_long;
pub type FLAC__int8 = i8;
pub type FLAC__uint8 = u8;
pub type FLAC__int16 = i16;
pub type FLAC__int32 = i32;
pub type FLAC__int64 = i64;
pub type FLAC__uint16 = u16;
pub type FLAC__uint32 = u32;
pub type FLAC__uint64 = u64;
pub type FLAC__bool = libc::c_int;
pub type FLAC__byte = FLAC__uint8;
pub type off_t = __off_t;
pub type FLAC__IOHandle = *mut libc::c_void;
pub type FLAC__IOCallback_Read = ::core::option::Option<
unsafe extern "C" fn(
ptr: *mut libc::c_void,
size: usize,
nmemb: usize,
handle: FLAC__IOHandle,
) -> usize,
>;
pub type FLAC__IOCallback_Write = ::core::option::Option<
unsafe extern "C" fn(
ptr: *const libc::c_void,
size: usize,
nmemb: usize,
handle: FLAC__IOHandle,
) -> usize,
>;
pub type FLAC__IOCallback_Seek = ::core::option::Option<
unsafe extern "C" fn(
handle: FLAC__IOHandle,
offset: FLAC__int64,
whence: libc::c_int,
) -> libc::c_int,
>;
pub type FLAC__IOCallback_Tell =
::core::option::Option<unsafe extern "C" fn(handle: FLAC__IOHandle) -> FLAC__int64>;
pub type FLAC__IOCallback_Eof =
::core::option::Option<unsafe extern "C" fn(handle: FLAC__IOHandle) -> libc::c_int>;
pub type FLAC__IOCallback_Close =
::core::option::Option<unsafe extern "C" fn(handle: FLAC__IOHandle) -> libc::c_int>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__IOCallbacks {
pub read: FLAC__IOCallback_Read,
pub write: FLAC__IOCallback_Write,
pub seek: FLAC__IOCallback_Seek,
pub tell: FLAC__IOCallback_Tell,
pub eof: FLAC__IOCallback_Eof,
pub close: FLAC__IOCallback_Close,
}
#[test]
fn bindgen_test_layout_FLAC__IOCallbacks() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__IOCallbacks> = ::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__IOCallbacks>(),
48usize,
concat!("Size of: ", stringify!(FLAC__IOCallbacks))
);
assert_eq!(
::core::mem::align_of::<FLAC__IOCallbacks>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__IOCallbacks))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__IOCallbacks),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__IOCallbacks),
"::",
stringify!(write)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).seek) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FLAC__IOCallbacks),
"::",
stringify!(seek)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).tell) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FLAC__IOCallbacks),
"::",
stringify!(tell)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).eof) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FLAC__IOCallbacks),
"::",
stringify!(eof)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(FLAC__IOCallbacks),
"::",
stringify!(close)
)
);
}
extern "C" {
pub static mut FLAC__VERSION_STRING: *const libc::c_char;
}
extern "C" {
pub static mut FLAC__VENDOR_STRING: *const libc::c_char;
}
extern "C" {
pub static FLAC__STREAM_SYNC_STRING: [FLAC__byte; 4usize];
}
extern "C" {
pub static FLAC__STREAM_SYNC: u32;
}
extern "C" {
pub static FLAC__STREAM_SYNC_LEN: u32;
}
pub const FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: FLAC__EntropyCodingMethodType = 0;
pub const FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: FLAC__EntropyCodingMethodType = 1;
pub type FLAC__EntropyCodingMethodType = libc::c_uint;
extern "C" {
pub static FLAC__EntropyCodingMethodTypeString: [*const libc::c_char; 0usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__EntropyCodingMethod_PartitionedRiceContents {
pub parameters: *mut u32,
pub raw_bits: *mut u32,
pub capacity_by_order: u32,
}
#[test]
fn bindgen_test_layout_FLAC__EntropyCodingMethod_PartitionedRiceContents() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__EntropyCodingMethod_PartitionedRiceContents> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__EntropyCodingMethod_PartitionedRiceContents>(),
24usize,
concat!(
"Size of: ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents)
)
);
assert_eq!(
::core::mem::align_of::<FLAC__EntropyCodingMethod_PartitionedRiceContents>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).parameters) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents),
"::",
stringify!(parameters)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).raw_bits) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents),
"::",
stringify!(raw_bits)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).capacity_by_order) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRiceContents),
"::",
stringify!(capacity_by_order)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__EntropyCodingMethod_PartitionedRice {
pub order: u32,
pub contents: *const FLAC__EntropyCodingMethod_PartitionedRiceContents,
}
#[test]
fn bindgen_test_layout_FLAC__EntropyCodingMethod_PartitionedRice() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__EntropyCodingMethod_PartitionedRice> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__EntropyCodingMethod_PartitionedRice>(),
16usize,
concat!(
"Size of: ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRice)
)
);
assert_eq!(
::core::mem::align_of::<FLAC__EntropyCodingMethod_PartitionedRice>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRice)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRice),
"::",
stringify!(order)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).contents) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__EntropyCodingMethod_PartitionedRice),
"::",
stringify!(contents)
)
);
}
extern "C" {
pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN: u32;
}
extern "C" {
pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN: u32;
}
extern "C" {
pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN: u32;
}
extern "C" {
pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN: u32;
}
extern "C" {
pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER: u32;
}
extern "C" {
pub static FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER: u32;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FLAC__EntropyCodingMethod {
pub type_: FLAC__EntropyCodingMethodType,
pub data: FLAC__EntropyCodingMethod__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FLAC__EntropyCodingMethod__bindgen_ty_1 {
pub partitioned_rice: FLAC__EntropyCodingMethod_PartitionedRice,
}
#[test]
fn bindgen_test_layout_FLAC__EntropyCodingMethod__bindgen_ty_1() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__EntropyCodingMethod__bindgen_ty_1> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__EntropyCodingMethod__bindgen_ty_1>(),
16usize,
concat!(
"Size of: ",
stringify!(FLAC__EntropyCodingMethod__bindgen_ty_1)
)
);
assert_eq!(
::core::mem::align_of::<FLAC__EntropyCodingMethod__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__EntropyCodingMethod__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).partitioned_rice) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__EntropyCodingMethod__bindgen_ty_1),
"::",
stringify!(partitioned_rice)
)
);
}
#[test]
fn bindgen_test_layout_FLAC__EntropyCodingMethod() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__EntropyCodingMethod> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__EntropyCodingMethod>(),
24usize,
concat!("Size of: ", stringify!(FLAC__EntropyCodingMethod))
);
assert_eq!(
::core::mem::align_of::<FLAC__EntropyCodingMethod>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__EntropyCodingMethod))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__EntropyCodingMethod),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__EntropyCodingMethod),
"::",
stringify!(data)
)
);
}
extern "C" {
pub static FLAC__ENTROPY_CODING_METHOD_TYPE_LEN: u32;
}
pub const FLAC__SUBFRAME_TYPE_CONSTANT: FLAC__SubframeType = 0;
pub const FLAC__SUBFRAME_TYPE_VERBATIM: FLAC__SubframeType = 1;
pub const FLAC__SUBFRAME_TYPE_FIXED: FLAC__SubframeType = 2;
pub const FLAC__SUBFRAME_TYPE_LPC: FLAC__SubframeType = 3;
pub type FLAC__SubframeType = libc::c_uint;
extern "C" {
pub static FLAC__SubframeTypeString: [*const libc::c_char; 0usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__Subframe_Constant {
pub value: FLAC__int64,
}
#[test]
fn bindgen_test_layout_FLAC__Subframe_Constant() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_Constant> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__Subframe_Constant>(),
8usize,
concat!("Size of: ", stringify!(FLAC__Subframe_Constant))
);
assert_eq!(
::core::mem::align_of::<FLAC__Subframe_Constant>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__Subframe_Constant))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Constant),
"::",
stringify!(value)
)
);
}
pub const FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32: FLAC__VerbatimSubframeDataType = 0;
pub const FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64: FLAC__VerbatimSubframeDataType = 1;
pub type FLAC__VerbatimSubframeDataType = libc::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FLAC__Subframe_Verbatim {
pub data: FLAC__Subframe_Verbatim__bindgen_ty_1,
pub data_type: FLAC__VerbatimSubframeDataType,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FLAC__Subframe_Verbatim__bindgen_ty_1 {
pub int32: *const FLAC__int32,
pub int64: *const FLAC__int64,
}
#[test]
fn bindgen_test_layout_FLAC__Subframe_Verbatim__bindgen_ty_1() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_Verbatim__bindgen_ty_1> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__Subframe_Verbatim__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(FLAC__Subframe_Verbatim__bindgen_ty_1)
)
);
assert_eq!(
::core::mem::align_of::<FLAC__Subframe_Verbatim__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__Subframe_Verbatim__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).int32) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Verbatim__bindgen_ty_1),
"::",
stringify!(int32)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).int64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Verbatim__bindgen_ty_1),
"::",
stringify!(int64)
)
);
}
#[test]
fn bindgen_test_layout_FLAC__Subframe_Verbatim() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_Verbatim> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__Subframe_Verbatim>(),
16usize,
concat!("Size of: ", stringify!(FLAC__Subframe_Verbatim))
);
assert_eq!(
::core::mem::align_of::<FLAC__Subframe_Verbatim>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__Subframe_Verbatim))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Verbatim),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data_type) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Verbatim),
"::",
stringify!(data_type)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FLAC__Subframe_Fixed {
pub entropy_coding_method: FLAC__EntropyCodingMethod,
pub order: u32,
pub warmup: [FLAC__int64; 4usize],
pub residual: *const FLAC__int32,
}
#[test]
fn bindgen_test_layout_FLAC__Subframe_Fixed() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_Fixed> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__Subframe_Fixed>(),
72usize,
concat!("Size of: ", stringify!(FLAC__Subframe_Fixed))
);
assert_eq!(
::core::mem::align_of::<FLAC__Subframe_Fixed>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__Subframe_Fixed))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).entropy_coding_method) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Fixed),
"::",
stringify!(entropy_coding_method)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Fixed),
"::",
stringify!(order)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).warmup) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Fixed),
"::",
stringify!(warmup)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).residual) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_Fixed),
"::",
stringify!(residual)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FLAC__Subframe_LPC {
pub entropy_coding_method: FLAC__EntropyCodingMethod,
pub order: u32,
pub qlp_coeff_precision: u32,
pub quantization_level: libc::c_int,
pub qlp_coeff: [FLAC__int32; 32usize],
pub warmup: [FLAC__int64; 32usize],
pub residual: *const FLAC__int32,
}
#[test]
fn bindgen_test_layout_FLAC__Subframe_LPC() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe_LPC> = ::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__Subframe_LPC>(),
432usize,
concat!("Size of: ", stringify!(FLAC__Subframe_LPC))
);
assert_eq!(
::core::mem::align_of::<FLAC__Subframe_LPC>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__Subframe_LPC))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).entropy_coding_method) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_LPC),
"::",
stringify!(entropy_coding_method)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_LPC),
"::",
stringify!(order)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).qlp_coeff_precision) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_LPC),
"::",
stringify!(qlp_coeff_precision)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).quantization_level) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_LPC),
"::",
stringify!(quantization_level)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).qlp_coeff) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_LPC),
"::",
stringify!(qlp_coeff)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).warmup) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_LPC),
"::",
stringify!(warmup)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).residual) as usize - ptr as usize },
424usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe_LPC),
"::",
stringify!(residual)
)
);
}
extern "C" {
pub static FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN: u32;
}
extern "C" {
pub static FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN: u32;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FLAC__Subframe {
pub type_: FLAC__SubframeType,
pub data: FLAC__Subframe__bindgen_ty_1,
pub wasted_bits: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FLAC__Subframe__bindgen_ty_1 {
pub constant: FLAC__Subframe_Constant,
pub fixed: FLAC__Subframe_Fixed,
pub lpc: FLAC__Subframe_LPC,
pub verbatim: FLAC__Subframe_Verbatim,
}
#[test]
fn bindgen_test_layout_FLAC__Subframe__bindgen_ty_1() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe__bindgen_ty_1> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__Subframe__bindgen_ty_1>(),
432usize,
concat!("Size of: ", stringify!(FLAC__Subframe__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<FLAC__Subframe__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__Subframe__bindgen_ty_1))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).constant) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe__bindgen_ty_1),
"::",
stringify!(constant)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).fixed) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe__bindgen_ty_1),
"::",
stringify!(fixed)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).lpc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe__bindgen_ty_1),
"::",
stringify!(lpc)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).verbatim) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe__bindgen_ty_1),
"::",
stringify!(verbatim)
)
);
}
#[test]
fn bindgen_test_layout_FLAC__Subframe() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__Subframe> = ::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__Subframe>(),
448usize,
concat!("Size of: ", stringify!(FLAC__Subframe))
);
assert_eq!(
::core::mem::align_of::<FLAC__Subframe>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__Subframe))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).wasted_bits) as usize - ptr as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Subframe),
"::",
stringify!(wasted_bits)
)
);
}
extern "C" {
pub static FLAC__SUBFRAME_ZERO_PAD_LEN: u32;
}
extern "C" {
pub static FLAC__SUBFRAME_TYPE_LEN: u32;
}
extern "C" {
pub static FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN: u32;
}
extern "C" {
pub static FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK: u32;
}
extern "C" {
pub static FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK: u32;
}
extern "C" {
pub static FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK: u32;
}
extern "C" {
pub static FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK: u32;
}
pub const FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: FLAC__ChannelAssignment = 0;
pub const FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: FLAC__ChannelAssignment = 1;
pub const FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: FLAC__ChannelAssignment = 2;
pub const FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: FLAC__ChannelAssignment = 3;
pub type FLAC__ChannelAssignment = libc::c_uint;
extern "C" {
pub static FLAC__ChannelAssignmentString: [*const libc::c_char; 0usize];
}
pub const FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER: FLAC__FrameNumberType = 0;
pub const FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER: FLAC__FrameNumberType = 1;
pub type FLAC__FrameNumberType = libc::c_uint;
extern "C" {
pub static FLAC__FrameNumberTypeString: [*const libc::c_char; 0usize];
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FLAC__FrameHeader {
pub blocksize: u32,
pub sample_rate: u32,
pub channels: u32,
pub channel_assignment: FLAC__ChannelAssignment,
pub bits_per_sample: u32,
pub number_type: FLAC__FrameNumberType,
pub number: FLAC__FrameHeader__bindgen_ty_1,
pub crc: FLAC__uint8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FLAC__FrameHeader__bindgen_ty_1 {
pub frame_number: FLAC__uint32,
pub sample_number: FLAC__uint64,
}
#[test]
fn bindgen_test_layout_FLAC__FrameHeader__bindgen_ty_1() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__FrameHeader__bindgen_ty_1> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__FrameHeader__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(FLAC__FrameHeader__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<FLAC__FrameHeader__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__FrameHeader__bindgen_ty_1))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).frame_number) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader__bindgen_ty_1),
"::",
stringify!(frame_number)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).sample_number) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader__bindgen_ty_1),
"::",
stringify!(sample_number)
)
);
}
#[test]
fn bindgen_test_layout_FLAC__FrameHeader() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__FrameHeader> = ::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__FrameHeader>(),
40usize,
concat!("Size of: ", stringify!(FLAC__FrameHeader))
);
assert_eq!(
::core::mem::align_of::<FLAC__FrameHeader>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__FrameHeader))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).blocksize) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader),
"::",
stringify!(blocksize)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader),
"::",
stringify!(sample_rate)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader),
"::",
stringify!(channels)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).channel_assignment) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader),
"::",
stringify!(channel_assignment)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).bits_per_sample) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader),
"::",
stringify!(bits_per_sample)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).number_type) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader),
"::",
stringify!(number_type)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).crc) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameHeader),
"::",
stringify!(crc)
)
);
}
extern "C" {
pub static FLAC__FRAME_HEADER_SYNC: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_SYNC_LEN: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_RESERVED_LEN: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_BLOCK_SIZE_LEN: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_SAMPLE_RATE_LEN: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_ZERO_PAD_LEN: u32;
}
extern "C" {
pub static FLAC__FRAME_HEADER_CRC_LEN: u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__FrameFooter {
pub crc: FLAC__uint16,
}
#[test]
fn bindgen_test_layout_FLAC__FrameFooter() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__FrameFooter> = ::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__FrameFooter>(),
2usize,
concat!("Size of: ", stringify!(FLAC__FrameFooter))
);
assert_eq!(
::core::mem::align_of::<FLAC__FrameFooter>(),
2usize,
concat!("Alignment of ", stringify!(FLAC__FrameFooter))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).crc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__FrameFooter),
"::",
stringify!(crc)
)
);
}
extern "C" {
pub static FLAC__FRAME_FOOTER_CRC_LEN: u32;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FLAC__Frame {
pub header: FLAC__FrameHeader,
pub subframes: [FLAC__Subframe; 8usize],
pub footer: FLAC__FrameFooter,
}
#[test]
fn bindgen_test_layout_FLAC__Frame() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__Frame> = ::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__Frame>(),
3632usize,
concat!("Size of: ", stringify!(FLAC__Frame))
);
assert_eq!(
::core::mem::align_of::<FLAC__Frame>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__Frame))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Frame),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).subframes) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Frame),
"::",
stringify!(subframes)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).footer) as usize - ptr as usize },
3624usize,
concat!(
"Offset of field: ",
stringify!(FLAC__Frame),
"::",
stringify!(footer)
)
);
}
pub const FLAC__METADATA_TYPE_STREAMINFO: FLAC__MetadataType = 0;
pub const FLAC__METADATA_TYPE_PADDING: FLAC__MetadataType = 1;
pub const FLAC__METADATA_TYPE_APPLICATION: FLAC__MetadataType = 2;
pub const FLAC__METADATA_TYPE_SEEKTABLE: FLAC__MetadataType = 3;
pub const FLAC__METADATA_TYPE_VORBIS_COMMENT: FLAC__MetadataType = 4;
pub const FLAC__METADATA_TYPE_CUESHEET: FLAC__MetadataType = 5;
pub const FLAC__METADATA_TYPE_PICTURE: FLAC__MetadataType = 6;
pub const FLAC__METADATA_TYPE_UNDEFINED: FLAC__MetadataType = 7;
pub const FLAC__MAX_METADATA_TYPE: FLAC__MetadataType = 126;
pub type FLAC__MetadataType = libc::c_uint;
extern "C" {
pub static FLAC__MetadataTypeString: [*const libc::c_char; 0usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_StreamInfo {
pub min_blocksize: u32,
pub max_blocksize: u32,
pub min_framesize: u32,
pub max_framesize: u32,
pub sample_rate: u32,
pub channels: u32,
pub bits_per_sample: u32,
pub total_samples: FLAC__uint64,
pub md5sum: [FLAC__byte; 16usize],
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_StreamInfo() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_StreamInfo> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_StreamInfo>(),
56usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_StreamInfo))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_StreamInfo>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamMetadata_StreamInfo))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).min_blocksize) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(min_blocksize)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).max_blocksize) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(max_blocksize)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).min_framesize) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(min_framesize)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).max_framesize) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(max_framesize)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(sample_rate)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(channels)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).bits_per_sample) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(bits_per_sample)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).total_samples) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(total_samples)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).md5sum) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_StreamInfo),
"::",
stringify!(md5sum)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN: u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_Padding {
pub dummy: libc::c_int,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_Padding() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_Padding> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_Padding>(),
4usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_Padding))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_Padding>(),
4usize,
concat!("Alignment of ", stringify!(FLAC__StreamMetadata_Padding))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).dummy) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Padding),
"::",
stringify!(dummy)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_Application {
pub id: [FLAC__byte; 4usize],
pub data: *mut FLAC__byte,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_Application() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_Application> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_Application>(),
16usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_Application))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_Application>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__StreamMetadata_Application)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Application),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Application),
"::",
stringify!(data)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_APPLICATION_ID_LEN: u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_SeekPoint {
pub sample_number: FLAC__uint64,
pub stream_offset: FLAC__uint64,
pub frame_samples: u32,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_SeekPoint() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_SeekPoint> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_SeekPoint>(),
24usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_SeekPoint))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_SeekPoint>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamMetadata_SeekPoint))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).sample_number) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_SeekPoint),
"::",
stringify!(sample_number)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).stream_offset) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_SeekPoint),
"::",
stringify!(stream_offset)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).frame_samples) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_SeekPoint),
"::",
stringify!(frame_samples)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER: FLAC__uint64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_SeekTable {
pub num_points: u32,
pub points: *mut FLAC__StreamMetadata_SeekPoint,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_SeekTable() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_SeekTable> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_SeekTable>(),
16usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_SeekTable))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_SeekTable>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamMetadata_SeekTable))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).num_points) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_SeekTable),
"::",
stringify!(num_points)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_SeekTable),
"::",
stringify!(points)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_VorbisComment_Entry {
pub length: FLAC__uint32,
pub entry: *mut FLAC__byte,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_VorbisComment_Entry() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_VorbisComment_Entry> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_VorbisComment_Entry>(),
16usize,
concat!(
"Size of: ",
stringify!(FLAC__StreamMetadata_VorbisComment_Entry)
)
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_VorbisComment_Entry>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__StreamMetadata_VorbisComment_Entry)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_VorbisComment_Entry),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).entry) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_VorbisComment_Entry),
"::",
stringify!(entry)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN: u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_VorbisComment {
pub vendor_string: FLAC__StreamMetadata_VorbisComment_Entry,
pub num_comments: FLAC__uint32,
pub comments: *mut FLAC__StreamMetadata_VorbisComment_Entry,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_VorbisComment() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_VorbisComment> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_VorbisComment>(),
32usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_VorbisComment))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_VorbisComment>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__StreamMetadata_VorbisComment)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).vendor_string) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_VorbisComment),
"::",
stringify!(vendor_string)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).num_comments) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_VorbisComment),
"::",
stringify!(num_comments)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).comments) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_VorbisComment),
"::",
stringify!(comments)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN: u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_CueSheet_Index {
pub offset: FLAC__uint64,
pub number: FLAC__byte,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_CueSheet_Index() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_CueSheet_Index> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_CueSheet_Index>(),
16usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_CueSheet_Index))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_CueSheet_Index>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__StreamMetadata_CueSheet_Index)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet_Index),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet_Index),
"::",
stringify!(number)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN: u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_CueSheet_Track {
pub offset: FLAC__uint64,
pub number: FLAC__byte,
pub isrc: [libc::c_char; 13usize],
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub num_indices: FLAC__byte,
pub indices: *mut FLAC__StreamMetadata_CueSheet_Index,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_CueSheet_Track() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_CueSheet_Track> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_CueSheet_Track>(),
32usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_CueSheet_Track))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_CueSheet_Track>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__StreamMetadata_CueSheet_Track)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet_Track),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet_Track),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).isrc) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet_Track),
"::",
stringify!(isrc)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).num_indices) as usize - ptr as usize },
23usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet_Track),
"::",
stringify!(num_indices)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).indices) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet_Track),
"::",
stringify!(indices)
)
);
}
impl FLAC__StreamMetadata_CueSheet_Track {
#[inline]
pub fn type_(&self) -> u32 {
unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_type(&mut self, val: u32) {
unsafe {
let val: u32 = ::core::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn pre_emphasis(&self) -> u32 {
unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_pre_emphasis(&mut self, val: u32) {
unsafe {
let val: u32 = ::core::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(type_: u32, pre_emphasis: u32) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let type_: u32 = unsafe { ::core::mem::transmute(type_) };
type_ as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let pre_emphasis: u32 = unsafe { ::core::mem::transmute(pre_emphasis) };
pre_emphasis as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN: u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_CueSheet {
pub media_catalog_number: [libc::c_char; 129usize],
pub lead_in: FLAC__uint64,
pub is_cd: FLAC__bool,
pub num_tracks: u32,
pub tracks: *mut FLAC__StreamMetadata_CueSheet_Track,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_CueSheet() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_CueSheet> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_CueSheet>(),
160usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_CueSheet))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_CueSheet>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamMetadata_CueSheet))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).media_catalog_number) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet),
"::",
stringify!(media_catalog_number)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).lead_in) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet),
"::",
stringify!(lead_in)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).is_cd) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet),
"::",
stringify!(is_cd)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).num_tracks) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet),
"::",
stringify!(num_tracks)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).tracks) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_CueSheet),
"::",
stringify!(tracks)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN: u32;
}
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER: FLAC__StreamMetadata_Picture_Type = 0;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD: FLAC__StreamMetadata_Picture_Type =
1;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON: FLAC__StreamMetadata_Picture_Type = 2;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER: FLAC__StreamMetadata_Picture_Type = 3;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_BACK_COVER: FLAC__StreamMetadata_Picture_Type = 4;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_LEAFLET_PAGE: FLAC__StreamMetadata_Picture_Type = 5;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA: FLAC__StreamMetadata_Picture_Type = 6;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_LEAD_ARTIST: FLAC__StreamMetadata_Picture_Type = 7;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_ARTIST: FLAC__StreamMetadata_Picture_Type = 8;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_CONDUCTOR: FLAC__StreamMetadata_Picture_Type = 9;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_BAND: FLAC__StreamMetadata_Picture_Type = 10;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_COMPOSER: FLAC__StreamMetadata_Picture_Type = 11;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_LYRICIST: FLAC__StreamMetadata_Picture_Type = 12;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_RECORDING_LOCATION: FLAC__StreamMetadata_Picture_Type =
13;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_RECORDING: FLAC__StreamMetadata_Picture_Type =
14;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_PERFORMANCE: FLAC__StreamMetadata_Picture_Type =
15;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_VIDEO_SCREEN_CAPTURE:
FLAC__StreamMetadata_Picture_Type = 16;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_FISH: FLAC__StreamMetadata_Picture_Type = 17;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_ILLUSTRATION: FLAC__StreamMetadata_Picture_Type = 18;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_BAND_LOGOTYPE: FLAC__StreamMetadata_Picture_Type = 19;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_PUBLISHER_LOGOTYPE: FLAC__StreamMetadata_Picture_Type =
20;
pub const FLAC__STREAM_METADATA_PICTURE_TYPE_UNDEFINED: FLAC__StreamMetadata_Picture_Type = 21;
pub type FLAC__StreamMetadata_Picture_Type = libc::c_uint;
extern "C" {
pub static FLAC__StreamMetadata_Picture_TypeString: [*const libc::c_char; 0usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_Picture {
pub type_: FLAC__StreamMetadata_Picture_Type,
pub mime_type: *mut libc::c_char,
pub description: *mut FLAC__byte,
pub width: FLAC__uint32,
pub height: FLAC__uint32,
pub depth: FLAC__uint32,
pub colors: FLAC__uint32,
pub data_length: FLAC__uint32,
pub data: *mut FLAC__byte,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_Picture() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_Picture> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_Picture>(),
56usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_Picture))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_Picture>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamMetadata_Picture))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).mime_type) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(mime_type)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(depth)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(colors)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data_length) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(data_length)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Picture),
"::",
stringify!(data)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_PICTURE_TYPE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_PICTURE_COLORS_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN: u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamMetadata_Unknown {
pub data: *mut FLAC__byte,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata_Unknown() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata_Unknown> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata_Unknown>(),
8usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata_Unknown))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata_Unknown>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamMetadata_Unknown))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata_Unknown),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FLAC__StreamMetadata {
pub type_: FLAC__MetadataType,
pub is_last: FLAC__bool,
pub length: u32,
pub data: FLAC__StreamMetadata__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FLAC__StreamMetadata__bindgen_ty_1 {
pub stream_info: FLAC__StreamMetadata_StreamInfo,
pub padding: FLAC__StreamMetadata_Padding,
pub application: FLAC__StreamMetadata_Application,
pub seek_table: FLAC__StreamMetadata_SeekTable,
pub vorbis_comment: FLAC__StreamMetadata_VorbisComment,
pub cue_sheet: FLAC__StreamMetadata_CueSheet,
pub picture: FLAC__StreamMetadata_Picture,
pub unknown: FLAC__StreamMetadata_Unknown,
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata__bindgen_ty_1() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata__bindgen_ty_1> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata__bindgen_ty_1>(),
160usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).stream_info) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1),
"::",
stringify!(stream_info)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).application) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1),
"::",
stringify!(application)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).seek_table) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1),
"::",
stringify!(seek_table)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).vorbis_comment) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1),
"::",
stringify!(vorbis_comment)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).cue_sheet) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1),
"::",
stringify!(cue_sheet)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).picture) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1),
"::",
stringify!(picture)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).unknown) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata__bindgen_ty_1),
"::",
stringify!(unknown)
)
);
}
#[test]
fn bindgen_test_layout_FLAC__StreamMetadata() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamMetadata> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamMetadata>(),
176usize,
concat!("Size of: ", stringify!(FLAC__StreamMetadata))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamMetadata>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamMetadata))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).is_last) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata),
"::",
stringify!(is_last)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamMetadata),
"::",
stringify!(data)
)
);
}
extern "C" {
pub static FLAC__STREAM_METADATA_IS_LAST_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_TYPE_LEN: u32;
}
extern "C" {
pub static FLAC__STREAM_METADATA_LENGTH_LEN: u32;
}
extern "C" {
pub fn FLAC__format_sample_rate_is_valid(sample_rate: u32) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__format_blocksize_is_subset(blocksize: u32, sample_rate: u32) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__format_sample_rate_is_subset(sample_rate: u32) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__format_vorbiscomment_entry_name_is_legal(name: *const libc::c_char) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__format_vorbiscomment_entry_value_is_legal(
value: *const FLAC__byte,
length: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__format_vorbiscomment_entry_is_legal(
entry: *const FLAC__byte,
length: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__format_seektable_is_legal(
seek_table: *const FLAC__StreamMetadata_SeekTable,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__format_seektable_sort(seek_table: *mut FLAC__StreamMetadata_SeekTable) -> u32;
}
extern "C" {
pub fn FLAC__format_cuesheet_is_legal(
cue_sheet: *const FLAC__StreamMetadata_CueSheet,
check_cd_da_subset: FLAC__bool,
violation: *mut *const libc::c_char,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__format_picture_is_legal(
picture: *const FLAC__StreamMetadata_Picture,
violation: *mut *const libc::c_char,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_get_streaminfo(
filename: *const libc::c_char,
streaminfo: *mut FLAC__StreamMetadata,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_get_tags(
filename: *const libc::c_char,
tags: *mut *mut FLAC__StreamMetadata,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_get_cuesheet(
filename: *const libc::c_char,
cuesheet: *mut *mut FLAC__StreamMetadata,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_get_picture(
filename: *const libc::c_char,
picture: *mut *mut FLAC__StreamMetadata,
type_: FLAC__StreamMetadata_Picture_Type,
mime_type: *const libc::c_char,
description: *const FLAC__byte,
max_width: u32,
max_height: u32,
max_depth: u32,
max_colors: u32,
) -> FLAC__bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__Metadata_SimpleIterator {
_unused: [u8; 0],
}
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK: FLAC__Metadata_SimpleIteratorStatus = 0;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT: FLAC__Metadata_SimpleIteratorStatus =
1;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE:
FLAC__Metadata_SimpleIteratorStatus = 2;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE:
FLAC__Metadata_SimpleIteratorStatus = 3;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE: FLAC__Metadata_SimpleIteratorStatus =
4;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA: FLAC__Metadata_SimpleIteratorStatus =
5;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR: FLAC__Metadata_SimpleIteratorStatus = 6;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR: FLAC__Metadata_SimpleIteratorStatus = 7;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR: FLAC__Metadata_SimpleIteratorStatus =
8;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR: FLAC__Metadata_SimpleIteratorStatus =
9;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR: FLAC__Metadata_SimpleIteratorStatus =
10;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR:
FLAC__Metadata_SimpleIteratorStatus = 11;
pub const FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR:
FLAC__Metadata_SimpleIteratorStatus = 12;
pub type FLAC__Metadata_SimpleIteratorStatus = libc::c_uint;
extern "C" {
pub static FLAC__Metadata_SimpleIteratorStatusString: [*const libc::c_char; 0usize];
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_new() -> *mut FLAC__Metadata_SimpleIterator;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_delete(iterator: *mut FLAC__Metadata_SimpleIterator);
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_status(
iterator: *mut FLAC__Metadata_SimpleIterator,
) -> FLAC__Metadata_SimpleIteratorStatus;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_init(
iterator: *mut FLAC__Metadata_SimpleIterator,
filename: *const libc::c_char,
read_only: FLAC__bool,
preserve_file_stats: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_is_writable(
iterator: *const FLAC__Metadata_SimpleIterator,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_next(
iterator: *mut FLAC__Metadata_SimpleIterator,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_prev(
iterator: *mut FLAC__Metadata_SimpleIterator,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_is_last(
iterator: *const FLAC__Metadata_SimpleIterator,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_get_block_offset(
iterator: *const FLAC__Metadata_SimpleIterator,
) -> off_t;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_get_block_type(
iterator: *const FLAC__Metadata_SimpleIterator,
) -> FLAC__MetadataType;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_get_block_length(
iterator: *const FLAC__Metadata_SimpleIterator,
) -> u32;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_get_application_id(
iterator: *mut FLAC__Metadata_SimpleIterator,
id: *mut FLAC__byte,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_get_block(
iterator: *mut FLAC__Metadata_SimpleIterator,
) -> *mut FLAC__StreamMetadata;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_set_block(
iterator: *mut FLAC__Metadata_SimpleIterator,
block: *mut FLAC__StreamMetadata,
use_padding: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_insert_block_after(
iterator: *mut FLAC__Metadata_SimpleIterator,
block: *mut FLAC__StreamMetadata,
use_padding: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_simple_iterator_delete_block(
iterator: *mut FLAC__Metadata_SimpleIterator,
use_padding: FLAC__bool,
) -> FLAC__bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__Metadata_Chain {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__Metadata_Iterator {
_unused: [u8; 0],
}
pub const FLAC__METADATA_CHAIN_STATUS_OK: FLAC__Metadata_ChainStatus = 0;
pub const FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT: FLAC__Metadata_ChainStatus = 1;
pub const FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE: FLAC__Metadata_ChainStatus = 2;
pub const FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE: FLAC__Metadata_ChainStatus = 3;
pub const FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE: FLAC__Metadata_ChainStatus = 4;
pub const FLAC__METADATA_CHAIN_STATUS_BAD_METADATA: FLAC__Metadata_ChainStatus = 5;
pub const FLAC__METADATA_CHAIN_STATUS_READ_ERROR: FLAC__Metadata_ChainStatus = 6;
pub const FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR: FLAC__Metadata_ChainStatus = 7;
pub const FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR: FLAC__Metadata_ChainStatus = 8;
pub const FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR: FLAC__Metadata_ChainStatus = 9;
pub const FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR: FLAC__Metadata_ChainStatus = 10;
pub const FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR: FLAC__Metadata_ChainStatus = 11;
pub const FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR: FLAC__Metadata_ChainStatus = 12;
pub const FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS: FLAC__Metadata_ChainStatus = 13;
pub const FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH: FLAC__Metadata_ChainStatus = 14;
pub const FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL: FLAC__Metadata_ChainStatus = 15;
pub type FLAC__Metadata_ChainStatus = libc::c_uint;
extern "C" {
pub static FLAC__Metadata_ChainStatusString: [*const libc::c_char; 0usize];
}
extern "C" {
pub fn FLAC__metadata_chain_new() -> *mut FLAC__Metadata_Chain;
}
extern "C" {
pub fn FLAC__metadata_chain_delete(chain: *mut FLAC__Metadata_Chain);
}
extern "C" {
pub fn FLAC__metadata_chain_status(
chain: *mut FLAC__Metadata_Chain,
) -> FLAC__Metadata_ChainStatus;
}
extern "C" {
pub fn FLAC__metadata_chain_read(
chain: *mut FLAC__Metadata_Chain,
filename: *const libc::c_char,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_chain_read_ogg(
chain: *mut FLAC__Metadata_Chain,
filename: *const libc::c_char,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_chain_read_with_callbacks(
chain: *mut FLAC__Metadata_Chain,
handle: FLAC__IOHandle,
callbacks: FLAC__IOCallbacks,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_chain_read_ogg_with_callbacks(
chain: *mut FLAC__Metadata_Chain,
handle: FLAC__IOHandle,
callbacks: FLAC__IOCallbacks,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_chain_check_if_tempfile_needed(
chain: *mut FLAC__Metadata_Chain,
use_padding: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_chain_write(
chain: *mut FLAC__Metadata_Chain,
use_padding: FLAC__bool,
preserve_file_stats: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_chain_write_with_callbacks(
chain: *mut FLAC__Metadata_Chain,
use_padding: FLAC__bool,
handle: FLAC__IOHandle,
callbacks: FLAC__IOCallbacks,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_chain_write_with_callbacks_and_tempfile(
chain: *mut FLAC__Metadata_Chain,
use_padding: FLAC__bool,
handle: FLAC__IOHandle,
callbacks: FLAC__IOCallbacks,
temp_handle: FLAC__IOHandle,
temp_callbacks: FLAC__IOCallbacks,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_chain_merge_padding(chain: *mut FLAC__Metadata_Chain);
}
extern "C" {
pub fn FLAC__metadata_chain_sort_padding(chain: *mut FLAC__Metadata_Chain);
}
extern "C" {
pub fn FLAC__metadata_iterator_new() -> *mut FLAC__Metadata_Iterator;
}
extern "C" {
pub fn FLAC__metadata_iterator_delete(iterator: *mut FLAC__Metadata_Iterator);
}
extern "C" {
pub fn FLAC__metadata_iterator_init(
iterator: *mut FLAC__Metadata_Iterator,
chain: *mut FLAC__Metadata_Chain,
);
}
extern "C" {
pub fn FLAC__metadata_iterator_next(iterator: *mut FLAC__Metadata_Iterator) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_iterator_prev(iterator: *mut FLAC__Metadata_Iterator) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_iterator_get_block_type(
iterator: *const FLAC__Metadata_Iterator,
) -> FLAC__MetadataType;
}
extern "C" {
pub fn FLAC__metadata_iterator_get_block(
iterator: *mut FLAC__Metadata_Iterator,
) -> *mut FLAC__StreamMetadata;
}
extern "C" {
pub fn FLAC__metadata_iterator_set_block(
iterator: *mut FLAC__Metadata_Iterator,
block: *mut FLAC__StreamMetadata,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_iterator_delete_block(
iterator: *mut FLAC__Metadata_Iterator,
replace_with_padding: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_iterator_insert_block_before(
iterator: *mut FLAC__Metadata_Iterator,
block: *mut FLAC__StreamMetadata,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_iterator_insert_block_after(
iterator: *mut FLAC__Metadata_Iterator,
block: *mut FLAC__StreamMetadata,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_new(type_: FLAC__MetadataType) -> *mut FLAC__StreamMetadata;
}
extern "C" {
pub fn FLAC__metadata_object_clone(
object: *const FLAC__StreamMetadata,
) -> *mut FLAC__StreamMetadata;
}
extern "C" {
pub fn FLAC__metadata_object_delete(object: *mut FLAC__StreamMetadata);
}
extern "C" {
pub fn FLAC__metadata_object_is_equal(
block1: *const FLAC__StreamMetadata,
block2: *const FLAC__StreamMetadata,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_application_set_data(
object: *mut FLAC__StreamMetadata,
data: *mut FLAC__byte,
length: u32,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_resize_points(
object: *mut FLAC__StreamMetadata,
new_num_points: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_set_point(
object: *mut FLAC__StreamMetadata,
point_num: u32,
point: FLAC__StreamMetadata_SeekPoint,
);
}
extern "C" {
pub fn FLAC__metadata_object_seektable_insert_point(
object: *mut FLAC__StreamMetadata,
point_num: u32,
point: FLAC__StreamMetadata_SeekPoint,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_delete_point(
object: *mut FLAC__StreamMetadata,
point_num: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_is_legal(
object: *const FLAC__StreamMetadata,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_template_append_placeholders(
object: *mut FLAC__StreamMetadata,
num: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_template_append_point(
object: *mut FLAC__StreamMetadata,
sample_number: FLAC__uint64,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_template_append_points(
object: *mut FLAC__StreamMetadata,
sample_numbers: *mut FLAC__uint64,
num: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_template_append_spaced_points(
object: *mut FLAC__StreamMetadata,
num: u32,
total_samples: FLAC__uint64,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(
object: *mut FLAC__StreamMetadata,
samples: u32,
total_samples: FLAC__uint64,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_seektable_template_sort(
object: *mut FLAC__StreamMetadata,
compact: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_set_vendor_string(
object: *mut FLAC__StreamMetadata,
entry: FLAC__StreamMetadata_VorbisComment_Entry,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_resize_comments(
object: *mut FLAC__StreamMetadata,
new_num_comments: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_set_comment(
object: *mut FLAC__StreamMetadata,
comment_num: u32,
entry: FLAC__StreamMetadata_VorbisComment_Entry,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_insert_comment(
object: *mut FLAC__StreamMetadata,
comment_num: u32,
entry: FLAC__StreamMetadata_VorbisComment_Entry,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_append_comment(
object: *mut FLAC__StreamMetadata,
entry: FLAC__StreamMetadata_VorbisComment_Entry,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_replace_comment(
object: *mut FLAC__StreamMetadata,
entry: FLAC__StreamMetadata_VorbisComment_Entry,
all: FLAC__bool,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_delete_comment(
object: *mut FLAC__StreamMetadata,
comment_num: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(
entry: *mut FLAC__StreamMetadata_VorbisComment_Entry,
field_name: *const libc::c_char,
field_value: *const libc::c_char,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(
entry: FLAC__StreamMetadata_VorbisComment_Entry,
field_name: *mut *mut libc::c_char,
field_value: *mut *mut libc::c_char,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_entry_matches(
entry: FLAC__StreamMetadata_VorbisComment_Entry,
field_name: *const libc::c_char,
field_name_length: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_find_entry_from(
object: *const FLAC__StreamMetadata,
offset: u32,
field_name: *const libc::c_char,
) -> libc::c_int;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_remove_entry_matching(
object: *mut FLAC__StreamMetadata,
field_name: *const libc::c_char,
) -> libc::c_int;
}
extern "C" {
pub fn FLAC__metadata_object_vorbiscomment_remove_entries_matching(
object: *mut FLAC__StreamMetadata,
field_name: *const libc::c_char,
) -> libc::c_int;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_track_new() -> *mut FLAC__StreamMetadata_CueSheet_Track;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_track_clone(
object: *const FLAC__StreamMetadata_CueSheet_Track,
) -> *mut FLAC__StreamMetadata_CueSheet_Track;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_track_delete(
object: *mut FLAC__StreamMetadata_CueSheet_Track,
);
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_track_resize_indices(
object: *mut FLAC__StreamMetadata,
track_num: u32,
new_num_indices: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_track_insert_index(
object: *mut FLAC__StreamMetadata,
track_num: u32,
index_num: u32,
index: FLAC__StreamMetadata_CueSheet_Index,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_track_insert_blank_index(
object: *mut FLAC__StreamMetadata,
track_num: u32,
index_num: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_track_delete_index(
object: *mut FLAC__StreamMetadata,
track_num: u32,
index_num: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_resize_tracks(
object: *mut FLAC__StreamMetadata,
new_num_tracks: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_set_track(
object: *mut FLAC__StreamMetadata,
track_num: u32,
track: *mut FLAC__StreamMetadata_CueSheet_Track,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_insert_track(
object: *mut FLAC__StreamMetadata,
track_num: u32,
track: *mut FLAC__StreamMetadata_CueSheet_Track,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_insert_blank_track(
object: *mut FLAC__StreamMetadata,
track_num: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_delete_track(
object: *mut FLAC__StreamMetadata,
track_num: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_is_legal(
object: *const FLAC__StreamMetadata,
check_cd_da_subset: FLAC__bool,
violation: *mut *const libc::c_char,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_cuesheet_calculate_cddb_id(
object: *const FLAC__StreamMetadata,
) -> FLAC__uint32;
}
extern "C" {
pub fn FLAC__metadata_object_picture_set_mime_type(
object: *mut FLAC__StreamMetadata,
mime_type: *mut libc::c_char,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_picture_set_description(
object: *mut FLAC__StreamMetadata,
description: *mut FLAC__byte,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_picture_set_data(
object: *mut FLAC__StreamMetadata,
data: *mut FLAC__byte,
length: FLAC__uint32,
copy: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__metadata_object_picture_is_legal(
object: *const FLAC__StreamMetadata,
violation: *mut *const libc::c_char,
) -> FLAC__bool;
}
pub const FLAC__STREAM_DECODER_SEARCH_FOR_METADATA: FLAC__StreamDecoderState = 0;
pub const FLAC__STREAM_DECODER_READ_METADATA: FLAC__StreamDecoderState = 1;
pub const FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC: FLAC__StreamDecoderState = 2;
pub const FLAC__STREAM_DECODER_READ_FRAME: FLAC__StreamDecoderState = 3;
pub const FLAC__STREAM_DECODER_END_OF_STREAM: FLAC__StreamDecoderState = 4;
pub const FLAC__STREAM_DECODER_OGG_ERROR: FLAC__StreamDecoderState = 5;
pub const FLAC__STREAM_DECODER_SEEK_ERROR: FLAC__StreamDecoderState = 6;
pub const FLAC__STREAM_DECODER_ABORTED: FLAC__StreamDecoderState = 7;
pub const FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR: FLAC__StreamDecoderState = 8;
pub const FLAC__STREAM_DECODER_UNINITIALIZED: FLAC__StreamDecoderState = 9;
pub type FLAC__StreamDecoderState = libc::c_uint;
extern "C" {
pub static FLAC__StreamDecoderStateString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_DECODER_INIT_STATUS_OK: FLAC__StreamDecoderInitStatus = 0;
pub const FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER: FLAC__StreamDecoderInitStatus = 1;
pub const FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS: FLAC__StreamDecoderInitStatus = 2;
pub const FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR: FLAC__StreamDecoderInitStatus =
3;
pub const FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE: FLAC__StreamDecoderInitStatus = 4;
pub const FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED: FLAC__StreamDecoderInitStatus = 5;
pub type FLAC__StreamDecoderInitStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamDecoderInitStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_DECODER_READ_STATUS_CONTINUE: FLAC__StreamDecoderReadStatus = 0;
pub const FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM: FLAC__StreamDecoderReadStatus = 1;
pub const FLAC__STREAM_DECODER_READ_STATUS_ABORT: FLAC__StreamDecoderReadStatus = 2;
pub type FLAC__StreamDecoderReadStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamDecoderReadStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_DECODER_SEEK_STATUS_OK: FLAC__StreamDecoderSeekStatus = 0;
pub const FLAC__STREAM_DECODER_SEEK_STATUS_ERROR: FLAC__StreamDecoderSeekStatus = 1;
pub const FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED: FLAC__StreamDecoderSeekStatus = 2;
pub type FLAC__StreamDecoderSeekStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamDecoderSeekStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_DECODER_TELL_STATUS_OK: FLAC__StreamDecoderTellStatus = 0;
pub const FLAC__STREAM_DECODER_TELL_STATUS_ERROR: FLAC__StreamDecoderTellStatus = 1;
pub const FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED: FLAC__StreamDecoderTellStatus = 2;
pub type FLAC__StreamDecoderTellStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamDecoderTellStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_DECODER_LENGTH_STATUS_OK: FLAC__StreamDecoderLengthStatus = 0;
pub const FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR: FLAC__StreamDecoderLengthStatus = 1;
pub const FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED: FLAC__StreamDecoderLengthStatus = 2;
pub type FLAC__StreamDecoderLengthStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamDecoderLengthStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE: FLAC__StreamDecoderWriteStatus = 0;
pub const FLAC__STREAM_DECODER_WRITE_STATUS_ABORT: FLAC__StreamDecoderWriteStatus = 1;
pub type FLAC__StreamDecoderWriteStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamDecoderWriteStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC: FLAC__StreamDecoderErrorStatus = 0;
pub const FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER: FLAC__StreamDecoderErrorStatus = 1;
pub const FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH: FLAC__StreamDecoderErrorStatus = 2;
pub const FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM: FLAC__StreamDecoderErrorStatus = 3;
pub const FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA: FLAC__StreamDecoderErrorStatus = 4;
pub type FLAC__StreamDecoderErrorStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamDecoderErrorStatusString: [*const libc::c_char; 0usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamDecoderProtected {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamDecoderPrivate {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamDecoder {
pub protected_: *mut FLAC__StreamDecoderProtected,
pub private_: *mut FLAC__StreamDecoderPrivate,
}
#[test]
fn bindgen_test_layout_FLAC__StreamDecoder() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamDecoder> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamDecoder>(),
16usize,
concat!("Size of: ", stringify!(FLAC__StreamDecoder))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamDecoder>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamDecoder))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).protected_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamDecoder),
"::",
stringify!(protected_)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).private_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamDecoder),
"::",
stringify!(private_)
)
);
}
pub type FLAC__StreamDecoderReadCallback = ::core::option::Option<
unsafe extern "C" fn(
decoder: *const FLAC__StreamDecoder,
buffer: *mut FLAC__byte,
bytes: *mut usize,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderReadStatus,
>;
pub type FLAC__StreamDecoderSeekCallback = ::core::option::Option<
unsafe extern "C" fn(
decoder: *const FLAC__StreamDecoder,
absolute_byte_offset: FLAC__uint64,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderSeekStatus,
>;
pub type FLAC__StreamDecoderTellCallback = ::core::option::Option<
unsafe extern "C" fn(
decoder: *const FLAC__StreamDecoder,
absolute_byte_offset: *mut FLAC__uint64,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderTellStatus,
>;
pub type FLAC__StreamDecoderLengthCallback = ::core::option::Option<
unsafe extern "C" fn(
decoder: *const FLAC__StreamDecoder,
stream_length: *mut FLAC__uint64,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderLengthStatus,
>;
pub type FLAC__StreamDecoderEofCallback = ::core::option::Option<
unsafe extern "C" fn(
decoder: *const FLAC__StreamDecoder,
client_data: *mut libc::c_void,
) -> FLAC__bool,
>;
pub type FLAC__StreamDecoderWriteCallback = ::core::option::Option<
unsafe extern "C" fn(
decoder: *const FLAC__StreamDecoder,
frame: *const FLAC__Frame,
buffer: *const *const FLAC__int32,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderWriteStatus,
>;
pub type FLAC__StreamDecoderMetadataCallback = ::core::option::Option<
unsafe extern "C" fn(
decoder: *const FLAC__StreamDecoder,
metadata: *const FLAC__StreamMetadata,
client_data: *mut libc::c_void,
),
>;
pub type FLAC__StreamDecoderErrorCallback = ::core::option::Option<
unsafe extern "C" fn(
decoder: *const FLAC__StreamDecoder,
status: FLAC__StreamDecoderErrorStatus,
client_data: *mut libc::c_void,
),
>;
extern "C" {
pub fn FLAC__stream_decoder_new() -> *mut FLAC__StreamDecoder;
}
extern "C" {
pub fn FLAC__stream_decoder_delete(decoder: *mut FLAC__StreamDecoder);
}
extern "C" {
pub fn FLAC__stream_decoder_set_ogg_serial_number(
decoder: *mut FLAC__StreamDecoder,
serial_number: libc::c_long,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_set_md5_checking(
decoder: *mut FLAC__StreamDecoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_set_metadata_respond(
decoder: *mut FLAC__StreamDecoder,
type_: FLAC__MetadataType,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_set_metadata_respond_application(
decoder: *mut FLAC__StreamDecoder,
id: *const FLAC__byte,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_set_metadata_respond_all(
decoder: *mut FLAC__StreamDecoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_set_metadata_ignore(
decoder: *mut FLAC__StreamDecoder,
type_: FLAC__MetadataType,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_set_metadata_ignore_application(
decoder: *mut FLAC__StreamDecoder,
id: *const FLAC__byte,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_set_metadata_ignore_all(
decoder: *mut FLAC__StreamDecoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_get_state(
decoder: *const FLAC__StreamDecoder,
) -> FLAC__StreamDecoderState;
}
extern "C" {
pub fn FLAC__stream_decoder_get_resolved_state_string(
decoder: *const FLAC__StreamDecoder,
) -> *const libc::c_char;
}
extern "C" {
pub fn FLAC__stream_decoder_get_md5_checking(decoder: *const FLAC__StreamDecoder)
-> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_get_total_samples(
decoder: *const FLAC__StreamDecoder,
) -> FLAC__uint64;
}
extern "C" {
pub fn FLAC__stream_decoder_get_channels(decoder: *const FLAC__StreamDecoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_decoder_get_channel_assignment(
decoder: *const FLAC__StreamDecoder,
) -> FLAC__ChannelAssignment;
}
extern "C" {
pub fn FLAC__stream_decoder_get_bits_per_sample(decoder: *const FLAC__StreamDecoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_decoder_get_sample_rate(decoder: *const FLAC__StreamDecoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_decoder_get_blocksize(decoder: *const FLAC__StreamDecoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_decoder_get_decode_position(
decoder: *const FLAC__StreamDecoder,
position: *mut FLAC__uint64,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_get_client_data(
decoder: *mut FLAC__StreamDecoder,
) -> *const libc::c_void;
}
extern "C" {
pub fn FLAC__stream_decoder_init_stream(
decoder: *mut FLAC__StreamDecoder,
read_callback: FLAC__StreamDecoderReadCallback,
seek_callback: FLAC__StreamDecoderSeekCallback,
tell_callback: FLAC__StreamDecoderTellCallback,
length_callback: FLAC__StreamDecoderLengthCallback,
eof_callback: FLAC__StreamDecoderEofCallback,
write_callback: FLAC__StreamDecoderWriteCallback,
metadata_callback: FLAC__StreamDecoderMetadataCallback,
error_callback: FLAC__StreamDecoderErrorCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_decoder_init_ogg_stream(
decoder: *mut FLAC__StreamDecoder,
read_callback: FLAC__StreamDecoderReadCallback,
seek_callback: FLAC__StreamDecoderSeekCallback,
tell_callback: FLAC__StreamDecoderTellCallback,
length_callback: FLAC__StreamDecoderLengthCallback,
eof_callback: FLAC__StreamDecoderEofCallback,
write_callback: FLAC__StreamDecoderWriteCallback,
metadata_callback: FLAC__StreamDecoderMetadataCallback,
error_callback: FLAC__StreamDecoderErrorCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_decoder_init_FILE(
decoder: *mut FLAC__StreamDecoder,
file: *mut FILE,
write_callback: FLAC__StreamDecoderWriteCallback,
metadata_callback: FLAC__StreamDecoderMetadataCallback,
error_callback: FLAC__StreamDecoderErrorCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_decoder_init_ogg_FILE(
decoder: *mut FLAC__StreamDecoder,
file: *mut FILE,
write_callback: FLAC__StreamDecoderWriteCallback,
metadata_callback: FLAC__StreamDecoderMetadataCallback,
error_callback: FLAC__StreamDecoderErrorCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_decoder_init_file(
decoder: *mut FLAC__StreamDecoder,
filename: *const libc::c_char,
write_callback: FLAC__StreamDecoderWriteCallback,
metadata_callback: FLAC__StreamDecoderMetadataCallback,
error_callback: FLAC__StreamDecoderErrorCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_decoder_init_ogg_file(
decoder: *mut FLAC__StreamDecoder,
filename: *const libc::c_char,
write_callback: FLAC__StreamDecoderWriteCallback,
metadata_callback: FLAC__StreamDecoderMetadataCallback,
error_callback: FLAC__StreamDecoderErrorCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamDecoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_decoder_finish(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_flush(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_reset(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_process_single(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_process_until_end_of_metadata(
decoder: *mut FLAC__StreamDecoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_process_until_end_of_stream(
decoder: *mut FLAC__StreamDecoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_skip_single_frame(decoder: *mut FLAC__StreamDecoder) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_decoder_seek_absolute(
decoder: *mut FLAC__StreamDecoder,
sample: FLAC__uint64,
) -> FLAC__bool;
}
pub const FLAC__STREAM_ENCODER_OK: FLAC__StreamEncoderState = 0;
pub const FLAC__STREAM_ENCODER_UNINITIALIZED: FLAC__StreamEncoderState = 1;
pub const FLAC__STREAM_ENCODER_OGG_ERROR: FLAC__StreamEncoderState = 2;
pub const FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR: FLAC__StreamEncoderState = 3;
pub const FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA: FLAC__StreamEncoderState = 4;
pub const FLAC__STREAM_ENCODER_CLIENT_ERROR: FLAC__StreamEncoderState = 5;
pub const FLAC__STREAM_ENCODER_IO_ERROR: FLAC__StreamEncoderState = 6;
pub const FLAC__STREAM_ENCODER_FRAMING_ERROR: FLAC__StreamEncoderState = 7;
pub const FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR: FLAC__StreamEncoderState = 8;
pub type FLAC__StreamEncoderState = libc::c_uint;
extern "C" {
pub static FLAC__StreamEncoderStateString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_ENCODER_INIT_STATUS_OK: FLAC__StreamEncoderInitStatus = 0;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR: FLAC__StreamEncoderInitStatus = 1;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER: FLAC__StreamEncoderInitStatus = 2;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS: FLAC__StreamEncoderInitStatus = 3;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS:
FLAC__StreamEncoderInitStatus = 4;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE: FLAC__StreamEncoderInitStatus =
5;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE: FLAC__StreamEncoderInitStatus = 6;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE: FLAC__StreamEncoderInitStatus = 7;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER: FLAC__StreamEncoderInitStatus = 8;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION:
FLAC__StreamEncoderInitStatus = 9;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER:
FLAC__StreamEncoderInitStatus = 10;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE: FLAC__StreamEncoderInitStatus = 11;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA: FLAC__StreamEncoderInitStatus = 12;
pub const FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED: FLAC__StreamEncoderInitStatus = 13;
pub type FLAC__StreamEncoderInitStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamEncoderInitStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE: FLAC__StreamEncoderReadStatus = 0;
pub const FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM: FLAC__StreamEncoderReadStatus = 1;
pub const FLAC__STREAM_ENCODER_READ_STATUS_ABORT: FLAC__StreamEncoderReadStatus = 2;
pub const FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED: FLAC__StreamEncoderReadStatus = 3;
pub type FLAC__StreamEncoderReadStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamEncoderReadStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_ENCODER_WRITE_STATUS_OK: FLAC__StreamEncoderWriteStatus = 0;
pub const FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR: FLAC__StreamEncoderWriteStatus = 1;
pub type FLAC__StreamEncoderWriteStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamEncoderWriteStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_ENCODER_SEEK_STATUS_OK: FLAC__StreamEncoderSeekStatus = 0;
pub const FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR: FLAC__StreamEncoderSeekStatus = 1;
pub const FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED: FLAC__StreamEncoderSeekStatus = 2;
pub type FLAC__StreamEncoderSeekStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamEncoderSeekStatusString: [*const libc::c_char; 0usize];
}
pub const FLAC__STREAM_ENCODER_TELL_STATUS_OK: FLAC__StreamEncoderTellStatus = 0;
pub const FLAC__STREAM_ENCODER_TELL_STATUS_ERROR: FLAC__StreamEncoderTellStatus = 1;
pub const FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED: FLAC__StreamEncoderTellStatus = 2;
pub type FLAC__StreamEncoderTellStatus = libc::c_uint;
extern "C" {
pub static FLAC__StreamEncoderTellStatusString: [*const libc::c_char; 0usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamEncoderProtected {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamEncoderPrivate {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FLAC__StreamEncoder {
pub protected_: *mut FLAC__StreamEncoderProtected,
pub private_: *mut FLAC__StreamEncoderPrivate,
}
#[test]
fn bindgen_test_layout_FLAC__StreamEncoder() {
const UNINIT: ::core::mem::MaybeUninit<FLAC__StreamEncoder> =
::core::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::core::mem::size_of::<FLAC__StreamEncoder>(),
16usize,
concat!("Size of: ", stringify!(FLAC__StreamEncoder))
);
assert_eq!(
::core::mem::align_of::<FLAC__StreamEncoder>(),
8usize,
concat!("Alignment of ", stringify!(FLAC__StreamEncoder))
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).protected_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamEncoder),
"::",
stringify!(protected_)
)
);
assert_eq!(
unsafe { ::core::ptr::addr_of!((*ptr).private_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FLAC__StreamEncoder),
"::",
stringify!(private_)
)
);
}
pub type FLAC__StreamEncoderReadCallback = ::core::option::Option<
unsafe extern "C" fn(
encoder: *const FLAC__StreamEncoder,
buffer: *mut FLAC__byte,
bytes: *mut usize,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderReadStatus,
>;
pub type FLAC__StreamEncoderWriteCallback = ::core::option::Option<
unsafe extern "C" fn(
encoder: *const FLAC__StreamEncoder,
buffer: *const FLAC__byte,
bytes: usize,
samples: u32,
current_frame: u32,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderWriteStatus,
>;
pub type FLAC__StreamEncoderSeekCallback = ::core::option::Option<
unsafe extern "C" fn(
encoder: *const FLAC__StreamEncoder,
absolute_byte_offset: FLAC__uint64,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderSeekStatus,
>;
pub type FLAC__StreamEncoderTellCallback = ::core::option::Option<
unsafe extern "C" fn(
encoder: *const FLAC__StreamEncoder,
absolute_byte_offset: *mut FLAC__uint64,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderTellStatus,
>;
pub type FLAC__StreamEncoderMetadataCallback = ::core::option::Option<
unsafe extern "C" fn(
encoder: *const FLAC__StreamEncoder,
metadata: *const FLAC__StreamMetadata,
client_data: *mut libc::c_void,
),
>;
pub type FLAC__StreamEncoderProgressCallback = ::core::option::Option<
unsafe extern "C" fn(
encoder: *const FLAC__StreamEncoder,
bytes_written: FLAC__uint64,
samples_written: FLAC__uint64,
frames_written: u32,
total_frames_estimate: u32,
client_data: *mut libc::c_void,
),
>;
extern "C" {
pub fn FLAC__stream_encoder_new() -> *mut FLAC__StreamEncoder;
}
extern "C" {
pub fn FLAC__stream_encoder_delete(encoder: *mut FLAC__StreamEncoder);
}
extern "C" {
pub fn FLAC__stream_encoder_set_ogg_serial_number(
encoder: *mut FLAC__StreamEncoder,
serial_number: libc::c_long,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_verify(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_streamable_subset(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_channels(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_bits_per_sample(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_sample_rate(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_compression_level(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_blocksize(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_do_mid_side_stereo(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_loose_mid_side_stereo(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_apodization(
encoder: *mut FLAC__StreamEncoder,
specification: *const libc::c_char,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_max_lpc_order(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_qlp_coeff_precision(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_do_qlp_coeff_prec_search(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_do_escape_coding(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_do_exhaustive_model_search(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_min_residual_partition_order(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_max_residual_partition_order(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_rice_parameter_search_dist(
encoder: *mut FLAC__StreamEncoder,
value: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_total_samples_estimate(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__uint64,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_metadata(
encoder: *mut FLAC__StreamEncoder,
metadata: *mut *mut FLAC__StreamMetadata,
num_blocks: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_set_limit_min_bitrate(
encoder: *mut FLAC__StreamEncoder,
value: FLAC__bool,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_get_state(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__StreamEncoderState;
}
extern "C" {
pub fn FLAC__stream_encoder_get_verify_decoder_state(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__StreamDecoderState;
}
extern "C" {
pub fn FLAC__stream_encoder_get_resolved_state_string(
encoder: *const FLAC__StreamEncoder,
) -> *const libc::c_char;
}
extern "C" {
pub fn FLAC__stream_encoder_get_verify_decoder_error_stats(
encoder: *const FLAC__StreamEncoder,
absolute_sample: *mut FLAC__uint64,
frame_number: *mut u32,
channel: *mut u32,
sample: *mut u32,
expected: *mut FLAC__int32,
got: *mut FLAC__int32,
);
}
extern "C" {
pub fn FLAC__stream_encoder_get_verify(encoder: *const FLAC__StreamEncoder) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_get_streamable_subset(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_get_channels(encoder: *const FLAC__StreamEncoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_bits_per_sample(encoder: *const FLAC__StreamEncoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_sample_rate(encoder: *const FLAC__StreamEncoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_blocksize(encoder: *const FLAC__StreamEncoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_do_mid_side_stereo(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_get_loose_mid_side_stereo(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_get_max_lpc_order(encoder: *const FLAC__StreamEncoder) -> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_qlp_coeff_precision(encoder: *const FLAC__StreamEncoder)
-> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_do_qlp_coeff_prec_search(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_get_do_escape_coding(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_get_do_exhaustive_model_search(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_get_min_residual_partition_order(
encoder: *const FLAC__StreamEncoder,
) -> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_max_residual_partition_order(
encoder: *const FLAC__StreamEncoder,
) -> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_rice_parameter_search_dist(
encoder: *const FLAC__StreamEncoder,
) -> u32;
}
extern "C" {
pub fn FLAC__stream_encoder_get_total_samples_estimate(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__uint64;
}
extern "C" {
pub fn FLAC__stream_encoder_get_limit_min_bitrate(
encoder: *const FLAC__StreamEncoder,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_init_stream(
encoder: *mut FLAC__StreamEncoder,
write_callback: FLAC__StreamEncoderWriteCallback,
seek_callback: FLAC__StreamEncoderSeekCallback,
tell_callback: FLAC__StreamEncoderTellCallback,
metadata_callback: FLAC__StreamEncoderMetadataCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_encoder_init_ogg_stream(
encoder: *mut FLAC__StreamEncoder,
read_callback: FLAC__StreamEncoderReadCallback,
write_callback: FLAC__StreamEncoderWriteCallback,
seek_callback: FLAC__StreamEncoderSeekCallback,
tell_callback: FLAC__StreamEncoderTellCallback,
metadata_callback: FLAC__StreamEncoderMetadataCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_encoder_init_FILE(
encoder: *mut FLAC__StreamEncoder,
file: *mut FILE,
progress_callback: FLAC__StreamEncoderProgressCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_encoder_init_ogg_FILE(
encoder: *mut FLAC__StreamEncoder,
file: *mut FILE,
progress_callback: FLAC__StreamEncoderProgressCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_encoder_init_file(
encoder: *mut FLAC__StreamEncoder,
filename: *const libc::c_char,
progress_callback: FLAC__StreamEncoderProgressCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_encoder_init_ogg_file(
encoder: *mut FLAC__StreamEncoder,
filename: *const libc::c_char,
progress_callback: FLAC__StreamEncoderProgressCallback,
client_data: *mut libc::c_void,
) -> FLAC__StreamEncoderInitStatus;
}
extern "C" {
pub fn FLAC__stream_encoder_finish(encoder: *mut FLAC__StreamEncoder) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_process(
encoder: *mut FLAC__StreamEncoder,
buffer: *const *const FLAC__int32,
samples: u32,
) -> FLAC__bool;
}
extern "C" {
pub fn FLAC__stream_encoder_process_interleaved(
encoder: *mut FLAC__StreamEncoder,
buffer: *const FLAC__int32,
samples: u32,
) -> FLAC__bool;
}