fix: clamped cpal backend output stream to MAX_CHANNELS (32)

Author: b-ma

src/context/online.rs

@@ -9,6 +9,7 @@ use crate::media_devices::{enumerate_devices_sync, MediaDeviceInfoKind};
 use crate::media_streams::{MediaStream, MediaStreamTrack};
 use crate::message::ControlMessage;
 use crate::node::{self, ChannelConfigOptions};
+use crate::render::graph::Graph;
 use crate::MediaElement;
 use crate::{AudioRenderCapacity, Event};
 
@@ -172,8 +173,8 @@ impl AudioContext {
             event_recv,
         } = control_thread_init;
 
-        let graph = crate::render::graph::Graph::new();
-        let message = crate::message::ControlMessage::Startup { graph };
+        let graph = Graph::new();
+        let message = ControlMessage::Startup { graph };
         ctrl_msg_send.send(message).unwrap();
 
         let base = ConcreteBaseAudioContext::new(

src/io/cpal.rs

@@ -16,7 +16,7 @@ use crate::context::AudioContextOptions;
 use crate::io::microphone::MicrophoneRender;
 use crate::media_devices::{MediaDeviceInfo, MediaDeviceInfoKind};
 use crate::render::RenderThread;
-use crate::AtomicF64;
+use crate::{AtomicF64, MAX_CHANNELS};
 
 use crossbeam_channel::Receiver;
 
@@ -142,38 +142,50 @@ impl AudioBackendManager for CpalBackend {
 
         log::info!("Output device: {:?}", device.name());
 
-        let supported = device
+        let default_device_config = device
             .default_output_config()
             .expect("error while querying config");
 
-        let mut preferred: StreamConfig = supported.clone().into();
+        // we grab the largest number of channels provided by the soundcard
+        // clamped to MAX_CHANNELS, this value cannot be changed by the user
+        let number_of_channels = usize::from(default_device_config.channels()).min(MAX_CHANNELS);
+
+        // override default device configuration with the options provided by
+        // the user when creating the `AudioContext`
+        let mut preferred_config: StreamConfig = default_device_config.clone().into();
+        // make sure the number of channels is clamped to MAX_CHANNELS
+        preferred_config.channels = number_of_channels as u16;
 
         // set specific sample rate if requested
         if let Some(sample_rate) = options.sample_rate {
             crate::assert_valid_sample_rate(sample_rate);
-            preferred.sample_rate.0 = sample_rate as u32;
+            preferred_config.sample_rate.0 = sample_rate as u32;
         }
 
         // always try to set a decent buffer size
         let buffer_size = super::buffer_size_for_latency_category(
             options.latency_hint,
-            preferred.sample_rate.0 as f32,
+            preferred_config.sample_rate.0 as f32,
         ) as u32;
 
-        let clamped_buffer_size: u32 = match supported.buffer_size() {
+        let clamped_buffer_size: u32 = match default_device_config.buffer_size() {
             SupportedBufferSize::Unknown => buffer_size,
             SupportedBufferSize::Range { min, max } => buffer_size.clamp(*min, *max),
         };
 
-        preferred.buffer_size = cpal::BufferSize::Fixed(clamped_buffer_size);
+        preferred_config.buffer_size = cpal::BufferSize::Fixed(clamped_buffer_size);
+
+        // report the picked sample rate to the render thread, i.e. if the requested
+        // sample rate is not supported by the hardware, it will fallback to the
+        // default device sample rate
+        let mut sample_rate = preferred_config.sample_rate.0 as f32;
 
+        // shared atomic to report output latency to the control thread
         let output_latency = Arc::new(AtomicF64::new(0.));
-        let mut number_of_channels = usize::from(preferred.channels);
-        let mut sample_rate = preferred.sample_rate.0 as f32;
 
         let renderer = RenderThread::new(
             sample_rate,
-            preferred.channels as usize,
+            preferred_config.channels as usize,
             ctrl_msg_recv.clone(),
             Arc::clone(&frames_played),
             Some(load_value_send.clone()),
@@ -182,12 +194,13 @@ impl AudioBackendManager for CpalBackend {
 
         log::debug!(
             "Attempt output stream with preferred config: {:?}",
-            &preferred
+            &preferred_config
         );
+
         let spawned = spawn_output_stream(
             &device,
-            supported.sample_format(),
-            &preferred,
+            default_device_config.sample_format(),
+            &preferred_config,
             renderer,
             Arc::clone(&output_latency),
         );
@@ -200,8 +213,10 @@ impl AudioBackendManager for CpalBackend {
             Err(e) => {
                 log::warn!("Output stream build failed with preferred config: {}", e);
 
-                let supported_config: StreamConfig = supported.clone().into();
-                number_of_channels = usize::from(supported_config.channels);
+                let mut supported_config: StreamConfig = default_device_config.clone().into();
+                // make sure number of channels is clamped to MAX_CHANNELS
+                supported_config.channels = number_of_channels as u16;
+                // fallback to device default sample rate
                 sample_rate = supported_config.sample_rate.0 as f32;
 
                 log::debug!(
@@ -220,11 +235,12 @@ impl AudioBackendManager for CpalBackend {
 
                 let spawned = spawn_output_stream(
                     &device,
-                    supported.sample_format(),
+                    default_device_config.sample_format(),
                     &supported_config,
                     renderer,
                     Arc::clone(&output_latency),
                 );
+
                 spawned.expect("OutputStream build failed with default config")
             }
         };

src/render/thread.rs

@@ -23,6 +23,8 @@ use super::graph::Graph;
 pub(crate) struct RenderThread {
     graph: Option<Graph>,
     sample_rate: f32,
+    /// number of channels of the backend stream, i.e. sound card number of
+    /// channels clamped to MAX_CHANNELS
     number_of_channels: usize,
     frames_played: Arc<AtomicU64>,
     receiver: Option<Receiver<ControlMessage>>,
@@ -176,12 +178,12 @@ impl RenderThread {
         buffer
     }
 
-    pub fn render<S: FromSample<f32> + Clone>(&mut self, buffer: &mut [S]) {
+    pub fn render<S: FromSample<f32> + Clone>(&mut self, output_buffer: &mut [S]) {
         // collect timing information
         let render_start = Instant::now();
 
         // perform actual rendering
-        self.render_inner(buffer);
+        self.render_inner(output_buffer);
 
         // calculate load value and ship to control thread
         if let Some(load_value_sender) = &self.load_value_sender {
@@ -198,13 +200,13 @@ impl RenderThread {
         }
     }
 
-    fn render_inner<S: FromSample<f32> + Clone>(&mut self, mut buffer: &mut [S]) {
+    fn render_inner<S: FromSample<f32> + Clone>(&mut self, mut output_buffer: &mut [S]) {
         // There may be audio frames left over from the previous render call,
         // if the cpal buffer size did not align with our internal RENDER_QUANTUM_SIZE
         if let Some((offset, prev_rendered)) = self.buffer_offset.take() {
             let leftover_len = (RENDER_QUANTUM_SIZE - offset) * self.number_of_channels;
             // split the leftover frames slice, to fit in `buffer`
-            let (first, next) = buffer.split_at_mut(leftover_len.min(buffer.len()));
+            let (first, next) = output_buffer.split_at_mut(leftover_len.min(output_buffer.len()));
 
             // copy rendered audio into output slice
             for i in 0..self.number_of_channels {
@@ -226,23 +228,23 @@ impl RenderThread {
             }
 
             // if there's still space left in the buffer, continue rendering
-            buffer = next;
+            output_buffer = next;
         }
 
         // handle addition/removal of nodes/edges
         self.handle_control_messages();
 
         // if the thread is still booting, or shutting down, fill with silence
         if self.graph.is_none() {
-            buffer.fill(S::from_sample_(0.));
+            output_buffer.fill(S::from_sample_(0.));
             return;
         }
 
         // The audio graph is rendered in chunks of RENDER_QUANTUM_SIZE frames.  But some audio backends
         // may not be able to emit chunks of this size.
         let chunk_size = RENDER_QUANTUM_SIZE * self.number_of_channels;
 
-        for data in buffer.chunks_mut(chunk_size) {
+        for data in output_buffer.chunks_mut(chunk_size) {
             // update time
             let current_frame = self
                 .frames_played
@@ -258,17 +260,19 @@ impl RenderThread {
             };
 
             // render audio graph, clone it in case we need to mutate/store the value later
-            let mut rendered = self.graph.as_mut().unwrap().render(&scope).clone();
+            let mut destination_buffer = self.graph.as_mut().unwrap().render(&scope).clone();
 
-            // online AudioContext allows channel count to be less than no of hardware channels
-            if rendered.number_of_channels() != self.number_of_channels {
-                rendered.mix(self.number_of_channels, ChannelInterpretation::Discrete);
+            // online AudioContext allows channel count to be less than the number
+            // of channels of the backend stream, i.e. number of channels of the
+            // soundcard clamped to MAX_CHANNELS.
+            if destination_buffer.number_of_channels() < self.number_of_channels {
+                destination_buffer.mix(self.number_of_channels, ChannelInterpretation::Discrete);
             }
 
             // copy rendered audio into output slice
             for i in 0..self.number_of_channels {
                 let output = data.iter_mut().skip(i).step_by(self.number_of_channels);
-                let channel = rendered.channel_data(i).iter();
+                let channel = destination_buffer.channel_data(i).iter();
                 for (sample, input) in output.zip(channel) {
                     let value = S::from_sample_(*input);
                     *sample = value;
@@ -279,7 +283,7 @@ impl RenderThread {
                 // this is the last chunk, and it contained less than RENDER_QUANTUM_SIZE samples
                 let channel_offset = data.len() / self.number_of_channels;
                 debug_assert!(channel_offset < RENDER_QUANTUM_SIZE);
-                self.buffer_offset = Some((channel_offset, rendered));
+                self.buffer_offset = Some((channel_offset, destination_buffer));
             }
 
             // handle addition/removal of nodes/edges