#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(dead_code)]
pub const __MINGW64_VERSION_MAJOR: u32 = 8;
pub const __MINGW64_VERSION_MINOR: u32 = 0;
pub const __MINGW64_VERSION_BUGFIX: u32 = 0;
pub const __MINGW64_VERSION_RC: u32 = 0;
pub const __MINGW64_VERSION_STATE: &'static [u8; 6usize] = b"alpha\0";
pub const __MINGW32_MAJOR_VERSION: u32 = 3;
pub const __MINGW32_MINOR_VERSION: u32 = 11;
pub const _M_AMD64: u32 = 100;
pub const _M_X64: u32 = 100;
pub const __: u32 = 1;
pub const __MINGW_USE_UNDERSCORE_PREFIX: u32 = 0;
pub const __MINGW_HAVE_ANSI_C99_PRINTF: u32 = 1;
pub const __MINGW_HAVE_WIDE_C99_PRINTF: u32 = 1;
pub const __MINGW_HAVE_ANSI_C99_SCANF: u32 = 1;
pub const __MINGW_HAVE_WIDE_C99_SCANF: u32 = 1;
pub const __MINGW_SEC_WARN_STR : & 'static [ u8 ; 92usize ] = b"This function or variable may be unsafe, use _CRT_SECURE_NO_WARNINGS to disable deprecation\0" ;
pub const __MINGW_MSVC2005_DEPREC_STR : & 'static [ u8 ; 117usize ] = b"This POSIX function is deprecated beginning in Visual C++ 2005, use _CRT_NONSTDC_NO_DEPRECATE to disable deprecation\0" ;
pub const __MINGW_FORTIFY_LEVEL: u32 = 0;
pub const __MINGW_FORTIFY_VA_ARG: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY: u32 = 0;
pub const __USE_CRTIMP: u32 = 1;
pub const USE___UUIDOF: u32 = 0;
pub const __CRT__NO_INLINE: u32 = 1;
pub const __MSVCRT_VERSION__: u32 = 1792;
pub const _WIN32_WINNT: u32 = 1537;
pub const MINGW_HAS_SECURE_API: u32 = 1;
pub const __STDC_SECURE_LIB__: u32 = 200411;
pub const __GOT_SECURE_LIB__: u32 = 200411;
pub const MINGW_HAS_DDK_H: u32 = 1;
pub const _CRT_PACKING: u32 = 8;
pub const _SECURECRT_FILL_BUFFER_PATTERN: u32 = 253;
pub const _ARGMAX: u32 = 100;
pub const __USE_MINGW_ANSI_STDIO: u32 = 0;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT64_MIN: i64 = -9223372036854775808;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const INT64_MAX: u64 = 9223372036854775807;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const UINT64_MAX: i32 = -1;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const UINT_LEAST64_MAX: i32 = -1;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i32 = -32768;
pub const INT_FAST32_MIN: i32 = -2147483648;
pub const INT_FAST64_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u32 = 32767;
pub const INT_FAST32_MAX: u32 = 2147483647;
pub const INT_FAST64_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: u32 = 65535;
pub const UINT_FAST32_MAX: u32 = 4294967295;
pub const UINT_FAST64_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const INTMAX_MIN: i64 = -9223372036854775808;
pub const INTMAX_MAX: u64 = 9223372036854775807;
pub const UINTMAX_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WCHAR_MIN: u32 = 0;
pub const WCHAR_MAX: u32 = 65535;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 65535;
pub const OPUS_OK: u32 = 0;
pub const OPUS_BAD_ARG: i32 = -1;
pub const OPUS_BUFFER_TOO_SMALL: i32 = -2;
pub const OPUS_INTERNAL_ERROR: i32 = -3;
pub const OPUS_INVALID_PACKET: i32 = -4;
pub const OPUS_UNIMPLEMENTED: i32 = -5;
pub const OPUS_INVALID_STATE: i32 = -6;
pub const OPUS_ALLOC_FAIL: i32 = -7;
pub const OPUS_SET_APPLICATION_REQUEST: u32 = 4000;
pub const OPUS_GET_APPLICATION_REQUEST: u32 = 4001;
pub const OPUS_SET_BITRATE_REQUEST: u32 = 4002;
pub const OPUS_GET_BITRATE_REQUEST: u32 = 4003;
pub const OPUS_SET_MAX_BANDWIDTH_REQUEST: u32 = 4004;
pub const OPUS_GET_MAX_BANDWIDTH_REQUEST: u32 = 4005;
pub const OPUS_SET_VBR_REQUEST: u32 = 4006;
pub const OPUS_GET_VBR_REQUEST: u32 = 4007;
pub const OPUS_SET_BANDWIDTH_REQUEST: u32 = 4008;
pub const OPUS_GET_BANDWIDTH_REQUEST: u32 = 4009;
pub const OPUS_SET_COMPLEXITY_REQUEST: u32 = 4010;
pub const OPUS_GET_COMPLEXITY_REQUEST: u32 = 4011;
pub const OPUS_SET_INBAND_FEC_REQUEST: u32 = 4012;
pub const OPUS_GET_INBAND_FEC_REQUEST: u32 = 4013;
pub const OPUS_SET_PACKET_LOSS_PERC_REQUEST: u32 = 4014;
pub const OPUS_GET_PACKET_LOSS_PERC_REQUEST: u32 = 4015;
pub const OPUS_SET_DTX_REQUEST: u32 = 4016;
pub const OPUS_GET_DTX_REQUEST: u32 = 4017;
pub const OPUS_SET_VBR_CONSTRAINT_REQUEST: u32 = 4020;
pub const OPUS_GET_VBR_CONSTRAINT_REQUEST: u32 = 4021;
pub const OPUS_SET_FORCE_CHANNELS_REQUEST: u32 = 4022;
pub const OPUS_GET_FORCE_CHANNELS_REQUEST: u32 = 4023;
pub const OPUS_SET_SIGNAL_REQUEST: u32 = 4024;
pub const OPUS_GET_SIGNAL_REQUEST: u32 = 4025;
pub const OPUS_GET_LOOKAHEAD_REQUEST: u32 = 4027;
pub const OPUS_GET_SAMPLE_RATE_REQUEST: u32 = 4029;
pub const OPUS_GET_FINAL_RANGE_REQUEST: u32 = 4031;
pub const OPUS_GET_PITCH_REQUEST: u32 = 4033;
pub const OPUS_SET_GAIN_REQUEST: u32 = 4034;
pub const OPUS_GET_GAIN_REQUEST: u32 = 4045;
pub const OPUS_SET_LSB_DEPTH_REQUEST: u32 = 4036;
pub const OPUS_GET_LSB_DEPTH_REQUEST: u32 = 4037;
pub const OPUS_GET_LAST_PACKET_DURATION_REQUEST: u32 = 4039;
pub const OPUS_SET_EXPERT_FRAME_DURATION_REQUEST: u32 = 4040;
pub const OPUS_GET_EXPERT_FRAME_DURATION_REQUEST: u32 = 4041;
pub const OPUS_SET_PREDICTION_DISABLED_REQUEST: u32 = 4042;
pub const OPUS_GET_PREDICTION_DISABLED_REQUEST: u32 = 4043;
pub const OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST: u32 = 4046;
pub const OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST: u32 = 4047;
pub const OPUS_GET_IN_DTX_REQUEST: u32 = 4049;
pub const OPUS_AUTO: i32 = -1000;
pub const OPUS_BITRATE_MAX: i32 = -1;
pub const OPUS_APPLICATION_VOIP: u32 = 2048;
pub const OPUS_APPLICATION_AUDIO: u32 = 2049;
pub const OPUS_APPLICATION_RESTRICTED_LOWDELAY: u32 = 2051;
pub const OPUS_SIGNAL_VOICE: u32 = 3001;
pub const OPUS_SIGNAL_MUSIC: u32 = 3002;
pub const OPUS_BANDWIDTH_NARROWBAND: u32 = 1101;
pub const OPUS_BANDWIDTH_MEDIUMBAND: u32 = 1102;
pub const OPUS_BANDWIDTH_WIDEBAND: u32 = 1103;
pub const OPUS_BANDWIDTH_SUPERWIDEBAND: u32 = 1104;
pub const OPUS_BANDWIDTH_FULLBAND: u32 = 1105;
pub const OPUS_FRAMESIZE_ARG: u32 = 5000;
pub const OPUS_FRAMESIZE_2_5_MS: u32 = 5001;
pub const OPUS_FRAMESIZE_5_MS: u32 = 5002;
pub const OPUS_FRAMESIZE_10_MS: u32 = 5003;
pub const OPUS_FRAMESIZE_20_MS: u32 = 5004;
pub const OPUS_FRAMESIZE_40_MS: u32 = 5005;
pub const OPUS_FRAMESIZE_60_MS: u32 = 5006;
pub const OPUS_FRAMESIZE_80_MS: u32 = 5007;
pub const OPUS_FRAMESIZE_100_MS: u32 = 5008;
pub const OPUS_FRAMESIZE_120_MS: u32 = 5009;
pub const OPUS_RESET_STATE: u32 = 4028;
pub type __gnuc_va_list = __builtin_va_list;
pub type va_list = __gnuc_va_list;
extern "C" {
pub fn __debugbreak();
}
extern "C" {
pub fn __mingw_get_crt_info() -> *const ::std::os::raw::c_char;
}
pub type size_t = ::std::os::raw::c_ulonglong;
pub type ssize_t = ::std::os::raw::c_longlong;
pub type rsize_t = size_t;
pub type wchar_t = ::std::os::raw::c_ushort;
pub type wint_t = ::std::os::raw::c_ushort;
pub type wctype_t = ::std::os::raw::c_ushort;
pub type errno_t = ::std::os::raw::c_int;
pub type __time32_t = ::std::os::raw::c_long;
pub type __time64_t = ::std::os::raw::c_longlong;
pub type time_t = __time64_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct threadmbcinfostruct {
_unused: [u8; 0],
}
pub type pthreadlocinfo = *mut threadlocaleinfostruct;
pub type pthreadmbcinfo = *mut threadmbcinfostruct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __lc_time_data {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct localeinfo_struct {
pub locinfo: pthreadlocinfo,
pub mbcinfo: pthreadmbcinfo,
}
#[test]
fn bindgen_test_layout_localeinfo_struct() {
assert_eq!(
::std::mem::size_of::<localeinfo_struct>(),
16usize,
concat!("Size of: ", stringify!(localeinfo_struct))
);
assert_eq!(
::std::mem::align_of::<localeinfo_struct>(),
8usize,
concat!("Alignment of ", stringify!(localeinfo_struct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<localeinfo_struct>())).locinfo as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(localeinfo_struct),
"::",
stringify!(locinfo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<localeinfo_struct>())).mbcinfo as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(localeinfo_struct),
"::",
stringify!(mbcinfo)
)
);
}
pub type _locale_tstruct = localeinfo_struct;
pub type _locale_t = *mut localeinfo_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tagLC_ID {
pub wLanguage: ::std::os::raw::c_ushort,
pub wCountry: ::std::os::raw::c_ushort,
pub wCodePage: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_tagLC_ID() {
assert_eq!(
::std::mem::size_of::<tagLC_ID>(),
6usize,
concat!("Size of: ", stringify!(tagLC_ID))
);
assert_eq!(
::std::mem::align_of::<tagLC_ID>(),
2usize,
concat!("Alignment of ", stringify!(tagLC_ID))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagLC_ID>())).wLanguage as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tagLC_ID),
"::",
stringify!(wLanguage)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagLC_ID>())).wCountry as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(tagLC_ID),
"::",
stringify!(wCountry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tagLC_ID>())).wCodePage as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(tagLC_ID),
"::",
stringify!(wCodePage)
)
);
}
pub type LC_ID = tagLC_ID;
pub type LPLC_ID = *mut tagLC_ID;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct threadlocaleinfostruct {
pub refcount: ::std::os::raw::c_int,
pub lc_codepage: ::std::os::raw::c_uint,
pub lc_collate_cp: ::std::os::raw::c_uint,
pub lc_handle: [::std::os::raw::c_ulong; 6usize],
pub lc_id: [LC_ID; 6usize],
pub lc_category: [threadlocaleinfostruct__bindgen_ty_1; 6usize],
pub lc_clike: ::std::os::raw::c_int,
pub mb_cur_max: ::std::os::raw::c_int,
pub lconv_intl_refcount: *mut ::std::os::raw::c_int,
pub lconv_num_refcount: *mut ::std::os::raw::c_int,
pub lconv_mon_refcount: *mut ::std::os::raw::c_int,
pub lconv: *mut lconv,
pub ctype1_refcount: *mut ::std::os::raw::c_int,
pub ctype1: *mut ::std::os::raw::c_ushort,
pub pctype: *const ::std::os::raw::c_ushort,
pub pclmap: *const ::std::os::raw::c_uchar,
pub pcumap: *const ::std::os::raw::c_uchar,
pub lc_time_curr: *mut __lc_time_data,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct threadlocaleinfostruct__bindgen_ty_1 {
pub locale: *mut ::std::os::raw::c_char,
pub wlocale: *mut wchar_t,
pub refcount: *mut ::std::os::raw::c_int,
pub wrefcount: *mut ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_threadlocaleinfostruct__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<threadlocaleinfostruct__bindgen_ty_1>(),
32usize,
concat!(
"Size of: ",
stringify!(threadlocaleinfostruct__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<threadlocaleinfostruct__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(threadlocaleinfostruct__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct__bindgen_ty_1>())).locale as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct__bindgen_ty_1),
"::",
stringify!(locale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct__bindgen_ty_1>())).wlocale as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct__bindgen_ty_1),
"::",
stringify!(wlocale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct__bindgen_ty_1>())).refcount as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct__bindgen_ty_1),
"::",
stringify!(refcount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct__bindgen_ty_1>())).wrefcount as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct__bindgen_ty_1),
"::",
stringify!(wrefcount)
)
);
}
#[test]
fn bindgen_test_layout_threadlocaleinfostruct() {
assert_eq!(
::std::mem::size_of::<threadlocaleinfostruct>(),
352usize,
concat!("Size of: ", stringify!(threadlocaleinfostruct))
);
assert_eq!(
::std::mem::align_of::<threadlocaleinfostruct>(),
8usize,
concat!("Alignment of ", stringify!(threadlocaleinfostruct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<threadlocaleinfostruct>())).refcount as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(refcount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).lc_codepage as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lc_codepage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).lc_collate_cp as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lc_collate_cp)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).lc_handle as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lc_handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<threadlocaleinfostruct>())).lc_id as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lc_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).lc_category as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lc_category)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<threadlocaleinfostruct>())).lc_clike as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lc_clike)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).mb_cur_max as *const _ as usize
},
268usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(mb_cur_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).lconv_intl_refcount as *const _
as usize
},
272usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lconv_intl_refcount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).lconv_num_refcount as *const _
as usize
},
280usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lconv_num_refcount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).lconv_mon_refcount as *const _
as usize
},
288usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lconv_mon_refcount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<threadlocaleinfostruct>())).lconv as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lconv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).ctype1_refcount as *const _ as usize
},
304usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(ctype1_refcount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<threadlocaleinfostruct>())).ctype1 as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(ctype1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<threadlocaleinfostruct>())).pctype as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(pctype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<threadlocaleinfostruct>())).pclmap as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(pclmap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<threadlocaleinfostruct>())).pcumap as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(pcumap)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<threadlocaleinfostruct>())).lc_time_curr as *const _ as usize
},
344usize,
concat!(
"Offset of field: ",
stringify!(threadlocaleinfostruct),
"::",
stringify!(lc_time_curr)
)
);
}
pub type threadlocinfo = threadlocaleinfostruct;
pub type int_least8_t = ::std::os::raw::c_schar;
pub type uint_least8_t = ::std::os::raw::c_uchar;
pub type int_least16_t = ::std::os::raw::c_short;
pub type uint_least16_t = ::std::os::raw::c_ushort;
pub type int_least32_t = ::std::os::raw::c_int;
pub type uint_least32_t = ::std::os::raw::c_uint;
pub type int_least64_t = ::std::os::raw::c_longlong;
pub type uint_least64_t = ::std::os::raw::c_ulonglong;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type int_fast16_t = ::std::os::raw::c_short;
pub type uint_fast16_t = ::std::os::raw::c_ushort;
pub type int_fast32_t = ::std::os::raw::c_int;
pub type uint_fast32_t = ::std::os::raw::c_uint;
pub type int_fast64_t = ::std::os::raw::c_longlong;
pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
pub type intmax_t = ::std::os::raw::c_longlong;
pub type uintmax_t = ::std::os::raw::c_ulonglong;
pub type opus_int8 = i8;
pub type opus_uint8 = u8;
pub type opus_int16 = i16;
pub type opus_uint16 = u16;
pub type opus_int32 = i32;
pub type opus_uint32 = u32;
pub type opus_int64 = i64;
pub type opus_uint64 = u64;
extern "C" {
#[doc = " Converts an opus error code into a human readable string."]
#[doc = ""]
#[doc = " @param[in] error <tt>int</tt>: Error number"]
#[doc = " @returns Error string"]
pub fn opus_strerror(error: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Gets the libopus version string."]
#[doc = ""]
#[doc = " Applications may look for the substring \"-fixed\" in the version string to"]
#[doc = " determine whether they have a fixed-point or floating-point build at"]
#[doc = " runtime."]
#[doc = ""]
#[doc = " @returns Version string"]
pub fn opus_get_version_string() -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpusEncoder {
_unused: [u8; 0],
}
extern "C" {
#[doc = " Gets the size of an <code>OpusEncoder</code> structure."]
#[doc = " @param[in] channels <tt>int</tt>: Number of channels."]
#[doc = " This must be 1 or 2."]
#[doc = " @returns The size in bytes."]
pub fn opus_encoder_get_size(channels: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Allocates and initializes an encoder state."]
#[doc = " There are three coding modes:"]
#[doc = ""]
#[doc = " @ref OPUS_APPLICATION_VOIP gives best quality at a given bitrate for voice"]
#[doc = " signals. It enhances the input signal by high-pass filtering and"]
#[doc = " emphasizing formants and harmonics. Optionally it includes in-band"]
#[doc = " forward error correction to protect against packet loss. Use this"]
#[doc = " mode for typical VoIP applications. Because of the enhancement,"]
#[doc = " even at high bitrates the output may sound different from the input."]
#[doc = ""]
#[doc = " @ref OPUS_APPLICATION_AUDIO gives best quality at a given bitrate for most"]
#[doc = " non-voice signals like music. Use this mode for music and mixed"]
#[doc = " (music/voice) content, broadcast, and applications requiring less"]
#[doc = " than 15 ms of coding delay."]
#[doc = ""]
#[doc = " @ref OPUS_APPLICATION_RESTRICTED_LOWDELAY configures low-delay mode that"]
#[doc = " disables the speech-optimized mode in exchange for slightly reduced delay."]
#[doc = " This mode can only be set on an newly initialized or freshly reset encoder"]
#[doc = " because it changes the codec delay."]
#[doc = ""]
#[doc = " This is useful when the caller knows that the speech-optimized modes will not be needed (use with caution)."]
#[doc = " @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)"]
#[doc = " This must be one of 8000, 12000, 16000,"]
#[doc = " 24000, or 48000."]
#[doc = " @param [in] channels <tt>int</tt>: Number of channels (1 or 2) in input signal"]
#[doc = " @param [in] application <tt>int</tt>: Coding mode (@ref OPUS_APPLICATION_VOIP/@ref OPUS_APPLICATION_AUDIO/@ref OPUS_APPLICATION_RESTRICTED_LOWDELAY)"]
#[doc = " @param [out] error <tt>int*</tt>: @ref opus_errorcodes"]
#[doc = " @note Regardless of the sampling rate and number channels selected, the Opus encoder"]
#[doc = " can switch to a lower audio bandwidth or number of channels if the bitrate"]
#[doc = " selected is too low. This also means that it is safe to always use 48 kHz stereo input"]
#[doc = " and let the encoder optimize the encoding."]
pub fn opus_encoder_create(
Fs: opus_int32,
channels: ::std::os::raw::c_int,
application: ::std::os::raw::c_int,
error: *mut ::std::os::raw::c_int,
) -> *mut OpusEncoder;
}
extern "C" {
#[doc = " Initializes a previously allocated encoder state"]
#[doc = " The memory pointed to by st must be at least the size returned by opus_encoder_get_size()."]
#[doc = " This is intended for applications which use their own allocator instead of malloc."]
#[doc = " @see opus_encoder_create(),opus_encoder_get_size()"]
#[doc = " To reset a previously initialized state, use the #OPUS_RESET_STATE CTL."]
#[doc = " @param [in] st <tt>OpusEncoder*</tt>: Encoder state"]
#[doc = " @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)"]
#[doc = " This must be one of 8000, 12000, 16000,"]
#[doc = " 24000, or 48000."]
#[doc = " @param [in] channels <tt>int</tt>: Number of channels (1 or 2) in input signal"]
#[doc = " @param [in] application <tt>int</tt>: Coding mode (OPUS_APPLICATION_VOIP/OPUS_APPLICATION_AUDIO/OPUS_APPLICATION_RESTRICTED_LOWDELAY)"]
#[doc = " @retval #OPUS_OK Success or @ref opus_errorcodes"]
pub fn opus_encoder_init(
st: *mut OpusEncoder,
Fs: opus_int32,
channels: ::std::os::raw::c_int,
application: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Encodes an Opus frame."]
#[doc = " @param [in] st <tt>OpusEncoder*</tt>: Encoder state"]
#[doc = " @param [in] pcm <tt>opus_int16*</tt>: Input signal (interleaved if 2 channels). length is frame_size*channels*sizeof(opus_int16)"]
#[doc = " @param [in] frame_size <tt>int</tt>: Number of samples per channel in the"]
#[doc = " input signal."]
#[doc = " This must be an Opus frame size for"]
#[doc = " the encoder's sampling rate."]
#[doc = " For example, at 48 kHz the permitted"]
#[doc = " values are 120, 240, 480, 960, 1920,"]
#[doc = " and 2880."]
#[doc = " Passing in a duration of less than"]
#[doc = " 10 ms (480 samples at 48 kHz) will"]
#[doc = " prevent the encoder from using the LPC"]
#[doc = " or hybrid modes."]
#[doc = " @param [out] data <tt>unsigned char*</tt>: Output payload."]
#[doc = " This must contain storage for at"]
#[doc = " least \\a max_data_bytes."]
#[doc = " @param [in] max_data_bytes <tt>opus_int32</tt>: Size of the allocated"]
#[doc = " memory for the output"]
#[doc = " payload. This may be"]
#[doc = " used to impose an upper limit on"]
#[doc = " the instant bitrate, but should"]
#[doc = " not be used as the only bitrate"]
#[doc = " control. Use #OPUS_SET_BITRATE to"]
#[doc = " control the bitrate."]
#[doc = " @returns The length of the encoded packet (in bytes) on success or a"]
#[doc = " negative error code (see @ref opus_errorcodes) on failure."]
pub fn opus_encode(
st: *mut OpusEncoder,
pcm: *const opus_int16,
frame_size: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_uchar,
max_data_bytes: opus_int32,
) -> opus_int32;
}
extern "C" {
#[doc = " Encodes an Opus frame from floating point input."]
#[doc = " @param [in] st <tt>OpusEncoder*</tt>: Encoder state"]
#[doc = " @param [in] pcm <tt>float*</tt>: Input in float format (interleaved if 2 channels), with a normal range of +/-1.0."]
#[doc = " Samples with a range beyond +/-1.0 are supported but will"]
#[doc = " be clipped by decoders using the integer API and should"]
#[doc = " only be used if it is known that the far end supports"]
#[doc = " extended dynamic range."]
#[doc = " length is frame_size*channels*sizeof(float)"]
#[doc = " @param [in] frame_size <tt>int</tt>: Number of samples per channel in the"]
#[doc = " input signal."]
#[doc = " This must be an Opus frame size for"]
#[doc = " the encoder's sampling rate."]
#[doc = " For example, at 48 kHz the permitted"]
#[doc = " values are 120, 240, 480, 960, 1920,"]
#[doc = " and 2880."]
#[doc = " Passing in a duration of less than"]
#[doc = " 10 ms (480 samples at 48 kHz) will"]
#[doc = " prevent the encoder from using the LPC"]
#[doc = " or hybrid modes."]
#[doc = " @param [out] data <tt>unsigned char*</tt>: Output payload."]
#[doc = " This must contain storage for at"]
#[doc = " least \\a max_data_bytes."]
#[doc = " @param [in] max_data_bytes <tt>opus_int32</tt>: Size of the allocated"]
#[doc = " memory for the output"]
#[doc = " payload. This may be"]
#[doc = " used to impose an upper limit on"]
#[doc = " the instant bitrate, but should"]
#[doc = " not be used as the only bitrate"]
#[doc = " control. Use #OPUS_SET_BITRATE to"]
#[doc = " control the bitrate."]
#[doc = " @returns The length of the encoded packet (in bytes) on success or a"]
#[doc = " negative error code (see @ref opus_errorcodes) on failure."]
pub fn opus_encode_float(
st: *mut OpusEncoder,
pcm: *const f32,
frame_size: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_uchar,
max_data_bytes: opus_int32,
) -> opus_int32;
}
extern "C" {
#[doc = " Frees an <code>OpusEncoder</code> allocated by opus_encoder_create()."]
#[doc = " @param[in] st <tt>OpusEncoder*</tt>: State to be freed."]
pub fn opus_encoder_destroy(st: *mut OpusEncoder);
}
extern "C" {
#[doc = " Perform a CTL function on an Opus encoder."]
#[doc = ""]
#[doc = " Generally the request and subsequent arguments are generated"]
#[doc = " by a convenience macro."]
#[doc = " @param st <tt>OpusEncoder*</tt>: Encoder state."]
#[doc = " @param request This and all remaining parameters should be replaced by one"]
#[doc = " of the convenience macros in @ref opus_genericctls or"]
#[doc = " @ref opus_encoderctls."]
#[doc = " @see opus_genericctls"]
#[doc = " @see opus_encoderctls"]
pub fn opus_encoder_ctl(
st: *mut OpusEncoder,
request: ::std::os::raw::c_int,
...
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpusDecoder {
_unused: [u8; 0],
}
extern "C" {
#[doc = " Gets the size of an <code>OpusDecoder</code> structure."]
#[doc = " @param [in] channels <tt>int</tt>: Number of channels."]
#[doc = " This must be 1 or 2."]
#[doc = " @returns The size in bytes."]
pub fn opus_decoder_get_size(channels: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Allocates and initializes a decoder state."]
#[doc = " @param [in] Fs <tt>opus_int32</tt>: Sample rate to decode at (Hz)."]
#[doc = " This must be one of 8000, 12000, 16000,"]
#[doc = " 24000, or 48000."]
#[doc = " @param [in] channels <tt>int</tt>: Number of channels (1 or 2) to decode"]
#[doc = " @param [out] error <tt>int*</tt>: #OPUS_OK Success or @ref opus_errorcodes"]
#[doc = ""]
#[doc = " Internally Opus stores data at 48000 Hz, so that should be the default"]
#[doc = " value for Fs. However, the decoder can efficiently decode to buffers"]
#[doc = " at 8, 12, 16, and 24 kHz so if for some reason the caller cannot use"]
#[doc = " data at the full sample rate, or knows the compressed data doesn't"]
#[doc = " use the full frequency range, it can request decoding at a reduced"]
#[doc = " rate. Likewise, the decoder is capable of filling in either mono or"]
#[doc = " interleaved stereo pcm buffers, at the caller's request."]
pub fn opus_decoder_create(
Fs: opus_int32,
channels: ::std::os::raw::c_int,
error: *mut ::std::os::raw::c_int,
) -> *mut OpusDecoder;
}
extern "C" {
#[doc = " Initializes a previously allocated decoder state."]
#[doc = " The state must be at least the size returned by opus_decoder_get_size()."]
#[doc = " This is intended for applications which use their own allocator instead of malloc. @see opus_decoder_create,opus_decoder_get_size"]
#[doc = " To reset a previously initialized state, use the #OPUS_RESET_STATE CTL."]
#[doc = " @param [in] st <tt>OpusDecoder*</tt>: Decoder state."]
#[doc = " @param [in] Fs <tt>opus_int32</tt>: Sampling rate to decode to (Hz)."]
#[doc = " This must be one of 8000, 12000, 16000,"]
#[doc = " 24000, or 48000."]
#[doc = " @param [in] channels <tt>int</tt>: Number of channels (1 or 2) to decode"]
#[doc = " @retval #OPUS_OK Success or @ref opus_errorcodes"]
pub fn opus_decoder_init(
st: *mut OpusDecoder,
Fs: opus_int32,
channels: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Decode an Opus packet."]
#[doc = " @param [in] st <tt>OpusDecoder*</tt>: Decoder state"]
#[doc = " @param [in] data <tt>char*</tt>: Input payload. Use a NULL pointer to indicate packet loss"]
#[doc = " @param [in] len <tt>opus_int32</tt>: Number of bytes in payload*"]
#[doc = " @param [out] pcm <tt>opus_int16*</tt>: Output signal (interleaved if 2 channels). length"]
#[doc = " is frame_size*channels*sizeof(opus_int16)"]
#[doc = " @param [in] frame_size Number of samples per channel of available space in \\a pcm."]
#[doc = " If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will"]
#[doc = " not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=1),"]
#[doc = " then frame_size needs to be exactly the duration of audio that is missing, otherwise the"]
#[doc = " decoder will not be in the optimal state to decode the next incoming packet. For the PLC and"]
#[doc = " FEC cases, frame_size <b>must</b> be a multiple of 2.5 ms."]
#[doc = " @param [in] decode_fec <tt>int</tt>: Flag (0 or 1) to request that any in-band forward error correction data be"]
#[doc = " decoded. If no such data is available, the frame is decoded as if it were lost."]
#[doc = " @returns Number of decoded samples or @ref opus_errorcodes"]
pub fn opus_decode(
st: *mut OpusDecoder,
data: *const ::std::os::raw::c_uchar,
len: opus_int32,
pcm: *mut opus_int16,
frame_size: ::std::os::raw::c_int,
decode_fec: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Decode an Opus packet with floating point output."]
#[doc = " @param [in] st <tt>OpusDecoder*</tt>: Decoder state"]
#[doc = " @param [in] data <tt>char*</tt>: Input payload. Use a NULL pointer to indicate packet loss"]
#[doc = " @param [in] len <tt>opus_int32</tt>: Number of bytes in payload"]
#[doc = " @param [out] pcm <tt>float*</tt>: Output signal (interleaved if 2 channels). length"]
#[doc = " is frame_size*channels*sizeof(float)"]
#[doc = " @param [in] frame_size Number of samples per channel of available space in \\a pcm."]
#[doc = " If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will"]
#[doc = " not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=1),"]
#[doc = " then frame_size needs to be exactly the duration of audio that is missing, otherwise the"]
#[doc = " decoder will not be in the optimal state to decode the next incoming packet. For the PLC and"]
#[doc = " FEC cases, frame_size <b>must</b> be a multiple of 2.5 ms."]
#[doc = " @param [in] decode_fec <tt>int</tt>: Flag (0 or 1) to request that any in-band forward error correction data be"]
#[doc = " decoded. If no such data is available the frame is decoded as if it were lost."]
#[doc = " @returns Number of decoded samples or @ref opus_errorcodes"]
pub fn opus_decode_float(
st: *mut OpusDecoder,
data: *const ::std::os::raw::c_uchar,
len: opus_int32,
pcm: *mut f32,
frame_size: ::std::os::raw::c_int,
decode_fec: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Perform a CTL function on an Opus decoder."]
#[doc = ""]
#[doc = " Generally the request and subsequent arguments are generated"]
#[doc = " by a convenience macro."]
#[doc = " @param st <tt>OpusDecoder*</tt>: Decoder state."]
#[doc = " @param request This and all remaining parameters should be replaced by one"]
#[doc = " of the convenience macros in @ref opus_genericctls or"]
#[doc = " @ref opus_decoderctls."]
#[doc = " @see opus_genericctls"]
#[doc = " @see opus_decoderctls"]
pub fn opus_decoder_ctl(
st: *mut OpusDecoder,
request: ::std::os::raw::c_int,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Frees an <code>OpusDecoder</code> allocated by opus_decoder_create()."]
#[doc = " @param[in] st <tt>OpusDecoder*</tt>: State to be freed."]
pub fn opus_decoder_destroy(st: *mut OpusDecoder);
}
extern "C" {
#[doc = " Parse an opus packet into one or more frames."]
#[doc = " Opus_decode will perform this operation internally so most applications do"]
#[doc = " not need to use this function."]
#[doc = " This function does not copy the frames, the returned pointers are pointers into"]
#[doc = " the input packet."]
#[doc = " @param [in] data <tt>char*</tt>: Opus packet to be parsed"]
#[doc = " @param [in] len <tt>opus_int32</tt>: size of data"]
#[doc = " @param [out] out_toc <tt>char*</tt>: TOC pointer"]
#[doc = " @param [out] frames <tt>char*[48]</tt> encapsulated frames"]
#[doc = " @param [out] size <tt>opus_int16[48]</tt> sizes of the encapsulated frames"]
#[doc = " @param [out] payload_offset <tt>int*</tt>: returns the position of the payload within the packet (in bytes)"]
#[doc = " @returns number of frames"]
pub fn opus_packet_parse(
data: *const ::std::os::raw::c_uchar,
len: opus_int32,
out_toc: *mut ::std::os::raw::c_uchar,
frames: *mut *const ::std::os::raw::c_uchar,
size: *mut opus_int16,
payload_offset: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Gets the bandwidth of an Opus packet."]
#[doc = " @param [in] data <tt>char*</tt>: Opus packet"]
#[doc = " @retval OPUS_BANDWIDTH_NARROWBAND Narrowband (4kHz bandpass)"]
#[doc = " @retval OPUS_BANDWIDTH_MEDIUMBAND Mediumband (6kHz bandpass)"]
#[doc = " @retval OPUS_BANDWIDTH_WIDEBAND Wideband (8kHz bandpass)"]
#[doc = " @retval OPUS_BANDWIDTH_SUPERWIDEBAND Superwideband (12kHz bandpass)"]
#[doc = " @retval OPUS_BANDWIDTH_FULLBAND Fullband (20kHz bandpass)"]
#[doc = " @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type"]
pub fn opus_packet_get_bandwidth(data: *const ::std::os::raw::c_uchar)
-> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Gets the number of samples per frame from an Opus packet."]
#[doc = " @param [in] data <tt>char*</tt>: Opus packet."]
#[doc = " This must contain at least one byte of"]
#[doc = " data."]
#[doc = " @param [in] Fs <tt>opus_int32</tt>: Sampling rate in Hz."]
#[doc = " This must be a multiple of 400, or"]
#[doc = " inaccurate results will be returned."]
#[doc = " @returns Number of samples per frame."]
pub fn opus_packet_get_samples_per_frame(
data: *const ::std::os::raw::c_uchar,
Fs: opus_int32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Gets the number of channels from an Opus packet."]
#[doc = " @param [in] data <tt>char*</tt>: Opus packet"]
#[doc = " @returns Number of channels"]
#[doc = " @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type"]
pub fn opus_packet_get_nb_channels(
data: *const ::std::os::raw::c_uchar,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Gets the number of frames in an Opus packet."]
#[doc = " @param [in] packet <tt>char*</tt>: Opus packet"]
#[doc = " @param [in] len <tt>opus_int32</tt>: Length of packet"]
#[doc = " @returns Number of frames"]
#[doc = " @retval OPUS_BAD_ARG Insufficient data was passed to the function"]
#[doc = " @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type"]
pub fn opus_packet_get_nb_frames(
packet: *const ::std::os::raw::c_uchar,
len: opus_int32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Gets the number of samples of an Opus packet."]
#[doc = " @param [in] packet <tt>char*</tt>: Opus packet"]
#[doc = " @param [in] len <tt>opus_int32</tt>: Length of packet"]
#[doc = " @param [in] Fs <tt>opus_int32</tt>: Sampling rate in Hz."]
#[doc = " This must be a multiple of 400, or"]
#[doc = " inaccurate results will be returned."]
#[doc = " @returns Number of samples"]
#[doc = " @retval OPUS_BAD_ARG Insufficient data was passed to the function"]
#[doc = " @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type"]
pub fn opus_packet_get_nb_samples(
packet: *const ::std::os::raw::c_uchar,
len: opus_int32,
Fs: opus_int32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Gets the number of samples of an Opus packet."]
#[doc = " @param [in] dec <tt>OpusDecoder*</tt>: Decoder state"]
#[doc = " @param [in] packet <tt>char*</tt>: Opus packet"]
#[doc = " @param [in] len <tt>opus_int32</tt>: Length of packet"]
#[doc = " @returns Number of samples"]
#[doc = " @retval OPUS_BAD_ARG Insufficient data was passed to the function"]
#[doc = " @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type"]
pub fn opus_decoder_get_nb_samples(
dec: *const OpusDecoder,
packet: *const ::std::os::raw::c_uchar,
len: opus_int32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Applies soft-clipping to bring a float signal within the [-1,1] range. If"]
#[doc = " the signal is already in that range, nothing is done. If there are values"]
#[doc = " outside of [-1,1], then the signal is clipped as smoothly as possible to"]
#[doc = " both fit in the range and avoid creating excessive distortion in the"]
#[doc = " process."]
#[doc = " @param [in,out] pcm <tt>float*</tt>: Input PCM and modified PCM"]
#[doc = " @param [in] frame_size <tt>int</tt> Number of samples per channel to process"]
#[doc = " @param [in] channels <tt>int</tt>: Number of channels"]
#[doc = " @param [in,out] softclip_mem <tt>float*</tt>: State memory for the soft clipping process (one float per channel, initialized to zero)"]
pub fn opus_pcm_soft_clip(
pcm: *mut f32,
frame_size: ::std::os::raw::c_int,
channels: ::std::os::raw::c_int,
softclip_mem: *mut f32,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpusRepacketizer {
_unused: [u8; 0],
}
extern "C" {
#[doc = " Gets the size of an <code>OpusRepacketizer</code> structure."]
#[doc = " @returns The size in bytes."]
pub fn opus_repacketizer_get_size() -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " (Re)initializes a previously allocated repacketizer state."]
#[doc = " The state must be at least the size returned by opus_repacketizer_get_size()."]
#[doc = " This can be used for applications which use their own allocator instead of"]
#[doc = " malloc()."]
#[doc = " It must also be called to reset the queue of packets waiting to be"]
#[doc = " repacketized, which is necessary if the maximum packet duration of 120 ms"]
#[doc = " is reached or if you wish to submit packets with a different Opus"]
#[doc = " configuration (coding mode, audio bandwidth, frame size, or channel count)."]
#[doc = " Failure to do so will prevent a new packet from being added with"]
#[doc = " opus_repacketizer_cat()."]
#[doc = " @see opus_repacketizer_create"]
#[doc = " @see opus_repacketizer_get_size"]
#[doc = " @see opus_repacketizer_cat"]
#[doc = " @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state to"]
#[doc = " (re)initialize."]
#[doc = " @returns A pointer to the same repacketizer state that was passed in."]
pub fn opus_repacketizer_init(rp: *mut OpusRepacketizer) -> *mut OpusRepacketizer;
}
extern "C" {
#[doc = " Allocates memory and initializes the new repacketizer with"]
#[doc = " opus_repacketizer_init()."]
pub fn opus_repacketizer_create() -> *mut OpusRepacketizer;
}
extern "C" {
#[doc = " Frees an <code>OpusRepacketizer</code> allocated by"]
#[doc = " opus_repacketizer_create()."]
#[doc = " @param[in] rp <tt>OpusRepacketizer*</tt>: State to be freed."]
pub fn opus_repacketizer_destroy(rp: *mut OpusRepacketizer);
}
extern "C" {
#[doc = " Add a packet to the current repacketizer state."]
#[doc = " This packet must match the configuration of any packets already submitted"]
#[doc = " for repacketization since the last call to opus_repacketizer_init()."]
#[doc = " This means that it must have the same coding mode, audio bandwidth, frame"]
#[doc = " size, and channel count."]
#[doc = " This can be checked in advance by examining the top 6 bits of the first"]
#[doc = " byte of the packet, and ensuring they match the top 6 bits of the first"]
#[doc = " byte of any previously submitted packet."]
#[doc = " The total duration of audio in the repacketizer state also must not exceed"]
#[doc = " 120 ms, the maximum duration of a single packet, after adding this packet."]
#[doc = ""]
#[doc = " The contents of the current repacketizer state can be extracted into new"]
#[doc = " packets using opus_repacketizer_out() or opus_repacketizer_out_range()."]
#[doc = ""]
#[doc = " In order to add a packet with a different configuration or to add more"]
#[doc = " audio beyond 120 ms, you must clear the repacketizer state by calling"]
#[doc = " opus_repacketizer_init()."]
#[doc = " If a packet is too large to add to the current repacketizer state, no part"]
#[doc = " of it is added, even if it contains multiple frames, some of which might"]
#[doc = " fit."]
#[doc = " If you wish to be able to add parts of such packets, you should first use"]
#[doc = " another repacketizer to split the packet into pieces and add them"]
#[doc = " individually."]
#[doc = " @see opus_repacketizer_out_range"]
#[doc = " @see opus_repacketizer_out"]
#[doc = " @see opus_repacketizer_init"]
#[doc = " @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state to which to"]
#[doc = " add the packet."]
#[doc = " @param[in] data <tt>const unsigned char*</tt>: The packet data."]
#[doc = " The application must ensure"]
#[doc = " this pointer remains valid"]
#[doc = " until the next call to"]
#[doc = " opus_repacketizer_init() or"]
#[doc = " opus_repacketizer_destroy()."]
#[doc = " @param len <tt>opus_int32</tt>: The number of bytes in the packet data."]
#[doc = " @returns An error code indicating whether or not the operation succeeded."]
#[doc = " @retval #OPUS_OK The packet's contents have been added to the repacketizer"]
#[doc = " state."]
#[doc = " @retval #OPUS_INVALID_PACKET The packet did not have a valid TOC sequence,"]
#[doc = " the packet's TOC sequence was not compatible"]
#[doc = " with previously submitted packets (because"]
#[doc = " the coding mode, audio bandwidth, frame size,"]
#[doc = " or channel count did not match), or adding"]
#[doc = " this packet would increase the total amount of"]
#[doc = " audio stored in the repacketizer state to more"]
#[doc = " than 120 ms."]
pub fn opus_repacketizer_cat(
rp: *mut OpusRepacketizer,
data: *const ::std::os::raw::c_uchar,
len: opus_int32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Construct a new packet from data previously submitted to the repacketizer"]
#[doc = " state via opus_repacketizer_cat()."]
#[doc = " @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state from which to"]
#[doc = " construct the new packet."]
#[doc = " @param begin <tt>int</tt>: The index of the first frame in the current"]
#[doc = " repacketizer state to include in the output."]
#[doc = " @param end <tt>int</tt>: One past the index of the last frame in the"]
#[doc = " current repacketizer state to include in the"]
#[doc = " output."]
#[doc = " @param[out] data <tt>const unsigned char*</tt>: The buffer in which to"]
#[doc = " store the output packet."]
#[doc = " @param maxlen <tt>opus_int32</tt>: The maximum number of bytes to store in"]
#[doc = " the output buffer. In order to guarantee"]
#[doc = " success, this should be at least"]
#[doc = " <code>1276</code> for a single frame,"]
#[doc = " or for multiple frames,"]
#[doc = " <code>1277*(end-begin)</code>."]
#[doc = " However, <code>1*(end-begin)</code> plus"]
#[doc = " the size of all packet data submitted to"]
#[doc = " the repacketizer since the last call to"]
#[doc = " opus_repacketizer_init() or"]
#[doc = " opus_repacketizer_create() is also"]
#[doc = " sufficient, and possibly much smaller."]
#[doc = " @returns The total size of the output packet on success, or an error code"]
#[doc = " on failure."]
#[doc = " @retval #OPUS_BAD_ARG <code>[begin,end)</code> was an invalid range of"]
#[doc = " frames (begin < 0, begin >= end, or end >"]
#[doc = " opus_repacketizer_get_nb_frames())."]
#[doc = " @retval #OPUS_BUFFER_TOO_SMALL \\a maxlen was insufficient to contain the"]
#[doc = " complete output packet."]
pub fn opus_repacketizer_out_range(
rp: *mut OpusRepacketizer,
begin: ::std::os::raw::c_int,
end: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_uchar,
maxlen: opus_int32,
) -> opus_int32;
}
extern "C" {
#[doc = " Return the total number of frames contained in packet data submitted to"]
#[doc = " the repacketizer state so far via opus_repacketizer_cat() since the last"]
#[doc = " call to opus_repacketizer_init() or opus_repacketizer_create()."]
#[doc = " This defines the valid range of packets that can be extracted with"]
#[doc = " opus_repacketizer_out_range() or opus_repacketizer_out()."]
#[doc = " @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state containing the"]
#[doc = " frames."]
#[doc = " @returns The total number of frames contained in the packet data submitted"]
#[doc = " to the repacketizer state."]
pub fn opus_repacketizer_get_nb_frames(rp: *mut OpusRepacketizer) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Construct a new packet from data previously submitted to the repacketizer"]
#[doc = " state via opus_repacketizer_cat()."]
#[doc = " This is a convenience routine that returns all the data submitted so far"]
#[doc = " in a single packet."]
#[doc = " It is equivalent to calling"]
#[doc = " @code"]
#[doc = " opus_repacketizer_out_range(rp, 0, opus_repacketizer_get_nb_frames(rp),"]
#[doc = " data, maxlen)"]
#[doc = " @endcode"]
#[doc = " @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state from which to"]
#[doc = " construct the new packet."]
#[doc = " @param[out] data <tt>const unsigned char*</tt>: The buffer in which to"]
#[doc = " store the output packet."]
#[doc = " @param maxlen <tt>opus_int32</tt>: The maximum number of bytes to store in"]
#[doc = " the output buffer. In order to guarantee"]
#[doc = " success, this should be at least"]
#[doc = " <code>1277*opus_repacketizer_get_nb_frames(rp)</code>."]
#[doc = " However,"]
#[doc = " <code>1*opus_repacketizer_get_nb_frames(rp)</code>"]
#[doc = " plus the size of all packet data"]
#[doc = " submitted to the repacketizer since the"]
#[doc = " last call to opus_repacketizer_init() or"]
#[doc = " opus_repacketizer_create() is also"]
#[doc = " sufficient, and possibly much smaller."]
#[doc = " @returns The total size of the output packet on success, or an error code"]
#[doc = " on failure."]
#[doc = " @retval #OPUS_BUFFER_TOO_SMALL \\a maxlen was insufficient to contain the"]
#[doc = " complete output packet."]
pub fn opus_repacketizer_out(
rp: *mut OpusRepacketizer,
data: *mut ::std::os::raw::c_uchar,
maxlen: opus_int32,
) -> opus_int32;
}
extern "C" {
#[doc = " Pads a given Opus packet to a larger size (possibly changing the TOC sequence)."]
#[doc = " @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the"]
#[doc = " packet to pad."]
#[doc = " @param len <tt>opus_int32</tt>: The size of the packet."]
#[doc = " This must be at least 1."]
#[doc = " @param new_len <tt>opus_int32</tt>: The desired size of the packet after padding."]
#[doc = " This must be at least as large as len."]
#[doc = " @returns an error code"]
#[doc = " @retval #OPUS_OK \\a on success."]
#[doc = " @retval #OPUS_BAD_ARG \\a len was less than 1 or new_len was less than len."]
#[doc = " @retval #OPUS_INVALID_PACKET \\a data did not contain a valid Opus packet."]
pub fn opus_packet_pad(
data: *mut ::std::os::raw::c_uchar,
len: opus_int32,
new_len: opus_int32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Remove all padding from a given Opus packet and rewrite the TOC sequence to"]
#[doc = " minimize space usage."]
#[doc = " @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the"]
#[doc = " packet to strip."]
#[doc = " @param len <tt>opus_int32</tt>: The size of the packet."]
#[doc = " This must be at least 1."]
#[doc = " @returns The new size of the output packet on success, or an error code"]
#[doc = " on failure."]
#[doc = " @retval #OPUS_BAD_ARG \\a len was less than 1."]
#[doc = " @retval #OPUS_INVALID_PACKET \\a data did not contain a valid Opus packet."]
pub fn opus_packet_unpad(data: *mut ::std::os::raw::c_uchar, len: opus_int32) -> opus_int32;
}
extern "C" {
#[doc = " Pads a given Opus multi-stream packet to a larger size (possibly changing the TOC sequence)."]
#[doc = " @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the"]
#[doc = " packet to pad."]
#[doc = " @param len <tt>opus_int32</tt>: The size of the packet."]
#[doc = " This must be at least 1."]
#[doc = " @param new_len <tt>opus_int32</tt>: The desired size of the packet after padding."]
#[doc = " This must be at least 1."]
#[doc = " @param nb_streams <tt>opus_int32</tt>: The number of streams (not channels) in the packet."]
#[doc = " This must be at least as large as len."]
#[doc = " @returns an error code"]
#[doc = " @retval #OPUS_OK \\a on success."]
#[doc = " @retval #OPUS_BAD_ARG \\a len was less than 1."]
#[doc = " @retval #OPUS_INVALID_PACKET \\a data did not contain a valid Opus packet."]
pub fn opus_multistream_packet_pad(
data: *mut ::std::os::raw::c_uchar,
len: opus_int32,
new_len: opus_int32,
nb_streams: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Remove all padding from a given Opus multi-stream packet and rewrite the TOC sequence to"]
#[doc = " minimize space usage."]
#[doc = " @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the"]
#[doc = " packet to strip."]
#[doc = " @param len <tt>opus_int32</tt>: The size of the packet."]
#[doc = " This must be at least 1."]
#[doc = " @param nb_streams <tt>opus_int32</tt>: The number of streams (not channels) in the packet."]
#[doc = " This must be at least 1."]
#[doc = " @returns The new size of the output packet on success, or an error code"]
#[doc = " on failure."]
#[doc = " @retval #OPUS_BAD_ARG \\a len was less than 1 or new_len was less than len."]
#[doc = " @retval #OPUS_INVALID_PACKET \\a data did not contain a valid Opus packet."]
pub fn opus_multistream_packet_unpad(
data: *mut ::std::os::raw::c_uchar,
len: opus_int32,
nb_streams: ::std::os::raw::c_int,
) -> opus_int32;
}
pub type __builtin_va_list = *mut ::std::os::raw::c_char;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lconv {
pub _address: u8,
}