pub const SAMPLE_RATE_HZ: ::std::os::raw::c_int = 48000;
pub const FRAME_MS: ::std::os::raw::c_int = 10;
pub const NUM_SAMPLES_PER_FRAME: ::std::os::raw::c_int = 480;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AudioProcessing {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct OptionalDouble {
pub has_value: bool,
pub value: f64,
}
#[test]
fn bindgen_test_layout_OptionalDouble() {
assert_eq!(
::std::mem::size_of::<OptionalDouble>(),
16usize,
concat!("Size of: ", stringify!(OptionalDouble))
);
assert_eq!(
::std::mem::align_of::<OptionalDouble>(),
8usize,
concat!("Alignment of ", stringify!(OptionalDouble))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<OptionalDouble>())).has_value as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(OptionalDouble),
"::",
stringify!(has_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<OptionalDouble>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(OptionalDouble),
"::",
stringify!(value)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct OptionalInt {
pub has_value: bool,
pub value: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_OptionalInt() {
assert_eq!(
::std::mem::size_of::<OptionalInt>(),
8usize,
concat!("Size of: ", stringify!(OptionalInt))
);
assert_eq!(
::std::mem::align_of::<OptionalInt>(),
4usize,
concat!("Alignment of ", stringify!(OptionalInt))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<OptionalInt>())).has_value as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(OptionalInt),
"::",
stringify!(has_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<OptionalInt>())).value as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(OptionalInt),
"::",
stringify!(value)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct OptionalBool {
pub has_value: bool,
pub value: bool,
}
#[test]
fn bindgen_test_layout_OptionalBool() {
assert_eq!(
::std::mem::size_of::<OptionalBool>(),
2usize,
concat!("Size of: ", stringify!(OptionalBool))
);
assert_eq!(
::std::mem::align_of::<OptionalBool>(),
1usize,
concat!("Alignment of ", stringify!(OptionalBool))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<OptionalBool>())).has_value as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(OptionalBool),
"::",
stringify!(has_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<OptionalBool>())).value as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(OptionalBool),
"::",
stringify!(value)
)
);
}
#[doc = " <div rustbindgen>A configuration used only when initializing a Processor.</div>"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct InitializationConfig {
pub num_capture_channels: ::std::os::raw::c_int,
pub num_render_channels: ::std::os::raw::c_int,
pub enable_experimental_agc: bool,
pub enable_intelligibility_enhancer: bool,
}
#[test]
fn bindgen_test_layout_InitializationConfig() {
assert_eq!(
::std::mem::size_of::<InitializationConfig>(),
12usize,
concat!("Size of: ", stringify!(InitializationConfig))
);
assert_eq!(
::std::mem::align_of::<InitializationConfig>(),
4usize,
concat!("Alignment of ", stringify!(InitializationConfig))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<InitializationConfig>())).num_capture_channels as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(InitializationConfig),
"::",
stringify!(num_capture_channels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<InitializationConfig>())).num_render_channels as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(InitializationConfig),
"::",
stringify!(num_render_channels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<InitializationConfig>())).enable_experimental_agc as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(InitializationConfig),
"::",
stringify!(enable_experimental_agc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<InitializationConfig>())).enable_intelligibility_enhancer
as *const _ as usize
},
9usize,
concat!(
"Offset of field: ",
stringify!(InitializationConfig),
"::",
stringify!(enable_intelligibility_enhancer)
)
);
}
#[doc = " <div rustbindgen>Echo cancellation configuration.</div>"]
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct EchoCancellation {
#[doc = " <div rustbindgen>Whether to use echo cancellation.</div>"]
pub enable: bool,
#[doc = " <div rustbindgen>"]
#[doc = " Determines the aggressiveness of the suppressor. A higher level trades off"]
#[doc = " double-talk performance for increased echo suppression."]
#[doc = " </div>"]
pub suppression_level: EchoCancellation_SuppressionLevel,
#[doc = " <div rustbindgen>"]
#[doc = " Use to enable the extended filter mode in the AEC, along with robustness"]
#[doc = " measures around the reported system delays. It comes with a significant"]
#[doc = " increase in AEC complexity, but is much more robust to unreliable reported"]
#[doc = " delays."]
#[doc = " </div>"]
pub enable_extended_filter: bool,
#[doc = " <div rustbindgen>"]
#[doc = " Enables delay-agnostic echo cancellation. This feature relies on internally"]
#[doc = " estimated delays between the process and reverse streams, thus not relying"]
#[doc = " on reported system delays."]
#[doc = " </div>"]
pub enable_delay_agnostic: bool,
#[doc = " <div rustbindgen>"]
#[doc = " Sets the delay in ms between process_render_frame() receiving a far-end"]
#[doc = " frame and process_capture_frame() receiving a near-end frame containing"]
#[doc = " the corresponding echo. You should set this only if you are certain that"]
#[doc = " the delay will be stable and constant. enable_delay_agnostic will be"]
#[doc = " ignored when this option is set."]
#[doc = " </div>"]
pub stream_delay_ms: OptionalInt,
}
#[repr(u32)]
#[doc = " <div rustbindgen>A level of echo suppression.</div>"]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EchoCancellation_SuppressionLevel {
LOW = 0,
MODERATE = 1,
HIGH = 2,
}
#[test]
fn bindgen_test_layout_EchoCancellation() {
assert_eq!(
::std::mem::size_of::<EchoCancellation>(),
20usize,
concat!("Size of: ", stringify!(EchoCancellation))
);
assert_eq!(
::std::mem::align_of::<EchoCancellation>(),
4usize,
concat!("Alignment of ", stringify!(EchoCancellation))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EchoCancellation>())).enable as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(EchoCancellation),
"::",
stringify!(enable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<EchoCancellation>())).suppression_level as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(EchoCancellation),
"::",
stringify!(suppression_level)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<EchoCancellation>())).enable_extended_filter as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(EchoCancellation),
"::",
stringify!(enable_extended_filter)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<EchoCancellation>())).enable_delay_agnostic as *const _ as usize
},
9usize,
concat!(
"Offset of field: ",
stringify!(EchoCancellation),
"::",
stringify!(enable_delay_agnostic)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<EchoCancellation>())).stream_delay_ms as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(EchoCancellation),
"::",
stringify!(stream_delay_ms)
)
);
}
impl Default for EchoCancellation {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " <div rustbindgen>Gain control configuration.</div>"]
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct GainControl {
#[doc = " <div rustbindgen>Whether to use gain control.</div>"]
pub enable: bool,
#[doc = " <div rustbindgen>Determines what type of gain control is applied.</div>"]
pub mode: GainControl_Mode,
#[doc = " <div rustbindgen>"]
#[doc = " Sets the target peak level (or envelope) of the AGC in dBFs (decibels from"]
#[doc = " digital full-scale). The convention is to use positive values."]
#[doc = " For instance, passing in a value of 3 corresponds to -3 dBFs, or a target"]
#[doc = " level 3 dB below full-scale. Limited to [0, 31]."]
#[doc = " </div>"]
pub target_level_dbfs: ::std::os::raw::c_int,
#[doc = " <div rustbindgen>"]
#[doc = " Sets the maximum gain the digital compression stage may apply, in dB. A"]
#[doc = " higher number corresponds to greater compression, while a value of 0 will"]
#[doc = " leave the signal uncompressed. Limited to [0, 90]."]
#[doc = " </div>"]
pub compression_gain_db: ::std::os::raw::c_int,
#[doc = " <div rustbindgen>"]
#[doc = " When enabled, the compression stage will hard limit the signal to the"]
#[doc = " target level. Otherwise, the signal will be compressed but not limited"]
#[doc = " above the target level."]
#[doc = " </div>"]
pub enable_limiter: bool,
}
#[repr(u32)]
#[doc = " <div rustbindgen>Mode of gain control.</div>"]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GainControl_Mode {
#[doc = " <div rustbindgen>Not supported yet.</div>"]
#[doc = " TODO(skywhale): Expose set_stream_analog_level() and"]
#[doc = " stream_analog_level()."]
ADAPTIVE_ANALOG = 0,
#[doc = " <div rustbindgen>"]
#[doc = " Bring the signal to an appropriate range by applying an adaptive gain"]
#[doc = " control. The volume is dynamically amplified with a microphone with"]
#[doc = " small pickup and vice versa."]
#[doc = " </div>"]
ADAPTIVE_DIGITAL = 1,
#[doc = " <div rustbindgen>"]
#[doc = " Unlike ADAPTIVE_DIGITAL, it only compresses (i.e. gradually reduces"]
#[doc = " gain with increasing level) the input signal when at higher levels."]
#[doc = " Use this where the capture signal level is predictable, so that a"]
#[doc = " known gain can be applied."]
#[doc = " </div>"]
FIXED_DIGITAL = 2,
}
#[test]
fn bindgen_test_layout_GainControl() {
assert_eq!(
::std::mem::size_of::<GainControl>(),
20usize,
concat!("Size of: ", stringify!(GainControl))
);
assert_eq!(
::std::mem::align_of::<GainControl>(),
4usize,
concat!("Alignment of ", stringify!(GainControl))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<GainControl>())).enable as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GainControl),
"::",
stringify!(enable)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<GainControl>())).mode as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GainControl),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<GainControl>())).target_level_dbfs as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GainControl),
"::",
stringify!(target_level_dbfs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<GainControl>())).compression_gain_db as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(GainControl),
"::",
stringify!(compression_gain_db)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<GainControl>())).enable_limiter as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(GainControl),
"::",
stringify!(enable_limiter)
)
);
}
impl Default for GainControl {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " <div rustbindgen>Noise suppression configuration.</div>"]
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct NoiseSuppression {
#[doc = " <div rustbindgen>Whether to use noise supression.</div>"]
pub enable: bool,
#[doc = " <div rustbindgen>"]
#[doc = " Determines the aggressiveness of the suppression. Increasing the level will"]
#[doc = " reduce the noise level at the expense of a higher speech distortion."]
#[doc = " </div>"]
pub suppression_level: NoiseSuppression_SuppressionLevel,
}
#[repr(u32)]
#[doc = " <div rustbindgen>A level of noise suppression.</div>"]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum NoiseSuppression_SuppressionLevel {
LOW = 0,
MODERATE = 1,
HIGH = 2,
VERY_HIGH = 3,
}
#[test]
fn bindgen_test_layout_NoiseSuppression() {
assert_eq!(
::std::mem::size_of::<NoiseSuppression>(),
8usize,
concat!("Size of: ", stringify!(NoiseSuppression))
);
assert_eq!(
::std::mem::align_of::<NoiseSuppression>(),
4usize,
concat!("Alignment of ", stringify!(NoiseSuppression))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<NoiseSuppression>())).enable as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(NoiseSuppression),
"::",
stringify!(enable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<NoiseSuppression>())).suppression_level as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(NoiseSuppression),
"::",
stringify!(suppression_level)
)
);
}
impl Default for NoiseSuppression {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " <div rustbindgen>Voice detection configuration.</div>"]
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct VoiceDetection {
#[doc = " <div rustbindgen>Whether to use voice detection.</div>"]
pub enable: bool,
#[doc = " <div rustbindgen>"]
#[doc = " Specifies the likelihood that a frame will be declared to contain voice. A"]
#[doc = " higher value makes it more likely that speech will not be clipped, at the"]
#[doc = " expense of more noise being detected as voice."]
#[doc = " </div>"]
pub detection_likelihood: VoiceDetection_DetectionLikelihood,
}
#[repr(u32)]
#[doc = " <div rustbindgen>The sensitivity of the noise detector.</div>"]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VoiceDetection_DetectionLikelihood {
VERY_LOW = 0,
LOW = 1,
MODERATE = 2,
HIGH = 3,
}
#[test]
fn bindgen_test_layout_VoiceDetection() {
assert_eq!(
::std::mem::size_of::<VoiceDetection>(),
8usize,
concat!("Size of: ", stringify!(VoiceDetection))
);
assert_eq!(
::std::mem::align_of::<VoiceDetection>(),
4usize,
concat!("Alignment of ", stringify!(VoiceDetection))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<VoiceDetection>())).enable as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(VoiceDetection),
"::",
stringify!(enable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<VoiceDetection>())).detection_likelihood as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(VoiceDetection),
"::",
stringify!(detection_likelihood)
)
);
}
impl Default for VoiceDetection {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " <div rustbindgen>Config that can be used mid-processing.</div>"]
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Config {
pub echo_cancellation: EchoCancellation,
pub gain_control: GainControl,
pub noise_suppression: NoiseSuppression,
pub voice_detection: VoiceDetection,
#[doc = " <div rustbindgen>"]
#[doc = " Use to enable experimental transient noise suppression."]
#[doc = " </div>"]
pub enable_transient_suppressor: bool,
#[doc = " <div rustbindgen>"]
#[doc = " Use to enable a filtering component which removes DC offset and"]
#[doc = " low-frequency noise."]
#[doc = " </div>"]
pub enable_high_pass_filter: bool,
}
#[test]
fn bindgen_test_layout_Config() {
assert_eq!(
::std::mem::size_of::<Config>(),
60usize,
concat!("Size of: ", stringify!(Config))
);
assert_eq!(
::std::mem::align_of::<Config>(),
4usize,
concat!("Alignment of ", stringify!(Config))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Config>())).echo_cancellation as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Config),
"::",
stringify!(echo_cancellation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Config>())).gain_control as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(Config),
"::",
stringify!(gain_control)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Config>())).noise_suppression as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(Config),
"::",
stringify!(noise_suppression)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Config>())).voice_detection as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(Config),
"::",
stringify!(voice_detection)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<Config>())).enable_transient_suppressor as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(Config),
"::",
stringify!(enable_transient_suppressor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Config>())).enable_high_pass_filter as *const _ as usize },
57usize,
concat!(
"Offset of field: ",
stringify!(Config),
"::",
stringify!(enable_high_pass_filter)
)
);
}
impl Default for Config {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " <div rustbindgen>Statistics about the processor state.</div>"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct Stats {
#[doc = " <div rustbindgen>"]
#[doc = " True if voice is detected in the current frame."]
#[doc = " </div>"]
pub has_voice: OptionalBool,
#[doc = " <div rustbindgen>"]
#[doc = " False if the current frame almost certainly contains no echo and true if it"]
#[doc = " _might_ contain echo."]
#[doc = " </div>"]
pub has_echo: OptionalBool,
#[doc = " <div rustbindgen>"]
#[doc = " Root mean square (RMS) level in dBFs (decibels from digital full-scale), or"]
#[doc = " alternately dBov. It is computed over all primary stream frames since the"]
#[doc = " last call to |get_stats()|. The returned value is constrained to [-127, 0],"]
#[doc = " where -127 indicates muted."]
#[doc = " </div>"]
pub rms_dbfs: OptionalInt,
#[doc = " <div rustbindgen>"]
#[doc = " Prior speech probability of the current frame averaged over output"]
#[doc = " channels, internally computed by noise suppressor."]
#[doc = " </div>"]
pub speech_probability: OptionalDouble,
#[doc = " <div rustbindgen>"]
#[doc = " RERL = ERL + ERLE"]
#[doc = " </div>"]
pub residual_echo_return_loss: OptionalDouble,
#[doc = " <div rustbindgen>"]
#[doc = " ERL = 10log_10(P_far / P_echo)"]
#[doc = " </div>"]
pub echo_return_loss: OptionalDouble,
#[doc = " <div rustbindgen>"]
#[doc = " ERLE = 10log_10(P_echo / P_out)"]
#[doc = " </div>"]
pub echo_return_loss_enhancement: OptionalDouble,
#[doc = " <div rustbindgen>"]
#[doc = " (Pre non-linear processing suppression) A_NLP = 10log_10(P_echo / P_a)"]
#[doc = " </div>"]
pub a_nlp: OptionalDouble,
#[doc = " <div rustbindgen>"]
#[doc = " Median of the measured delay in ms. The values are aggregated until the"]
#[doc = " first call to |get_stats()| and afterwards aggregated and updated every"]
#[doc = " second."]
#[doc = " </div>"]
pub delay_median_ms: OptionalInt,
#[doc = " <div rustbindgen>"]
#[doc = " Standard deviation of the measured delay in ms. The values are aggregated"]
#[doc = " until the first call to |get_stats()| and afterwards aggregated and updated"]
#[doc = " every second."]
#[doc = " </div>"]
pub delay_standard_deviation_ms: OptionalInt,
#[doc = " <div rustbindgen>"]
#[doc = " The fraction of delay estimates that can make the echo cancellation perform"]
#[doc = " poorly."]
#[doc = " </div>"]
pub delay_fraction_poor_delays: OptionalDouble,
}
#[test]
fn bindgen_test_layout_Stats() {
assert_eq!(
::std::mem::size_of::<Stats>(),
128usize,
concat!("Size of: ", stringify!(Stats))
);
assert_eq!(
::std::mem::align_of::<Stats>(),
8usize,
concat!("Alignment of ", stringify!(Stats))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Stats>())).has_voice as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(has_voice)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Stats>())).has_echo as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(has_echo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Stats>())).rms_dbfs as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(rms_dbfs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Stats>())).speech_probability as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(speech_probability)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Stats>())).residual_echo_return_loss as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(residual_echo_return_loss)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Stats>())).echo_return_loss as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(echo_return_loss)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<Stats>())).echo_return_loss_enhancement as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(echo_return_loss_enhancement)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Stats>())).a_nlp as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(a_nlp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Stats>())).delay_median_ms as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(delay_median_ms)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<Stats>())).delay_standard_deviation_ms as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(delay_standard_deviation_ms)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<Stats>())).delay_fraction_poor_delays as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(Stats),
"::",
stringify!(delay_fraction_poor_delays)
)
);
}
extern "C" {
#[link_name = "\u{1}_ZN23webrtc_audio_processing23audio_processing_createERKNS_20InitializationConfigEPi"]
pub fn audio_processing_create(
init_config: *const InitializationConfig,
error: *mut ::std::os::raw::c_int,
) -> *mut AudioProcessing;
}
extern "C" {
#[link_name = "\u{1}_ZN23webrtc_audio_processing21process_capture_frameEPNS_15AudioProcessingEPPf"]
pub fn process_capture_frame(
ap: *mut AudioProcessing,
channels: *mut *mut f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}_ZN23webrtc_audio_processing20process_render_frameEPNS_15AudioProcessingEPPf"]
pub fn process_render_frame(
ap: *mut AudioProcessing,
channel3: *mut *mut f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}_ZN23webrtc_audio_processing9get_statsEPNS_15AudioProcessingE"]
pub fn get_stats(ap: *mut AudioProcessing) -> Stats;
}
extern "C" {
#[link_name = "\u{1}_ZN23webrtc_audio_processing10set_configEPNS_15AudioProcessingERKNS_6ConfigE"]
pub fn set_config(ap: *mut AudioProcessing, config: *const Config);
}
extern "C" {
#[link_name = "\u{1}_ZN23webrtc_audio_processing23audio_processing_deleteEPNS_15AudioProcessingE"]
pub fn audio_processing_delete(ap: *mut AudioProcessing);
}
extern "C" {
#[link_name = "\u{1}_ZN23webrtc_audio_processing10is_successEi"]
pub fn is_success(code: ::std::os::raw::c_int) -> bool;
}