Vendor dependencies for 0.3.0 release

vendor/rodio/examples/automatic_gain_control.rs

@@ -0,0 +1,46 @@
+use rodio::source::Source;
+use rodio::Decoder;
+use std::fs::File;
+use std::io::BufReader;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    // Decode the sound file into a source
+    let file = BufReader::new(File::open("assets/music.flac").unwrap());
+    let source = Decoder::new(file).unwrap();
+
+    // Apply automatic gain control to the source
+    let agc_source = source.automatic_gain_control(1.0, 4.0, 0.005, 5.0);
+
+    // Make it so that the source checks if automatic gain control should be
+    // enabled or disabled every 5 milliseconds. We must clone `agc_enabled`
+    // or we would lose it when we move it into the periodic access.
+    let agc_enabled = Arc::new(AtomicBool::new(true));
+    let agc_enabled_clone = agc_enabled.clone();
+    let controlled = agc_source.periodic_access(Duration::from_millis(5), move |agc_source| {
+        agc_source.set_enabled(agc_enabled_clone.load(Ordering::Relaxed));
+    });
+
+    // Add the source now equipped with automatic gain control and controlled via
+    // periodic_access to the sink for playback
+    sink.append(controlled);
+
+    // after 5 seconds of playback disable automatic gain control using the
+    // shared AtomicBool `agc_enabled`. You could do this from another part
+    // of the program since `agc_enabled` is of type Arc<AtomicBool> which
+    // is freely clone-able and move-able.
+    //
+    // Note that disabling the AGC takes up to 5 millis because periodic_access
+    // controls the source every 5 millis.
+    thread::sleep(Duration::from_secs(5));
+    agc_enabled.store(false, Ordering::Relaxed);
+
+    // Keep the program running until playback is complete
+    sink.sleep_until_end();
+}

vendor/rodio/examples/basic.rs

@@ -0,0 +1,36 @@
+use std::io::BufReader;
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    let (_stream, stream_handle) = rodio::OutputStream::try_default().unwrap();
+
+    let file = std::fs::File::open("assets/beep.wav").unwrap();
+    let beep1 = stream_handle.play_once(BufReader::new(file)).unwrap();
+    beep1.set_volume(0.2);
+    println!("Started beep1");
+
+    thread::sleep(Duration::from_millis(1500));
+
+    let file = std::fs::File::open("assets/beep2.wav").unwrap();
+    let beep2 = stream_handle.play_once(BufReader::new(file)).unwrap();
+    beep2.set_volume(0.3);
+    beep2.detach();
+    println!("Started beep2");
+
+    thread::sleep(Duration::from_millis(1500));
+    let file = std::fs::File::open("assets/beep3.ogg").unwrap();
+    let beep3 = stream_handle.play_once(file).unwrap();
+    beep3.set_volume(0.2);
+    println!("Started beep3");
+
+    thread::sleep(Duration::from_millis(1500));
+    drop(beep1);
+    println!("Stopped beep1");
+
+    thread::sleep(Duration::from_millis(1500));
+    drop(beep3);
+    println!("Stopped beep3");
+
+    thread::sleep(Duration::from_millis(1500));
+}

vendor/rodio/examples/mix_multiple_sources.rs

@@ -0,0 +1,38 @@
+use rodio::source::{SineWave, Source};
+use rodio::{dynamic_mixer, OutputStream, Sink};
+use std::time::Duration;
+
+fn main() {
+    // Construct a dynamic controller and mixer, stream_handle, and sink.
+    let (controller, mixer) = dynamic_mixer::mixer::<f32>(2, 44_100);
+    let (_stream, stream_handle) = OutputStream::try_default().unwrap();
+    let sink = Sink::try_new(&stream_handle).unwrap();
+
+    // Create four unique sources. The frequencies used here correspond
+    // notes in the key of C and in octave 4: C4, or middle C on a piano,
+    // E4, G4, and A4 respectively.
+    let source_c = SineWave::new(261.63)
+        .take_duration(Duration::from_secs_f32(1.))
+        .amplify(0.20);
+    let source_e = SineWave::new(329.63)
+        .take_duration(Duration::from_secs_f32(1.))
+        .amplify(0.20);
+    let source_g = SineWave::new(392.0)
+        .take_duration(Duration::from_secs_f32(1.))
+        .amplify(0.20);
+    let source_a = SineWave::new(440.0)
+        .take_duration(Duration::from_secs_f32(1.))
+        .amplify(0.20);
+
+    // Add sources C, E, G, and A to the mixer controller.
+    controller.add(source_c);
+    controller.add(source_e);
+    controller.add(source_g);
+    controller.add(source_a);
+
+    // Append the dynamic mixer to the sink to play a C major 6th chord.
+    sink.append(mixer);
+
+    // Sleep the thread until sink is empty.
+    sink.sleep_until_end();
+}

