oximedia-audio-analysis 0.1.0

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
144
145
146
147
148
149

//! Noise type classification.

use crate::spectral::SpectralFeatures;

/// Noise type classification.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NoiseType {
    /// White noise (flat spectrum)
    White,
    /// Pink noise (1/f spectrum)
    Pink,
    /// Brown/red noise (1/f² spectrum)
    Brown,
    /// Environmental noise
    Environmental,
    /// Hum (power line interference)
    Hum,
    /// Unknown/other
    Unknown,
}

/// Classify noise type from spectral features.
///
/// # Arguments
/// * `spectral` - Spectral features of the noise
///
/// # Returns
/// Classified noise type
#[must_use]
pub fn classify_noise(spectral: &SpectralFeatures) -> NoiseType {
    // White noise: flat spectrum (high flatness)
    if spectral.flatness > 0.9 {
        return NoiseType::White;
    }

    // Hum: very low frequency peak
    if spectral.centroid < 100.0 && spectral.flatness < 0.3 {
        return NoiseType::Hum;
    }

    // Analyze spectral slope
    let slope = estimate_spectral_slope(&spectral.magnitude_spectrum);

    // Pink noise: -3 dB/octave slope
    if slope < -2.0 && slope > -4.0 {
        return NoiseType::Pink;
    }

    // Brown noise: -6 dB/octave slope
    if slope < -5.0 && slope > -7.0 {
        return NoiseType::Brown;
    }

    // Environmental noise: irregular spectrum
    if spectral.flatness > 0.3 && spectral.flatness < 0.7 {
        return NoiseType::Environmental;
    }

    NoiseType::Unknown
}

/// Estimate spectral slope (in dB/octave).
fn estimate_spectral_slope(spectrum: &[f32]) -> f32 {
    if spectrum.len() < 10 {
        return 0.0;
    }

    // Divide spectrum into logarithmic bins (octaves)
    let num_bins = 6;
    let mut bin_energies = vec![0.0; num_bins];
    let mut bin_counts = vec![0; num_bins];

    for (i, &mag) in spectrum.iter().enumerate() {
        if i > 0 {
            let octave = (i as f32).log2() as usize;
            if octave < num_bins {
                bin_energies[octave] += mag * mag;
                bin_counts[octave] += 1;
            }
        }
    }

    // Average energy per bin
    for i in 0..num_bins {
        if bin_counts[i] > 0 {
            bin_energies[i] /= bin_counts[i] as f32;
        }
    }

    // Compute slope via linear regression in log space
    let mut sum_x = 0.0;
    let mut sum_y = 0.0;
    let mut sum_xy = 0.0;
    let mut sum_xx = 0.0;
    let mut n = 0;

    for (i, &energy) in bin_energies.iter().enumerate() {
        if energy > 0.0 {
            let x = i as f32;
            let y = 10.0 * energy.log10();

            sum_x += x;
            sum_y += y;
            sum_xy += x * y;
            sum_xx += x * x;
            n += 1;
        }
    }

    if n > 1 {
        (n as f32 * sum_xy - sum_x * sum_y) / (n as f32 * sum_xx - sum_x * sum_x)
    } else {
        0.0
    }
}

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

    #[test]
    fn test_noise_classification() {
        // White noise: flat spectrum
        let white_spectral = SpectralFeatures {
            centroid: 1000.0,
            flatness: 0.95,
            crest: 1.5,
            bandwidth: 2000.0,
            rolloff: 5000.0,
            flux: 0.0,
            magnitude_spectrum: vec![1.0; 100],
        };

        assert_eq!(classify_noise(&white_spectral), NoiseType::White);

        // Hum: low frequency
        let hum_spectral = SpectralFeatures {
            centroid: 60.0,
            flatness: 0.1,
            crest: 5.0,
            bandwidth: 50.0,
            rolloff: 100.0,
            flux: 0.0,
            magnitude_spectrum: vec![0.1; 100],
        };

        assert_eq!(classify_noise(&hum_spectral), NoiseType::Hum);
    }
}