Merge pull request #7 from SolarLiner/duplex

Initial duplex audio wrapper for single input/output stream pairs

Cargo.toml

@@ -11,6 +11,7 @@ log = "0.4.22"
 ndarray = "0.15.6"
 oneshot = "0.1.8"
 thiserror = "1.0.63"
+rtrb = "0.3.1"
 
 [dev-dependencies]
 anyhow = "1.0.86"

examples/duplex.rs

@@ -0,0 +1,50 @@
+use crate::util::sine::SineWave;
+use anyhow::Result;
+use interflow::duplex::AudioDuplexCallback;
+use interflow::prelude::*;
+
+mod util;
+
+fn main() -> Result<()> {
+    let input = default_input_device();
+    let output = default_output_device();
+    let mut input_config = input.default_input_config().unwrap();
+    input_config.buffer_size_range = (Some(128), Some(512));
+    let mut output_config = output.default_output_config().unwrap();
+    output_config.buffer_size_range = (Some(128), Some(512));
+    let stream =
+        duplex::create_duplex_stream(input, input_config, output, output_config, RingMod::new())
+            .unwrap();
+    println!("Press Enter to stop");
+    std::io::stdin().read_line(&mut String::new())?;
+    stream.eject().unwrap();
+    Ok(())
+}
+
+struct RingMod {
+    carrier: SineWave,
+}
+
+impl RingMod {
+    fn new() -> Self {
+        Self {
+            carrier: SineWave::new(440.0),
+        }
+    }
+}
+
+impl AudioDuplexCallback for RingMod {
+    fn on_audio_data(
+        &mut self,
+        context: AudioCallbackContext,
+        input: AudioInput<f32>,
+        mut output: AudioOutput<f32>,
+    ) {
+        let sr = context.stream_config.samplerate as f32;
+        for i in 0..output.buffer.num_samples() {
+            let inp = input.buffer.get_frame(i)[0];
+            let c = self.carrier.next_sample(sr);
+            output.buffer.set_mono(i, inp * c);
+        }
+    }
+}

examples/sine_wave.rs

@@ -1,54 +1,20 @@
-use std::f32::consts::TAU;
-
 use anyhow::Result;
-
+use util::sine::SineWave;
 use interflow::prelude::*;
 
+mod util;
+
 fn main() -> Result<()> {
     env_logger::init();
 
     let device = default_output_device();
     println!("Using device {}", device.name());
     let stream = device
-        .default_output_stream(SineWave {
-            frequency: 440.,
-            phase: 0.,
-        })
+        .default_output_stream(SineWave::new(440.0))
         .unwrap();
     println!("Press Enter to stop");
     std::io::stdin().read_line(&mut String::new())?;
     stream.eject().unwrap();
     Ok(())
 }
 
-struct SineWave {
-    frequency: f32,
-    phase: f32,
-}
-
-impl AudioOutputCallback for SineWave {
-    fn on_output_data(&mut self, context: AudioCallbackContext, mut output: AudioOutput<f32>) {
-        eprintln!(
-            "Callback called, timestamp: {:2.3} s",
-            context.timestamp.as_seconds()
-        );
-        let sr = context.timestamp.samplerate as f32;
-        for i in 0..output.buffer.num_samples() {
-            output.buffer.set_mono(i, self.next_sample(sr));
-        }
-        // Reduce amplitude to not blow up speakers and ears
-        output.buffer.change_amplitude(0.125);
-    }
-}
-
-impl SineWave {
-    pub fn next_sample(&mut self, samplerate: f32) -> f32 {
-        let step = samplerate.recip() * self.frequency;
-        let y = (TAU * self.phase).sin();
-        self.phase += step;
-        if self.phase > 1. {
-            self.phase -= 1.;
-        }
-        y
-    }
-}

examples/util/mod.rs

@@ -1 +1,2 @@
 pub mod enumerate;
+pub mod sine;

examples/util/sine.rs

@@ -0,0 +1,41 @@
+use interflow::{AudioCallbackContext, AudioOutput, AudioOutputCallback};
+use std::f32::consts::TAU;
+
+pub struct SineWave {
+    pub frequency: f32,
+    pub phase: f32,
+}
+
+impl AudioOutputCallback for SineWave {
+    fn on_output_data(&mut self, context: AudioCallbackContext, mut output: AudioOutput<f32>) {
+        eprintln!(
+            "Callback called, timestamp: {:2.3} s",
+            context.timestamp.as_seconds()
+        );
+        let sr = context.timestamp.samplerate as f32;
+        for i in 0..output.buffer.num_samples() {
+            output.buffer.set_mono(i, self.next_sample(sr));
+        }
+        // Reduce amplitude to not blow up speakers and ears
+        output.buffer.change_amplitude(0.125);
+    }
+}
+
+impl SineWave {
+    pub fn new(frequency: f32) -> Self {
+        Self {
+            frequency,
+            phase: 0.0,
+        }
+    }
+
+    pub fn next_sample(&mut self, samplerate: f32) -> f32 {
+        let step = samplerate.recip() * self.frequency;
+        let y = (TAU * self.phase).sin();
+        self.phase += step;
+        if self.phase > 1. {
+            self.phase -= 1.;
+        }
+        y
+    }
+}

src/audio_buffer.rs

@@ -286,6 +286,21 @@ impl<S: DataMut> AudioBufferBase<S>
 where
     S::Elem: Clone,
 {
+    /// Returns a mutable view over each channel of the frame at the given index.
+    /// 
+    /// # Arguments 
+    /// 
+    /// * `sample`: Sample index for the frame to return.
+    /// 
+    /// # Panics
+    /// 
+    /// Panics if the sample index is out of range.
+    /// 
+    /// returns: ArrayBase<ViewRepr<&mut <S as RawData>::Elem>, Dim<[usize; 1]>> 
+    pub fn get_frame_mut(&mut self, sample: usize) -> ArrayViewMut1<S::Elem> {
+        self.storage.column_mut(sample)
+    }
+
     /// Sets audio data of a single frame, that is all channels at the specified sample index.
     /// Panics when the sample is out of range.
     pub fn set_frame<'a>(&mut self, sample: usize, data: impl AsArray<'a, S::Elem, Ix1>)

src/backends/mod.rs

@@ -34,7 +34,7 @@ pub mod wasapi;
 /// | **Platform** | **Driver** |
 /// |:------------:|:----------:|
 /// |     Linux    |    ALSA    |
-/// |     macOS    | CoreAudio  |
+/// |     macOS    |  CoreAudio |
 /// |    Windows   |   WASAPI   |
 #[cfg(any(os_alsa, os_coreaudio, os_wasapi))]
 #[allow(clippy::needless_return)]

src/backends/wasapi/stream.rs

@@ -264,16 +264,15 @@ impl<Callback: AudioInputCallback> AudioThread<Callback, Audio::IAudioCaptureCli
     }
 
     fn process(&mut self) -> Result<(), error::WasapiError> {
-        let frames_available = unsafe {
-            self.interface.GetNextPacketSize()? as usize
-        };
+        let frames_available = unsafe { self.interface.GetNextPacketSize()? as usize };
         if frames_available == 0 {
             return Ok(());
         }
         let Some(mut buffer) = AudioCaptureBuffer::<f32>::from_client(
             &self.interface,
             self.stream_config.channels.count(),
-        )? else {
+        )?
+        else {
             eprintln!("Null buffer from WASAPI");
             return Ok(());
         };