Draft: Revamped API

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "rust-analyzer.cargo.features": [
+        "pipewire"
+    ]
+}

examples/duplex.rs

@@ -1,20 +1,24 @@
 use crate::util::sine::SineWave;
 use anyhow::Result;
-use interflow::duplex::AudioDuplexCallback;
 use interflow::prelude::*;
 
 mod util;
 
+//noinspection RsUnwrap
 fn main() -> Result<()> {
+    env_logger::init();
     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 duplex_config = DuplexStreamConfig::new(input_config, output_config);
-    let stream =
-        duplex::create_duplex_stream(input, output, RingMod::new(), duplex_config).unwrap();
+    log::info!("Opening input: {}", input.name());
+    log::info!("Opening output: {}", output.name());
+    let config = StreamConfig {
+        buffer_size_range: (Some(128), Some(512)),
+        input_channels: 2,
+        output_channels: 2,
+        ..output.default_config().unwrap()
+    };
+    let duplex_config = DuplexStreamConfig::new(config);
+    let stream = create_duplex_stream(input, output, RingMod::new(), duplex_config).unwrap();
     println!("Press Enter to stop");
     std::io::stdin().read_line(&mut String::new())?;
     stream.eject().unwrap();
@@ -33,17 +37,21 @@ impl RingMod {
     }
 }
 
