MediaDevices: add support for MediaTrackConstraints.channelCount

Fixes #446

TODO: channelCount should be modeled as a ConstrainULong, not just u32.
TODO: cubeb support

Author: orottier

examples/microphone.rs

@@ -72,6 +72,7 @@ fn main() {
 
     let mut constraints = MediaTrackConstraints::default();
     constraints.device_id = source_id;
+    // constraints.channel_count = Some(2);
     let stream_constraints = MediaStreamConstraints::AudioWithConstraints(constraints);
     let mic = media_devices::get_user_media_sync(stream_constraints);
 

src/io/cpal.rs

@@ -266,7 +266,10 @@ impl AudioBackendManager for CpalBackend {
         }
     }
 
-    fn build_input(options: AudioContextOptions) -> (Self, Receiver<AudioBuffer>)
+    fn build_input(
+        options: AudioContextOptions,
+        number_of_channels: Option<u32>,
+    ) -> (Self, Receiver<AudioBuffer>)
     where
         Self: Sized,
     {
@@ -297,6 +300,10 @@ impl AudioBackendManager for CpalBackend {
         // clone the config, we may need to fall back on it later
         let mut preferred: StreamConfig = supported.clone().into();
 
+        if let Some(number_of_channels) = number_of_channels {
+            preferred.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);
@@ -315,32 +322,40 @@ impl AudioBackendManager for CpalBackend {
         };
 
         preferred.buffer_size = cpal::BufferSize::Fixed(clamped_buffer_size);
-
-        let mut number_of_channels = usize::from(preferred.channels);
         let mut sample_rate = preferred.sample_rate.0 as f32;
+        let mut number_of_channels = preferred.channels as usize;
 
         let smoothing = 3; // todo, use buffering to smooth frame drops
         let (sender, mut receiver) = crossbeam_channel::bounded(smoothing);
         let renderer = MicrophoneRender::new(number_of_channels, sample_rate, sender);
 
-        let maybe_stream =
-            spawn_input_stream(&device, supported.sample_format(), &preferred, renderer);
+        log::debug!(
+            "Attempt input stream with preferred config: {:?}",
+            &preferred
+        );
+
+        let spawned = spawn_input_stream(&device, supported.sample_format(), &preferred, renderer);
 
         // the required block size preferred config may not be supported, in that
         // case, fallback the supported config
-        let stream = match maybe_stream {
-            Ok(stream) => stream,
+        let stream = match spawned {
+            Ok(stream) => {
+                log::debug!("Input stream set up successfully");
+                stream
+            }
             Err(e) => {
-                log::warn!(
-                    "Output stream failed to build: {:?}, retry with default config {:?}",
-                    e,
-                    preferred
-                );
+                log::warn!("Output stream build failed with preferred config: {}", e);
 
                 let supported_config: StreamConfig = supported.clone().into();
+                // fallback to device default sample rate and channel count
                 number_of_channels = usize::from(supported_config.channels);
                 sample_rate = supported_config.sample_rate.0 as f32;
 
+                log::debug!(
+                    "Attempt output stream with fallback config: {:?}",
+                    &supported_config
+                );
+
                 // setup a new comms channel
                 let (sender, receiver2) = crossbeam_channel::bounded(smoothing);
                 receiver = receiver2; // overwrite earlier

src/io/cubeb.rs

@@ -269,7 +269,10 @@ impl AudioBackendManager for CubebBackend {
         backend
     }
 
-    fn build_input(options: AudioContextOptions) -> (Self, Receiver<AudioBuffer>)
+    fn build_input(
+        options: AudioContextOptions,
+        _number_of_channels: Option<u32>,
+    ) -> (Self, Receiver<AudioBuffer>)
     where
         Self: Sized,
     {

src/io/mod.rs

@@ -112,7 +112,10 @@ pub(crate) fn build_output(
 }
 
 /// Set up an input stream (microphone) bases on the selected features (cubeb/cpal/none)
-pub(crate) fn build_input(options: AudioContextOptions) -> MediaStream {
+pub(crate) fn build_input(
+    options: AudioContextOptions,
+    number_of_channels: Option<u32>,
+) -> MediaStream {
     #[cfg(all(not(feature = "cubeb"), not(feature = "cpal")))]
     {
         panic!("No audio backend available, enable the 'cpal' or 'cubeb' feature")
@@ -123,12 +126,12 @@ pub(crate) fn build_input(options: AudioContextOptions) -> MediaStream {
         let (backend, receiver) = {
             #[cfg(feature = "cubeb")]
             {
-                cubeb::CubebBackend::build_input(options)
+                cubeb::CubebBackend::build_input(options, number_of_channels)
             }
 
             #[cfg(all(not(feature = "cubeb"), feature = "cpal"))]
             {
-                cpal::CpalBackend::build_input(options)
+                cpal::CpalBackend::build_input(options, number_of_channels)
             }
         };
 
@@ -151,7 +154,10 @@ pub(crate) trait AudioBackendManager: Send + Sync + 'static {
         Self: Sized;
 
     /// Setup a new input stream (microphone capture)
-    fn build_input(options: AudioContextOptions) -> (Self, Receiver<AudioBuffer>)
+    fn build_input(
+        options: AudioContextOptions,
+        number_of_channels: Option<u32>,
+    ) -> (Self, Receiver<AudioBuffer>)
     where
         Self: Sized;
 

src/io/none.rs

@@ -110,7 +110,10 @@ impl AudioBackendManager for NoneBackend {
     }
 
     /// Setup a new input stream (microphone capture)
-    fn build_input(_options: AudioContextOptions) -> (Self, Receiver<AudioBuffer>)
+    fn build_input(
+        _options: AudioContextOptions,
+        _number_of_channels: Option<u32>,
+    ) -> (Self, Receiver<AudioBuffer>)
     where
         Self: Sized,
     {

src/media_devices/mod.rs

@@ -148,7 +148,7 @@ pub struct MediaTrackConstraints {
     // ConstrainBoolean autoGainControl;
     // ConstrainBoolean noiseSuppression;
     pub latency: Option<f64>,
-    //ConstrainULong channelCount;
+    pub channel_count: Option<u32>, // TODO model as ConstrainULong;
     pub device_id: Option<String>,
     // ConstrainDOMString groupId;
 }
@@ -218,15 +218,15 @@ fn is_valid_device_id(device_id: &str) -> bool {
 /// std::thread::sleep(std::time::Duration::from_secs(4));
 /// ```
 pub fn get_user_media_sync(constraints: MediaStreamConstraints) -> MediaStream {
-    let mut options = match constraints {
-        MediaStreamConstraints::Audio => AudioContextOptions::default(),
-        MediaStreamConstraints::AudioWithConstraints(cs) => cs.into(),
+    let (channel_count, mut options) = match constraints {
+        MediaStreamConstraints::Audio => (None, AudioContextOptions::default()),
+        MediaStreamConstraints::AudioWithConstraints(cs) => (cs.channel_count, cs.into()),
     };
 
     if !is_valid_device_id(&options.sink_id) {
         log::error!("NotFoundError: invalid deviceId {:?}", options.sink_id);
         options.sink_id = String::from("");
     }
 
-    crate::io::build_input(options)
+    crate::io::build_input(options, channel_count)
 }