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 = " 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 > ( ) , 16usize , 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 > ( ) ) ) . stream_delay_ms as * const _ as usize } , 8usize , 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>" ] DIGITAL_FIXED = 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 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>" ] # [ doc = " TODO(skywhale): Move to EchoCancellation." ] 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>" ] # [ doc = " TODO(skywhale): Move to EchoCancellation." ] pub enable_delay_agnostic : bool , # [ 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 > ( ) , 56usize , 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 } , 16usize , concat ! ( "Offset of field: " , stringify ! ( Config ) , "::" , stringify ! ( gain_control ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < Config > ( ) ) ) . noise_suppression as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( Config ) , "::" , stringify ! ( noise_suppression ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < Config > ( ) ) ) . voice_detection as * const _ as usize } , 44usize , concat ! ( "Offset of field: " , stringify ! ( Config ) , "::" , stringify ! ( voice_detection ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < Config > ( ) ) ) . enable_extended_filter as * const _ as usize } , 52usize , concat ! ( "Offset of field: " , stringify ! ( Config ) , "::" , stringify ! ( enable_extended_filter ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < Config > ( ) ) ) . enable_delay_agnostic as * const _ as usize } , 53usize , concat ! ( "Offset of field: " , stringify ! ( Config ) , "::" , stringify ! ( enable_delay_agnostic ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < Config > ( ) ) ) . enable_transient_suppressor as * const _ as usize } , 54usize , 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 } , 55usize , 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 ; }