-impl AudioDuplexCallback for RingMod {
-    fn on_audio_data(
+impl AudioCallback for RingMod {
+    fn prepare(&mut self, context: AudioCallbackContext) {
+        self.carrier.prepare(context);
+    }
+
+    fn process_audio(
         &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 sr = context.stream_config.sample_rate as f32;
+        for i in 0..output.buffer.num_frames() {
             let inp = input.buffer.get_frame(i)[0];
-            let c = self.carrier.next_sample(sr);
+            let c = self.carrier.next_sample();
             output.buffer.set_mono(i, inp * c);
         }
     }

examples/input.rs

@@ -12,7 +12,7 @@ fn main() -> Result<()> {
     let device = default_input_device();
     let value = Arc::new(AtomicF32::new(0.));
     let stream = device
-        .default_input_stream(RmsMeter::new(value.clone()))
+        .default_stream(DeviceType::INPUT, RmsMeter::new(value.clone()))
         .unwrap();
     util::display_peakmeter(value)?;
     stream.eject().unwrap();
@@ -30,12 +30,23 @@ impl RmsMeter {
     }
 }
 
-impl AudioInputCallback for RmsMeter {
-    fn on_input_data(&mut self, context: AudioCallbackContext, input: AudioInput<f32>) {
+impl AudioCallback for RmsMeter {
+    fn prepare(&mut self, context: AudioCallbackContext) {
         let meter = self
             .meter
-            .get_or_insert_with(|| PeakMeter::new(context.stream_config.samplerate as f32, 15.0));
-        meter.set_samplerate(context.stream_config.samplerate as f32);
+            .get_or_insert_with(|| PeakMeter::new(context.stream_config.sample_rate as f32, 15.0));
+        meter.set_samplerate(context.stream_config.sample_rate as f32);
+    }
+    fn process_audio(
+        &mut self,
+        _: AudioCallbackContext,
+        input: AudioInput<f32>,
+        _output: AudioOutput<f32>,
+    ) {
+        let meter = self
+            .meter
+            .as_mut()
+            .expect("Peak meter not constructed, prepare not called");
         meter.process_buffer(input.buffer.as_ref());
         self.value
             .store(meter.value(), std::sync::atomic::Ordering::Relaxed);

examples/loopback.rs

@@ -10,14 +10,16 @@ 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));
-    input_config.channels = 0b01;
-    output_config.channels = 0b11;
+    log::info!("Opening input : {}", input.name());
+    log::info!("Opening output: {}", output.name());
+    let config = StreamConfig {
+        buffer_size_range: (Some(128), Some(512)),
+        input_channels: 1,
+        output_channels: 1,
+        ..output.default_config().unwrap()
+    };
     let value = Arc::new(AtomicF32::new(0.));
-    let config = DuplexStreamConfig::new(input_config, output_config);
+    let config = DuplexStreamConfig::new(config);
     let stream =
         create_duplex_stream(input, output, Loopback::new(44100., value.clone()), config).unwrap();
     util::display_peakmeter(value)?;
@@ -39,15 +41,16 @@ impl Loopback {
     }
 }
 
-impl AudioDuplexCallback for Loopback {
-    fn on_audio_data(
+impl AudioCallback for Loopback {
+    fn prepare(&mut self, context: AudioCallbackContext) {}
+    fn process_audio(
         &mut self,
         context: AudioCallbackContext,
         input: AudioInput<f32>,
         mut output: AudioOutput<f32>,
     ) {
         self.meter
-            .set_samplerate(context.stream_config.samplerate as f32);
+            .set_samplerate(context.stream_config.sample_rate as f32);
         let rms = self.meter.process_buffer(input.buffer.as_ref());
         self.value.store(rms, std::sync::atomic::Ordering::Relaxed);
         output.buffer.as_interleaved_mut().fill(0.0);

examples/set_buffer_size.rs

@@ -6,7 +6,7 @@ mod util;
 #[cfg(os_coreaudio)]
 fn main() -> anyhow::Result<()> {
     use interflow::backends::coreaudio::CoreAudioDriver;
-    use interflow::channel_map::{ChannelMap32, CreateBitset};
+    use interflow::channel_map::CreateBitset;
     use interflow::prelude::*;
     use std::sync::{
         atomic::{AtomicBool, Ordering},
@@ -19,19 +19,23 @@ fn main() -> anyhow::Result<()> {
         sine_wave: SineWave,
     }
 
-    impl AudioOutputCallback for MyCallback {
-        fn on_output_data(&mut self, context: AudioCallbackContext, mut output: AudioOutput<f32>) {
+    impl AudioCallback for MyCallback {
+        fn prepare(&mut self, context: AudioCallbackContext) {
+            self.sine_wave.prepare(context);
+        }
+
+        fn process_audio(&mut self, _: AudioCallbackContext, _: AudioInput<f32>, mut output: AudioOutput<f32>) {
             if self.first_callback.swap(false, Ordering::SeqCst) {
                 println!(
                     "Actual buffer size granted by OS: {}",
-                    output.buffer.num_samples()
+                    output.buffer.num_frames()
                 );
             }
 
             for mut frame in output.buffer.as_interleaved_mut().rows_mut() {
                 let sample = self
                     .sine_wave
-                    .next_sample(context.stream_config.samplerate as f32);
+                    .next_sample();
                 for channel_sample in &mut frame {
                     *channel_sample = sample;
                 }
@@ -61,8 +65,9 @@ fn main() -> anyhow::Result<()> {
     println!("Requesting buffer size: {}", requested_buffer_size);
 
     let stream_config = StreamConfig {
-        samplerate: 48000.0,
-        channels: ChannelMap32::from_indices([0, 1]),
+        sample_rate: 48000.0,
+        input_channels: 0,
+        output_channels: 2,
         buffer_size_range: (Some(requested_buffer_size), Some(requested_buffer_size)),
         exclusive: false,
     };
@@ -72,7 +77,7 @@ fn main() -> anyhow::Result<()> {
         sine_wave: SineWave::new(440.0),
     };
 
-    let stream = device.create_output_stream(stream_config, callback)?;
+    let stream = device.create_stream(stream_config, callback)?;
 
     println!("Playing sine wave... Press enter to stop.");
     std::io::stdin().read_line(&mut String::new())?;

examples/sine_wave.rs

@@ -9,7 +9,7 @@ fn main() -> Result<()> {
 
     let device = default_output_device();
     println!("Using device {}", device.name());
-    let stream = device.default_output_stream(SineWave::new(440.0)).unwrap();
+    let stream = device.default_stream(DeviceType::OUTPUT, SineWave::new(440.0)).unwrap();
     println!("Press Enter to stop");
     std::io::stdin().read_line(&mut String::new())?;
     stream.eject().unwrap();

examples/util/meter.rs

@@ -42,7 +42,7 @@ impl PeakMeter {
     }
 
     pub fn process_buffer(&mut self, buffer: AudioRef<f32>) -> f32 {
-        let buffer_duration = buffer.num_samples() as f32 * self.dt;
+        let buffer_duration = buffer.num_frames() as f32 * self.dt;
         let peak_lin = buffer
             .channels()
             .flat_map(|ch| ch.iter().copied().max_by(f32::total_cmp))

examples/util/sine.rs

@@ -1,20 +1,29 @@
-use interflow::{AudioCallbackContext, AudioOutput, AudioOutputCallback};
+use interflow::{AudioCallback, AudioCallbackContext, AudioInput, AudioOutput};
 use std::f32::consts::TAU;
 
 pub struct SineWave {
     pub frequency: f32,
     pub phase: f32,
+    step_frequency_scaling: f32,
 }
 
-impl AudioOutputCallback for SineWave {
-    fn on_output_data(&mut self, context: AudioCallbackContext, mut output: AudioOutput<f32>) {
+impl AudioCallback for SineWave {
+    fn prepare(&mut self, context: AudioCallbackContext) {
+        self.step_frequency_scaling = context.stream_config.sample_rate.recip() as f32;
+    }
+    fn process_audio(
+        &mut self,
+        context: AudioCallbackContext,
+        _input: AudioInput<f32>,
+        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));
+        for i in 0..output.buffer.num_frames() {
+            output.buffer.set_mono(i, self.next_sample());
         }
         // Reduce amplitude to not blow up speakers and ears
         output.buffer.change_amplitude(0.125);
@@ -26,11 +35,12 @@ impl SineWave {
         Self {
             frequency,
             phase: 0.0,
+            step_frequency_scaling: 0.0,
         }
     }
 
-    pub fn next_sample(&mut self, samplerate: f32) -> f32 {
-        let step = samplerate.recip() * self.frequency;
+    pub fn next_sample(&mut self) -> f32 {
+        let step = self.step_frequency_scaling * self.frequency;
         let y = (TAU * self.phase).sin();
         self.phase += step;
         if self.phase > 1. {