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

//! Clipping detection.

/// Clipping detection result.
#[derive(Debug, Clone)]
pub struct ClippingResult {
    /// Whether clipping is detected
    pub has_clipping: bool,
    /// Number of clipped samples
    pub clipped_samples: usize,
    /// Ratio of clipped samples to total samples
    pub clipping_ratio: f32,
    /// Maximum consecutive clipped samples
    pub max_consecutive_clipped: usize,
}

/// Detect clipping in audio samples.
///
/// # Arguments
/// * `samples` - Audio samples
/// * `threshold` - Clipping threshold (typically 0.99 for digital audio)
///
/// # Returns
/// Clipping detection result
#[must_use]
pub fn detect_clipping(samples: &[f32], threshold: f32) -> ClippingResult {
    if samples.is_empty() {
        return ClippingResult {
            has_clipping: false,
            clipped_samples: 0,
            clipping_ratio: 0.0,
            max_consecutive_clipped: 0,
        };
    }

    let mut clipped_samples = 0;
    let mut consecutive = 0;
    let mut max_consecutive = 0;

    for &sample in samples {
        if sample.abs() >= threshold {
            clipped_samples += 1;
            consecutive += 1;
            max_consecutive = max_consecutive.max(consecutive);
        } else {
            consecutive = 0;
        }
    }

    let clipping_ratio = clipped_samples as f32 / samples.len() as f32;

    ClippingResult {
        has_clipping: clipped_samples > 0,
        clipped_samples,
        clipping_ratio,
        max_consecutive_clipped: max_consecutive,
    }
}

/// Detect clipping with hysteresis (more robust to noise).
#[must_use]
pub fn detect_clipping_with_hysteresis(
    samples: &[f32],
    threshold_high: f32,
    threshold_low: f32,
) -> ClippingResult {
    if samples.is_empty() {
        return ClippingResult {
            has_clipping: false,
            clipped_samples: 0,
            clipping_ratio: 0.0,
            max_consecutive_clipped: 0,
        };
    }

    let mut clipped_samples = 0;
    let mut consecutive = 0;
    let mut max_consecutive = 0;
    let mut in_clip = false;

    for &sample in samples {
        let abs_sample = sample.abs();

        if !in_clip && abs_sample >= threshold_high {
            in_clip = true;
            clipped_samples += 1;
            consecutive += 1;
        } else if in_clip {
            clipped_samples += 1;
            consecutive += 1;

            if abs_sample < threshold_low {
                in_clip = false;
                max_consecutive = max_consecutive.max(consecutive);
                consecutive = 0;
            }
        }
    }

    if in_clip {
        max_consecutive = max_consecutive.max(consecutive);
    }

    let clipping_ratio = clipped_samples as f32 / samples.len() as f32;

    ClippingResult {
        has_clipping: clipped_samples > 0,
        clipped_samples,
        clipping_ratio,
        max_consecutive_clipped: max_consecutive,
    }
}

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

    #[test]
    fn test_clipping_detection() {
        // No clipping
        let samples = vec![0.0, 0.5, -0.5, 0.8, -0.8];
        let result = detect_clipping(&samples, 0.99);
        assert!(!result.has_clipping);

        // With clipping
        let clipped = vec![0.0, 1.0, 1.0, -1.0, 0.5];
        let result = detect_clipping(&clipped, 0.99);
        assert!(result.has_clipping);
        assert!(result.clipped_samples >= 2); // At least the 1.0 and -1.0 values
    }

    #[test]
    fn test_clipping_with_hysteresis() {
        let samples = vec![0.0, 0.95, 1.0, 0.98, 0.9, 0.5];
        let result = detect_clipping_with_hysteresis(&samples, 0.99, 0.9);

        assert!(result.has_clipping);
    }
}