vendor/rodio/examples/music_flac.rs

@@ -0,0 +1,11 @@
+use std::io::BufReader;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/music.flac").unwrap();
+    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
+
+    sink.sleep_until_end();
+}

vendor/rodio/examples/music_m4a.rs

@@ -0,0 +1,11 @@
+use std::io::BufReader;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/music.m4a").unwrap();
+    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
+
+    sink.sleep_until_end();
+}

vendor/rodio/examples/music_mp3.rs

@@ -0,0 +1,11 @@
+use std::io::BufReader;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/music.mp3").unwrap();
+    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
+
+    sink.sleep_until_end();
+}

vendor/rodio/examples/music_ogg.rs

@@ -0,0 +1,11 @@
+use std::io::BufReader;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/music.ogg").unwrap();
+    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
+
+    sink.sleep_until_end();
+}

vendor/rodio/examples/music_wav.rs

@@ -0,0 +1,11 @@
+use std::io::BufReader;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/music.wav").unwrap();
+    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
+
+    sink.sleep_until_end();
+}

vendor/rodio/examples/noise_generator.rs

@@ -0,0 +1,41 @@
+//! Noise generator example. Use the "noise" feature to enable the noise generator sources.
+
+#[cfg(feature = "noise")]
+fn main() {
+    use rodio::source::{pink, white, Source};
+    use std::thread;
+    use std::time::Duration;
+
+    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);
+}
+
+#[cfg(not(feature = "noise"))]
+fn main() {
+    println!("rodio has not been compiled with noise sources, use `--features noise` to enable this feature.");
+    println!("Exiting...");
+}

vendor/rodio/examples/reverb.rs

@@ -0,0 +1,15 @@
+use rodio::Source;
+use std::io::BufReader;
+use std::time::Duration;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/music.ogg").unwrap();
+    let source = rodio::Decoder::new(BufReader::new(file)).unwrap();
+    let with_reverb = source.buffered().reverb(Duration::from_millis(40), 0.7);
+    sink.append(with_reverb);
+
+    sink.sleep_until_end();
+}

vendor/rodio/examples/seek_mp3.rs

@@ -0,0 +1,22 @@
+use std::io::BufReader;
+use std::time::Duration;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/music.mp3").unwrap();
+    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
+
+    std::thread::sleep(std::time::Duration::from_secs(2));
+    sink.try_seek(Duration::from_secs(0)).unwrap();
+
+    std::thread::sleep(std::time::Duration::from_secs(2));
+    sink.try_seek(Duration::from_secs(4)).unwrap();
+
+    sink.sleep_until_end();
+
+    // wont do anything since the sound has ended already
+    sink.try_seek(Duration::from_secs(5)).unwrap();
+    println!("seek example ended");
+}

vendor/rodio/examples/signal_generator.rs

