oximedia-audio-analysis 0.1.7

Audio analysis tools for media including loudness, spectrum, and speech detection
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

//! Echo and reverb detection.

use crate::{AnalysisConfig, Result};

/// Echo detector for detecting echoes and reverb.
pub struct EchoDetector {
    #[allow(dead_code)]
    config: AnalysisConfig,
}

impl EchoDetector {
    /// Create a new echo detector.
    #[must_use]
    pub fn new(config: AnalysisConfig) -> Self {
        Self { config }
    }

    /// Detect echo in audio samples.
    pub fn detect(&self, samples: &[f32], sample_rate: f32) -> Result<EchoResult> {
        // Compute autocorrelation to find repeating patterns
        let max_delay = (sample_rate * 2.0) as usize; // Check up to 2 seconds
        let autocorr = self.compute_autocorrelation(samples, max_delay);

        // Find peaks in autocorrelation (indicating echoes)
        let echo_delays = self.find_echo_delays(&autocorr, sample_rate);

        // Estimate reverb amount from decay
        let reverb_amount = self.estimate_reverb(&autocorr);

        Ok(EchoResult {
            has_echo: !echo_delays.is_empty(),
            echo_delays,
            reverb_amount,
        })
    }

    /// Compute autocorrelation.
    #[allow(clippy::unused_self)]
    fn compute_autocorrelation(&self, samples: &[f32], max_lag: usize) -> Vec<f32> {
        let max_lag = max_lag.min(samples.len());
        let mut autocorr = vec![0.0; max_lag];

        for lag in 0..max_lag {
            let mut sum = 0.0;
            let mut norm = 0.0;

            for i in 0..(samples.len() - lag) {
                sum += samples[i] * samples[i + lag];
                norm += samples[i] * samples[i];
            }

            autocorr[lag] = if norm > 0.0 { sum / norm } else { 0.0 };
        }

        autocorr
    }

    /// Find echo delays from autocorrelation peaks.
    #[allow(clippy::unused_self)]
    fn find_echo_delays(&self, autocorr: &[f32], sample_rate: f32) -> Vec<f32> {
        let min_delay_samples = (sample_rate * 0.02) as usize; // Minimum 20ms
        let threshold = 0.3;

        let mut delays = Vec::new();

        for i in min_delay_samples..(autocorr.len() - 1) {
            if autocorr[i] > threshold
                && autocorr[i] > autocorr[i - 1]
                && autocorr[i] > autocorr[i + 1]
            {
                let delay_seconds = i as f32 / sample_rate;
                delays.push(delay_seconds);

                if delays.len() >= 5 {
                    break;
                }
            }
        }

        delays
    }

    /// Estimate reverb amount from autocorrelation decay.
    #[allow(clippy::unused_self)]
    fn estimate_reverb(&self, autocorr: &[f32]) -> f32 {
        if autocorr.len() < 100 {
            return 0.0;
        }

        // Measure how slowly autocorrelation decays
        let early = autocorr[10..50].iter().sum::<f32>() / 40.0;
        let late = autocorr[100..(autocorr.len().min(500))].iter().sum::<f32>()
            / (autocorr.len().min(500) - 100) as f32;

        // More reverb = slower decay = higher late/early ratio
        (late / (early + 1e-6)).min(1.0)
    }
}

/// Echo detection result.
#[derive(Debug, Clone)]
pub struct EchoResult {
    /// Whether echo is detected
    pub has_echo: bool,
    /// Echo delay times in seconds
    pub echo_delays: Vec<f32>,
    /// Reverb amount (0-1)
    pub reverb_amount: f32,
}

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

    #[test]
    fn test_echo_detector() {
        let config = AnalysisConfig::default();
        let detector = EchoDetector::new(config);

        // Use a low sample rate and short buffer to keep autocorrelation fast
        // (compute_autocorrelation is O(max_lag * n), so large buffers are very slow)
        let sample_rate = 4000.0;
        let mut samples = vec![0.0; (sample_rate * 0.5) as usize]; // 0.5s buffer

        // Original signal
        for i in 0..200 {
            samples[i] = (2.0 * std::f32::consts::PI * 440.0 * i as f32 / sample_rate).sin();
        }

        // Echo at 0.1 seconds
        let echo_delay = (sample_rate * 0.1) as usize;
        for i in 0..200 {
            if i + echo_delay < samples.len() {
                samples[i + echo_delay] += 0.5 * samples[i];
            }
        }

        let result = detector
            .detect(&samples, sample_rate)
            .expect("detection should succeed");
        assert!(result.has_echo || result.reverb_amount > 0.0);
    }
}