oximedia-effects 0.1.4

Professional audio effects suite for OxiMedia
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

//! Noise gate with threshold and hysteresis.

use crate::{utils::EnvelopeFollower, AudioEffect};

/// Gate configuration.
#[derive(Debug, Clone)]
pub struct GateConfig {
    /// Threshold in dB.
    pub threshold_db: f32,
    /// Attack time in milliseconds.
    pub attack_ms: f32,
    /// Release time in milliseconds.
    pub release_ms: f32,
    /// Hysteresis range in dB (prevents chattering).
    pub hysteresis_db: f32,
}

impl Default for GateConfig {
    fn default() -> Self {
        Self {
            threshold_db: -40.0,
            attack_ms: 1.0,
            release_ms: 100.0,
            hysteresis_db: 6.0,
        }
    }
}

/// Noise gate effect.
pub struct Gate {
    envelope: EnvelopeFollower,
    config: GateConfig,
    is_open: bool,
    current_gain: f32,
    gain_smoother: f32,
}

impl Gate {
    /// Create new gate.
    #[must_use]
    pub fn new(config: GateConfig, sample_rate: f32) -> Self {
        Self {
            envelope: EnvelopeFollower::new(config.attack_ms, config.release_ms, sample_rate),
            config,
            is_open: false,
            current_gain: 0.0,
            gain_smoother: 0.0,
        }
    }

    /// Convert dB to linear.
    fn db_to_linear(db: f32) -> f32 {
        10.0_f32.powf(db / 20.0)
    }
}

impl AudioEffect for Gate {
    fn process_sample(&mut self, input: f32) -> f32 {
        // Detect envelope
        let envelope = self.envelope.process(input);

        // Determine if gate should be open or closed
        let threshold = Self::db_to_linear(self.config.threshold_db);

        let target_gain = if self.is_open {
            // Gate is open, check if we should close
            let close_threshold =
                Self::db_to_linear(self.config.threshold_db - self.config.hysteresis_db);
            if envelope < close_threshold {
                self.is_open = false;
                0.0
            } else {
                1.0
            }
        } else {
            // Gate is closed, check if we should open
            if envelope > threshold {
                self.is_open = true;
                1.0
            } else {
                0.0
            }
        };

        // Smooth gain changes
        let smoothing = 0.9;
        self.gain_smoother = target_gain + smoothing * (self.gain_smoother - target_gain);

        input * self.gain_smoother
    }

    fn reset(&mut self) {
        self.envelope.reset();
        self.is_open = false;
        self.current_gain = 0.0;
        self.gain_smoother = 0.0;
    }
}

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

    #[test]
    fn test_gate() {
        let config = GateConfig::default();
        let mut gate = Gate::new(config, 48000.0);

        // Process loud signal
        let loud_output = gate.process_sample(0.5);
        assert!(loud_output.is_finite());

        // Process quiet signal
        let quiet_output = gate.process_sample(0.001);
        assert!(quiet_output.is_finite());
    }

    #[test]
    fn test_db_to_linear() {
        assert!((Gate::db_to_linear(0.0) - 1.0).abs() < 0.01);
        assert!(Gate::db_to_linear(-40.0) < 0.1);
    }
}