sonora 0.1.0

WebRTC Audio Processing — pure Rust port with echo cancellation, noise suppression, and AGC
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Submodule state tracking for the audio processing pipeline.
//!
//! Ported from `AudioProcessingImpl::SubmoduleStates` in
//! `modules/audio_processing/audio_processing_impl.h/cc`.
//!
//! Tracks which submodules are active and detects state changes that
//! require reinitialization.

/// Tracks the enabled/disabled state of each audio processing submodule.
#[derive(Debug)]
pub(crate) struct SubmoduleStates {
    high_pass_filter_enabled: bool,
    noise_suppressor_enabled: bool,
    gain_controller2_enabled: bool,
    gain_adjustment_enabled: bool,
    echo_controller_enabled: bool,
    first_update: bool,
}

impl SubmoduleStates {
    pub(crate) fn new() -> Self {
        Self {
            high_pass_filter_enabled: false,
            noise_suppressor_enabled: false,
            gain_controller2_enabled: false,
            gain_adjustment_enabled: false,
            echo_controller_enabled: false,
            first_update: true,
        }
    }

    /// Updates the submodule state and returns `true` if it has changed.
    pub(crate) fn update(
        &mut self,
        high_pass_filter_enabled: bool,
        noise_suppressor_enabled: bool,
        gain_controller2_enabled: bool,
        gain_adjustment_enabled: bool,
        echo_controller_enabled: bool,
    ) -> bool {
        let mut changed = false;
        changed |= high_pass_filter_enabled != self.high_pass_filter_enabled;
        changed |= noise_suppressor_enabled != self.noise_suppressor_enabled;
        changed |= gain_controller2_enabled != self.gain_controller2_enabled;
        changed |= gain_adjustment_enabled != self.gain_adjustment_enabled;
        changed |= echo_controller_enabled != self.echo_controller_enabled;

        if changed {
            self.high_pass_filter_enabled = high_pass_filter_enabled;
            self.noise_suppressor_enabled = noise_suppressor_enabled;
            self.gain_controller2_enabled = gain_controller2_enabled;
            self.gain_adjustment_enabled = gain_adjustment_enabled;
            self.echo_controller_enabled = echo_controller_enabled;
        }

        changed |= self.first_update;
        self.first_update = false;
        changed
    }

    /// Returns whether any capture multi-band processing submodules are active.
    pub(crate) fn capture_multi_band_sub_modules_active(&self) -> bool {
        self.capture_multi_band_processing_present()
    }

    /// Returns whether capture multi-band processing is present.
    pub(crate) fn capture_multi_band_processing_present(&self) -> bool {
        self.capture_multi_band_processing_active(true)
    }

    /// Returns whether capture multi-band processing is active.
    pub(crate) fn capture_multi_band_processing_active(&self, ec_processing_active: bool) -> bool {
        self.high_pass_filter_enabled
            || self.noise_suppressor_enabled
            || (self.echo_controller_enabled && ec_processing_active)
    }

    /// Returns whether capture full-band processing is active.
    pub(crate) fn capture_full_band_processing_active(&self) -> bool {
        self.gain_controller2_enabled || self.gain_adjustment_enabled
    }

    /// Returns whether render multi-band submodules are active.
    pub(crate) fn render_multi_band_sub_modules_active(&self) -> bool {
        self.echo_controller_enabled
    }

    /// Returns whether render output was modified by processing.
    /// Always false: the Rust port does not include render pre-processors.
    pub(crate) fn render_output_modified(&self) -> bool {
        false
    }

    /// Returns whether high-pass filtering is required.
    pub(crate) fn high_pass_filtering_required(&self) -> bool {
        self.high_pass_filter_enabled || self.noise_suppressor_enabled
    }

    /// Returns whether the echo controller is enabled.
    pub(crate) fn echo_controller_enabled(&self) -> bool {
        self.echo_controller_enabled
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn first_update_always_returns_changed() {
        let mut states = SubmoduleStates::new();
        assert!(states.update(false, false, false, false, false));
    }

    #[test]
    fn second_update_no_change() {
        let mut states = SubmoduleStates::new();
        states.update(false, false, false, false, false);
        assert!(!states.update(false, false, false, false, false));
    }

    #[test]
    fn enabling_module_returns_changed() {
        let mut states = SubmoduleStates::new();
        states.update(false, false, false, false, false);
        assert!(states.update(true, false, false, false, false));
    }

    #[test]
    fn capture_multi_band_with_hpf() {
        let mut states = SubmoduleStates::new();
        states.update(true, false, false, false, false);
        assert!(states.capture_multi_band_processing_active(false));
    }

    #[test]
    fn capture_multi_band_with_echo_controller_inactive() {
        let mut states = SubmoduleStates::new();
        states.update(false, false, false, false, true);
        assert!(!states.capture_multi_band_processing_active(false));
        assert!(states.capture_multi_band_processing_active(true));
    }

    #[test]
    fn high_pass_filtering_required() {
        let mut states = SubmoduleStates::new();
        states.update(false, true, false, false, false);
        assert!(states.high_pass_filtering_required());
    }

    #[test]
    fn render_multi_band_with_echo_controller() {
        let mut states = SubmoduleStates::new();
        states.update(false, false, false, false, true);
        assert!(states.render_multi_band_sub_modules_active());
    }
}