Synthesizer Waveforms

Cargo.toml

@@ -18,6 +18,7 @@ minimp3_fixed = { version = "0.5.4", optional = true}
 symphonia = { version = "0.5.4", optional = true, default-features = false }
 crossbeam-channel = { version = "0.5.8", optional = true }
 thiserror = "1.0.49"
+rand = "0.8.5"
 
 [features]
 default = ["flac", "vorbis", "wav", "mp3"]

examples/noise_generator.rs

@@ -0,0 +1,33 @@
+use std::thread;
+use std::time::Duration;
+
+use rodio::source::{pink, white, Source};
+
+fn main() {
+    let (_stream, stream_handle) = rodio::OutputStream::try_default().unwrap();
+
+    let noise_duration = Duration::from_millis(1000);
+    let interval_duration = Duration::from_millis(1500);
+
+    stream_handle
+        .play_raw(
+            white(cpal::SampleRate(48000))
+                .amplify(0.1)
+                .take_duration(noise_duration),
+        )
+        .unwrap();
+    println!("Playing white noise");
+
+    thread::sleep(interval_duration);
+
+    stream_handle
+        .play_raw(
+            pink(cpal::SampleRate(48000))
+                .amplify(0.1)
+                .take_duration(noise_duration),
+        )
+        .unwrap();
+    println!("Playing pink noise");
+
+    thread::sleep(interval_duration);
+}

src/source/mod.rs

@@ -21,6 +21,7 @@ pub use self::from_factory::{from_factory, FromFactoryIter};
 pub use self::from_iter::{from_iter, FromIter};
 pub use self::linear_ramp::LinearGainRamp;
 pub use self::mix::Mix;
+pub use self::noise::{pink, white, PinkNoise, WhiteNoise};
 pub use self::pausable::Pausable;
 pub use self::periodic::PeriodicAccess;
 pub use self::position::TrackPosition;
@@ -32,6 +33,7 @@ pub use self::skippable::Skippable;
 pub use self::spatial::Spatial;
 pub use self::speed::Speed;
 pub use self::stoppable::Stoppable;
+pub use self::synth::{SynthWaveform, SynthWaveformFunction};
 pub use self::take::TakeDuration;
 pub use self::uniform::UniformSourceIterator;
 pub use self::zero::Zero;
@@ -51,6 +53,7 @@ mod from_factory;
 mod from_iter;
 mod linear_ramp;
 mod mix;
+mod noise;
 mod pausable;
 mod periodic;
 mod position;
@@ -62,6 +65,7 @@ mod skippable;
 mod spatial;
 mod speed;
 mod stoppable;
+mod synth;
 mod take;
 mod uniform;
 mod zero;

src/source/noise.rs

