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

//! Background noise consistency analysis.

use crate::{AnalysisConfig, Result};

/// Noise analyzer for forensic analysis.
pub struct NoiseAnalyzer {
    config: AnalysisConfig,
}

impl NoiseAnalyzer {
    /// Create a new noise analyzer.
    #[must_use]
    pub fn new(config: AnalysisConfig) -> Self {
        Self { config }
    }

    /// Analyze noise consistency across audio.
    pub fn analyze_consistency(
        &self,
        samples: &[f32],
        _sample_rate: f32,
    ) -> Result<NoiseConsistency> {
        // Divide audio into segments and analyze noise floor in each
        let segment_size = self.config.fft_size * 10;
        let num_segments = samples.len() / segment_size;

        if num_segments < 2 {
            return Ok(NoiseConsistency {
                is_consistent: true,
                noise_floor_variation: 0.0,
            });
        }

        let mut noise_floors = Vec::new();

        for i in 0..num_segments {
            let start = i * segment_size;
            let end = ((i + 1) * segment_size).min(samples.len());
            let segment = &samples[start..end];

            let noise_floor = self.estimate_noise_floor(segment);
            noise_floors.push(noise_floor);
        }

        // Compute variation in noise floors
        let mean = noise_floors.iter().sum::<f32>() / noise_floors.len() as f32;
        let variance = noise_floors
            .iter()
            .map(|&x| (x - mean).powi(2))
            .sum::<f32>()
            / noise_floors.len() as f32;

        let std_dev = variance.sqrt();
        let coefficient_of_variation = if mean > 0.0 { std_dev / mean } else { 0.0 };

        // Noise should be relatively consistent
        let is_consistent = coefficient_of_variation < 0.5;

        Ok(NoiseConsistency {
            is_consistent,
            noise_floor_variation: coefficient_of_variation,
        })
    }

    /// Estimate noise floor from audio segment.
    #[allow(clippy::unused_self)]
    fn estimate_noise_floor(&self, samples: &[f32]) -> f32 {
        if samples.is_empty() {
            return 0.0;
        }

        // Use lower percentile of amplitudes as noise floor estimate
        let mut amplitudes: Vec<f32> = samples.iter().map(|&x| x.abs()).collect();
        amplitudes.sort_by(|a, b| a.partial_cmp(b).unwrap());

        // 10th percentile as noise floor
        let percentile_idx = (amplitudes.len() as f32 * 0.1) as usize;
        amplitudes[percentile_idx]
    }
}

/// Noise consistency analysis result.
#[derive(Debug, Clone)]
pub struct NoiseConsistency {
    /// Whether noise floor is consistent
    pub is_consistent: bool,
    /// Coefficient of variation of noise floor
    pub noise_floor_variation: f32,
}

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

    #[test]
    fn test_noise_analyzer() {
        let config = AnalysisConfig::default();
        let analyzer = NoiseAnalyzer::new(config);

        // Generate signal with consistent noise
        let mut samples = Vec::new();
        for _ in 0..100000 {
            samples.push(0.01); // Constant low-level noise
        }

        let result = analyzer.analyze_consistency(&samples, 44100.0);
        assert!(result.is_ok());

        let consistency = result.unwrap();
        assert!(consistency.is_consistent);
    }

    #[test]
    fn test_noise_floor_estimation() {
        let config = AnalysisConfig::default();
        let analyzer = NoiseAnalyzer::new(config);

        let samples = vec![0.01, 0.02, 0.01, 0.5, 0.8, 0.01]; // Mostly low, some peaks
        let floor = analyzer.estimate_noise_floor(&samples);

        assert!(floor < 0.1); // Should be close to low values
    }
}