audio-lab 0.1.0

Toolkit for audio research and testing
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

use ndarray::{Array1, Array2};
use ndarray_rand::{
    RandomExt,
    rand::{SeedableRng, rngs::StdRng},
    rand_distr::Uniform,
};

use crate::signal::{SignalError, TimeSignal};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Spectrum {
    White,
    Pink,
}

#[derive(Debug, thiserror::Error)]
pub enum NoiseError {
    #[error(transparent)]
    Signal(#[from] SignalError),
}

#[derive(Debug, Clone, Copy)]
pub struct NoiseConfig {
    pub spectrum: Spectrum,
    pub amplitude: f64,
    pub sample_rate: f64,
    pub num_channels: usize,
    /// Seed for the random number generator. `None` uses a random seed.
    pub seed: Option<u64>,
}

impl Default for NoiseConfig {
    fn default() -> Self {
        Self {
            spectrum: Spectrum::White,
            amplitude: 1.0,
            sample_rate: 48_000.0,
            num_channels: 1,
            seed: None,
        }
    }
}

pub fn generate_noise(
    num_time_steps: usize,
    config: NoiseConfig,
) -> Result<TimeSignal, NoiseError> {
    let NoiseConfig {
        spectrum,
        amplitude,
        sample_rate,
        num_channels,
        seed,
    } = config;

    let mut rng = match seed {
        Some(s) => StdRng::seed_from_u64(s),
        None => StdRng::from_os_rng(),
    };
    let data = Array2::random_using(
        (num_channels, num_time_steps),
        Uniform::new(-1.0, 1.0).unwrap(),
        &mut rng,
    );
    let mut signal = TimeSignal::new(data, sample_rate)?;

    if spectrum == Spectrum::Pink {
        let mut freq = signal.into_freq();
        let filter = Array1::from_shape_fn(freq.num_freq_bins(), |i| ((i + 1) as f64).sqrt());
        for mut channel in freq.channel_iter_mut() {
            channel.zip_mut_with(&filter, |bin, scale| *bin /= *scale);
        }
        signal = freq.into_time();
    }

    signal.normalize_peak(amplitude);

    let comment = format!("{spectrum:?} noise signal (amplitude = {amplitude})");
    signal.set_comment(Some(&comment));
    Ok(signal)
}

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

    #[test]
    fn generates_reproducible_white_noise() {
        let config = NoiseConfig {
            seed: Some(123),
            amplitude: 0.5,
            ..Default::default()
        };
        let left = generate_noise(32, config).unwrap();
        let right = generate_noise(32, config).unwrap();
        assert_eq!(left, right);
        let peak = left
            .iter()
            .fold(0.0_f64, |peak, sample| peak.max(sample.abs()));
        assert!((peak - 0.5).abs() < 1e-12);
    }

    #[test]
    fn pink_noise_is_supported() {
        let noise = generate_noise(
            64,
            NoiseConfig {
                spectrum: Spectrum::Pink,
                seed: Some(123),
                ..Default::default()
            },
        )
        .unwrap();
        assert_eq!(noise.num_time_steps(), 64);
    }
}