@@ -0,0 +1,135 @@
+use crate::Source;
+
+use super::SeekError;
+
+/// Create a new white noise source.
+#[inline]
+pub fn white(sample_rate: cpal::SampleRate) -> WhiteNoise {
+    WhiteNoise::new(sample_rate)
+}
+
+/// Create a new pink noise source.
+#[inline]
+pub fn pink(sample_rate: cpal::SampleRate) -> PinkNoise {
+    PinkNoise::new(sample_rate)
+}
+
+/// Generates an infinite stream of random samples in [=1.0, 1.0]
+#[derive(Clone, Debug)]
+pub struct WhiteNoise {
+    sample_rate: cpal::SampleRate,
+}
+
+impl WhiteNoise {
+    /// Create a new white noise generator.
+    pub fn new(sample_rate: cpal::SampleRate) -> Self {
+        Self { sample_rate }
+    }
+}
+
+impl Iterator for WhiteNoise {
+    type Item = f32;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        let randf = rand::random::<f32>();
+        let scaled = randf * 2.0 - 1.0;
+        Some(scaled)
+    }
+}
+
+impl Source for WhiteNoise {
+    #[inline]
+    fn current_frame_len(&self) -> Option<usize> {
+        None
+    }
+
+    #[inline]
+    fn channels(&self) -> u16 {
+        1
+    }
+
+    #[inline]
+    fn sample_rate(&self) -> u32 {
+        self.sample_rate.0
+    }
+
+    #[inline]
+    fn total_duration(&self) -> Option<std::time::Duration> {
+        None
+    }
+
+    #[inline]
+    fn try_seek(&mut self, _: std::time::Duration) -> Result<(), SeekError> {
+        // Does nothing, should do nothing
+        Ok(())
+    }
+}
+
+// https://www.musicdsp.org/en/latest/Filters/76-pink-noise-filter.html
+//
+/// Generate an infinite stream of pink noise samples in [-1.0, 1.0].
+pub struct PinkNoise {
+    noise: WhiteNoise,
+    b: [f32; 7],
+}
+
+impl PinkNoise {
+    pub fn new(sample_rate: cpal::SampleRate) -> Self {
+        Self {
+            noise: WhiteNoise::new(sample_rate),
+            b: [0.0f32, 0.0f32, 0.0f32, 0.0f32, 0.0f32, 0.0f32, 0.0f32],
+        }
+    }
+}
+
+impl Iterator for PinkNoise {
+    type Item = f32;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let white = self.noise.next().unwrap();
+        self.b[0] = 0.99886 * self.b[0] + white * 0.0555179;
+        self.b[1] = 0.99332 * self.b[1] + white * 0.0750759;
+        self.b[2] = 0.969 * self.b[2] + white * 0.153852;
+        self.b[3] = 0.8665 * self.b[3] + white * 0.3104856;
+        self.b[4] = 0.550 * self.b[4] + white * 0.5329522;
+        self.b[5] = -0.7616 * self.b[5] - white * 0.016898;
+
+        let pink = self.b[0]
+            + self.b[1]
+            + self.b[2]
+            + self.b[3]
+            + self.b[4]
+            + self.b[5]
+            + self.b[6]
+            + white * 0.5362;
+
+        self.b[6] = white * 0.115926;
+
+        Some(pink)
+    }
+}
+
+impl Source for PinkNoise {
+    fn current_frame_len(&self) -> Option<usize> {
+        None
+    }
+
+    fn channels(&self) -> u16 {
+        1
+    }
+
+    fn sample_rate(&self) -> u32 {
+        self.noise.sample_rate()
+    }
+
+    fn total_duration(&self) -> Option<std::time::Duration> {
+        None
+    }
+
+    #[inline]
+    fn try_seek(&mut self, _: std::time::Duration) -> Result<(), SeekError> {
+        // Does nothing, should do nothing
+        Ok(())
+    }
+}

src/source/sine.rs

@@ -1,26 +1,27 @@
-use std::f32::consts::PI;
 use std::time::Duration;
 
+use crate::source::{SynthWaveform, SynthWaveformFunction};
 use crate::Source;
 
 use super::SeekError;
 
+const SAMPLE_RATE: u32 = 48000;
+
 /// An infinite source that produces a sine.
 ///
 /// Always has a rate of 48kHz and one channel.
 #[derive(Clone, Debug)]
 pub struct SineWave {
-    freq: f32,
-    num_sample: usize,
+    synth: SynthWaveform,
 }
 
 impl SineWave {
     /// The frequency of the sine.
     #[inline]
     pub fn new(freq: f32) -> SineWave {
+        let sr = cpal::SampleRate(SAMPLE_RATE);
         SineWave {
-            freq,
-            num_sample: 0,
+            synth: SynthWaveform::new(sr, freq, SynthWaveformFunction::Sine),
         }
     }
 }
@@ -30,10 +31,7 @@ impl Iterator for SineWave {
 
     #[inline]
     fn next(&mut self) -> Option<f32> {
-        self.num_sample = self.num_sample.wrapping_add(1);
-
-        let value = 2.0 * PI * self.freq * self.num_sample as f32 / 48000.0;
-        Some(value.sin())
+        self.synth.next()
     }
 }
 
@@ -50,7 +48,7 @@ impl Source for SineWave {
 
     #[inline]
     fn sample_rate(&self) -> u32 {
-        48000
+        SAMPLE_RATE
     }
 
     #[inline]
@@ -59,11 +57,7 @@ impl Source for SineWave {
     }
 
     #[inline]
-    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
-        // This is a constant sound, normal seeking would not have any effect.
-        // While changing the phase of the sine wave could change how it sounds in
-        // combination with another sound (beating) such precision is not the intend
-        // of seeking
-        Ok(())
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.synth.try_seek(pos)
     }
 }