feat: duplex support PR feedback updates.

Author: gulbrand

README.md

@@ -30,7 +30,7 @@ This library currently supports the following:
 - Enumerate known supported input and output stream formats for a device.
 - Get the current default input and output stream formats for a device.
 - Build and run input and output PCM streams on a chosen device with a given stream format.
-- Build and run duplex (simultaneous input/output) streams with hardware clock synchronization (macOS only, more platforms coming soon).
+- Build and run duplex (simultaneous input/output) streams with hardware clock synchronization.
 
 Currently, supported platforms include:
 

examples/duplex_feedback.rs

@@ -11,7 +11,7 @@ mod imp {
     use clap::Parser;
     use cpal::duplex::DuplexStreamConfig;
     use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
-    use cpal::BufferSize;
+    use cpal::{BufferSize, ChannelCount, FrameCount, Sample, SampleRate};
 
     #[derive(Parser, Debug)]
     #[command(version, about = "CPAL duplex feedback example", long_about = None)]
@@ -22,33 +22,35 @@ mod imp {
 
         /// Number of input channels
         #[arg(long, value_name = "CHANNELS", default_value_t = 2)]
-        input_channels: u16,
+        input_channels: ChannelCount,
 
         /// Number of output channels
         #[arg(long, value_name = "CHANNELS", default_value_t = 2)]
-        output_channels: u16,
+        output_channels: ChannelCount,
 
         /// Sample rate in Hz
         #[arg(short, long, value_name = "RATE", default_value_t = 48000)]
-        sample_rate: u32,
+        sample_rate: SampleRate,
 
-        /// Buffer size in frames
-        #[arg(short, long, value_name = "FRAMES", default_value_t = 512)]
-        buffer_size: u32,
+        /// Buffer size in frames (omit for device default)
+        #[arg(short, long, value_name = "FRAMES")]
+        buffer_size: Option<FrameCount>,
     }
 
     pub fn run() -> anyhow::Result<()> {
         let opt = Opt::parse();
         let host = cpal::default_host();
 
         // Find the device by device ID or use default
-        let device = if let Some(device_id_str) = opt.device {
-            let device_id = device_id_str.parse().expect("failed to parse device id");
-            host.device_by_id(&device_id)
-                .unwrap_or_else(|| panic!("failed to find device with id: {}", device_id_str))
-        } else {
-            host.default_output_device()
-                .expect("no default output device")
+        let device = match opt.device {
+            Some(device_id_str) => {
+                let device_id = device_id_str.parse().expect("failed to parse device id");
+                host.device_by_id(&device_id)
+                    .expect(&format!("failed to find device with id: {}", device_id_str))
+            }
+            None => host
+                .default_output_device()
+                .expect("no default output device"),
         };
 
         println!("Using device: \"{}\"", device.description()?.name());
@@ -58,15 +60,18 @@ mod imp {
             input_channels: opt.input_channels,
             output_channels: opt.output_channels,
             sample_rate: opt.sample_rate,
-            buffer_size: BufferSize::Fixed(opt.buffer_size),
+            buffer_size: opt
+                .buffer_size
+                .map(|s| BufferSize::Fixed(s))
+                .unwrap_or(BufferSize::Default),
         };
 
         println!("Building duplex stream with config: {config:?}");
 
         let stream = device.build_duplex_stream::<f32, _, _>(
             &config,
             move |input, output, _info| {
-                output.fill(0.0);
+                output.fill(Sample::EQUILIBRIUM);
                 let copy_len = input.len().min(output.len());
                 output[..copy_len].copy_from_slice(&input[..copy_len]);
             },
@@ -76,7 +81,7 @@ mod imp {
 
         println!("Successfully built duplex stream.");
         println!(
-            "Input: {} channels, Output: {} channels, Sample rate: {} Hz, Buffer size: {} frames",
+            "Input: {} channels, Output: {} channels, Sample rate: {} Hz, Buffer size: {:?} frames",
             opt.input_channels, opt.output_channels, opt.sample_rate, opt.buffer_size
         );
 
@@ -86,7 +91,6 @@ mod imp {
         println!("Playing for 10 seconds... (speak into your microphone)");
         std::thread::sleep(std::time::Duration::from_secs(10));
 
-        drop(stream);
         println!("Done!");
         Ok(())
     }
@@ -98,7 +102,6 @@ fn main() {
 
     #[cfg(not(target_os = "macos"))]
     {
-        eprintln!("Duplex streams are currently only supported on macOS.");
-        eprintln!("Windows (WASAPI) and Linux (ALSA) support is planned.");
+        eprintln!("Duplex streams are not supported on this platform.");
     }
 }

src/duplex.rs

@@ -3,20 +3,9 @@
 //! This module provides types for building duplex (simultaneous input/output) audio streams
 //! with hardware clock synchronization.
 //!
-//! # Overview
-//!
-//! Unlike separate input and output streams which may have independent clocks, a duplex stream
-//! uses a single device context for both input and output, ensuring they share the same
-//! hardware clock. This is essential for applications like:
-//!
-//! - DAWs (Digital Audio Workstations)
-//! - Real-time audio effects processing
-//! - Audio measurement and analysis
-//! - Any application requiring sample-accurate I/O synchronization
-//!
 //! See `examples/duplex_feedback.rs` for a working example.
 
-use crate::{InputStreamTimestamp, OutputStreamTimestamp, SampleRate};
+use crate::{ChannelCount, InputStreamTimestamp, OutputStreamTimestamp, SampleRate};
 
 /// Information passed to duplex callbacks.
 ///
@@ -66,10 +55,10 @@ impl DuplexCallbackInfo {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DuplexStreamConfig {
     /// Number of input channels.
-    pub input_channels: u16,
+    pub input_channels: ChannelCount,
 
     /// Number of output channels.
-    pub output_channels: u16,
+    pub output_channels: ChannelCount,
 
     /// Sample rate in Hz.
     pub sample_rate: SampleRate,