@@ -0,0 +1,83 @@
+//! Test signal generator example.
+
+fn main() {
+    use rodio::source::{chirp, Function, SignalGenerator, Source};
+    use std::thread;
+    use std::time::Duration;
+
+    let (_stream, stream_handle) = rodio::OutputStream::try_default().unwrap();
+
+    let test_signal_duration = Duration::from_millis(1000);
+    let interval_duration = Duration::from_millis(1500);
+
+    println!("Playing 1000 Hz tone");
+    stream_handle
+        .play_raw(
+            SignalGenerator::new(cpal::SampleRate(48000), 1000.0, Function::Sine)
+                .amplify(0.1)
+                .take_duration(test_signal_duration),
+        )
+        .unwrap();
+
+    thread::sleep(interval_duration);
+
+    println!("Playing 10,000 Hz tone");
+    stream_handle
+        .play_raw(
+            SignalGenerator::new(cpal::SampleRate(48000), 10000.0, Function::Sine)
+                .amplify(0.1)
+                .take_duration(test_signal_duration),
+        )
+        .unwrap();
+
+    thread::sleep(interval_duration);
+
+    println!("Playing 440 Hz Triangle Wave");
+    stream_handle
+        .play_raw(
+            SignalGenerator::new(cpal::SampleRate(48000), 440.0, Function::Triangle)
+                .amplify(0.1)
+                .take_duration(test_signal_duration),
+        )
+        .unwrap();
+
+    thread::sleep(interval_duration);
+
+    println!("Playing 440 Hz Sawtooth Wave");
+    stream_handle
+        .play_raw(
+            SignalGenerator::new(cpal::SampleRate(48000), 440.0, Function::Sawtooth)
+                .amplify(0.1)
+                .take_duration(test_signal_duration),
+        )
+        .unwrap();
+
+    thread::sleep(interval_duration);
+
+    println!("Playing 440 Hz Square Wave");
+    stream_handle
+        .play_raw(
+            SignalGenerator::new(cpal::SampleRate(48000), 440.0, Function::Square)
+                .amplify(0.1)
+                .take_duration(test_signal_duration),
+        )
+        .unwrap();
+
+    thread::sleep(interval_duration);
+
+    println!("Playing 20-10000 Hz Sweep");
+    stream_handle
+        .play_raw(
+            chirp(
+                cpal::SampleRate(48000),
+                20.0,
+                10000.0,
+                Duration::from_secs(1),
+            )
+            .amplify(0.1)
+            .take_duration(test_signal_duration),
+        )
+        .unwrap();
+
+    thread::sleep(interval_duration);
+}

vendor/rodio/examples/spatial.rs

@@ -0,0 +1,53 @@
+use std::io::BufReader;
+use std::thread;
+use std::time::Duration;
+
+use rodio::Source;
+
+fn main() {
+    let iter_duration = Duration::from_secs(5);
+    let iter_distance = 5.;
+
+    let refresh_duration = Duration::from_millis(10);
+
+    let num_steps = iter_duration.as_secs_f32() / refresh_duration.as_secs_f32();
+    let step_distance = iter_distance / num_steps;
+    let num_steps = num_steps as u32;
+
+    let repeats = 5;
+
+    let total_duration = iter_duration * 2 * repeats;
+
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let mut positions = ([0., 0., 0.], [-1., 0., 0.], [1., 0., 0.]);
+    let sink = rodio::SpatialSink::try_new(&handle, positions.0, positions.1, positions.2).unwrap();
+
+    let file = std::fs::File::open("assets/music.ogg").unwrap();
+    let source = rodio::Decoder::new(BufReader::new(file))
+        .unwrap()
+        .repeat_infinite()
+        .take_duration(total_duration);
+    sink.append(source);
+    // A sound emitter playing the music starting at the centre gradually moves to the right
+    // until it stops and begins traveling to the left, it will eventually pass through the
+    // listener again and go to the far left.
+    // This is repeated 5 times.
+    for _ in 0..repeats {
+        for _ in 0..num_steps {
+            thread::sleep(refresh_duration);
+            positions.0[0] += step_distance;
+            sink.set_emitter_position(positions.0);
+        }
+        for _ in 0..(num_steps * 2) {
+            thread::sleep(refresh_duration);
+            positions.0[0] -= step_distance;
+            sink.set_emitter_position(positions.0);
+        }
+        for _ in 0..num_steps {
+            thread::sleep(refresh_duration);
+            positions.0[0] += step_distance;
+            sink.set_emitter_position(positions.0);
+        }
+    }
+    sink.sleep_until_end();
+}

vendor/rodio/examples/stereo.rs

@@ -0,0 +1,12 @@
+//! Plays a tone alternating between right and left ears, with right being first.
+use std::io::BufReader;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/RL.ogg").unwrap();
+    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
+
+    sink.sleep_until_end();
+}