Merge pull request #440 from orottier/feature/assertions-in-nodes

Fix in ChannelMergerNode channel config & run assertions in constructor of nodes

Author: orottier

src/node/channel_merger.rs

@@ -7,6 +7,38 @@ use super::{
     AudioNode, ChannelConfig, ChannelConfigOptions, ChannelCountMode, ChannelInterpretation,
 };
 
+/// Assert that the channel count is valid for the ChannelMergerNode
+/// see <https://webaudio.github.io/web-audio-api/#audionode-channelcount-constraints>
+///
+/// # Panics
+///
+/// This function panics if given count is greater than 2
+///
+#[track_caller]
+#[inline(always)]
+fn assert_valid_channel_count(count: usize) {
+    assert!(
+        count == 1,
+        "InvalidStateError - channel count of ChannelMergerNode must be equal to 1"
+    );
+}
+
+/// Assert that the channel count mode is valid for the ChannelMergerNode
+/// see <https://webaudio.github.io/web-audio-api/#audionode-channelcountmode-constraints>
+///
+/// # Panics
+///
+/// This function panics if the mode is not equal to Explicit
+///
+#[track_caller]
+#[inline(always)]
+fn assert_valid_channel_count_mode(mode: ChannelCountMode) {
+    assert!(
+        mode == ChannelCountMode::Explicit,
+        "InvalidStateError - channel count of ChannelMergerNode must be set to Explicit"
+    );
+}
+
 /// Options for constructing a [`ChannelMergerNode`]
 // dictionary ChannelMergerOptions : AudioNodeOptions {
 //   unsigned long numberOfInputs = 6;
@@ -34,6 +66,7 @@ impl Default for ChannelMergerOptions {
 pub struct ChannelMergerNode {
     registration: AudioContextRegistration,
     channel_config: ChannelConfig,
+    number_of_inputs: usize,
 }
 
 impl AudioNode for ChannelMergerNode {
@@ -45,16 +78,18 @@ impl AudioNode for ChannelMergerNode {
         &self.channel_config
     }
 
-    fn set_channel_count(&self, _v: usize) {
-        panic!("InvalidStateError - Cannot edit channel count of ChannelMergerNode")
+    fn set_channel_count(&self, count: usize) {
+        assert_valid_channel_count(count);
+        self.channel_config.set_count(count);
     }
 
-    fn set_channel_count_mode(&self, _v: ChannelCountMode) {
-        panic!("InvalidStateError - Cannot edit channel count mode of ChannelMergerNode")
+    fn set_channel_count_mode(&self, mode: ChannelCountMode) {
+        assert_valid_channel_count_mode(mode);
+        self.channel_config.set_count_mode(mode);
     }
 
     fn number_of_inputs(&self) -> usize {
-        self.channel_count()
+        self.number_of_inputs
     }
 
     fn number_of_outputs(&self) -> usize {
@@ -63,14 +98,17 @@ impl AudioNode for ChannelMergerNode {
 }
 
 impl ChannelMergerNode {
-    pub fn new<C: BaseAudioContext>(context: &C, mut options: ChannelMergerOptions) -> Self {
+    pub fn new<C: BaseAudioContext>(context: &C, options: ChannelMergerOptions) -> Self {
         context.register(move |registration| {
             crate::assert_valid_number_of_channels(options.number_of_inputs);
-            options.channel_config.count = options.number_of_inputs;
+
+            assert_valid_channel_count(options.channel_config.count);
+            assert_valid_channel_count_mode(options.channel_config.count_mode);
 
             let node = ChannelMergerNode {
                 registration,
                 channel_config: options.channel_config.into(),
+                number_of_inputs: options.number_of_inputs,
             };
 
             let render = ChannelMergerRenderer {};
@@ -111,3 +149,78 @@ impl AudioProcessor for ChannelMergerRenderer {
         false
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::context::{BaseAudioContext, OfflineAudioContext};
+    use crate::node::{AudioNode, AudioScheduledSourceNode};
+
+    use float_eq::assert_float_eq;
+
+    #[test]
+    fn test_merge() {
+        let sample_rate = 48000.;
+        let mut context = OfflineAudioContext::new(2, 128, sample_rate);
+
+        let merger = context.create_channel_merger(2);
+        merger.connect(&context.destination());
+
+        let mut src1 = context.create_constant_source();
+        src1.offset().set_value(2.);
+        src1.connect_at(&merger, 0, 0);
+        src1.start();
+
+        let mut src2 = context.create_constant_source();
+        src2.offset().set_value(3.);
+        src2.connect_at(&merger, 0, 1);
+        src2.start();
+
+        let buffer = context.start_rendering_sync();
+
+        let left = buffer.get_channel_data(0);
+        assert_float_eq!(left, &[2.; 128][..], abs_all <= 0.);
+
+        let right = buffer.get_channel_data(1);
+        assert_float_eq!(right, &[3.; 128][..], abs_all <= 0.);
+    }
+
+    #[test]
+    fn test_merge_disconnect() {
+        let sample_rate = 48000.;
+        let length = 4 * 128;
+        let disconnect_at = length as f64 / sample_rate as f64 / 2.;
+        let mut context = OfflineAudioContext::new(2, length, sample_rate);
+
+        let merger = context.create_channel_merger(2);
+        merger.connect(&context.destination());
+
+        let mut src1 = context.create_constant_source();
+        src1.offset().set_value(2.);
+        src1.connect_at(&merger, 0, 0);
+        src1.start();
+
+        let mut src2 = context.create_constant_source();
+        src2.offset().set_value(3.);
+        src2.connect_at(&merger, 0, 1);
+        src2.start();
+
+        context.suspend_sync(disconnect_at, move |_| src2.disconnect());
+
+        let buffer = context.start_rendering_sync();
+
+        let left = buffer.get_channel_data(0);
+        assert_float_eq!(left, &vec![2.; length][..], abs_all <= 0.);
+
+        let right = buffer.get_channel_data(1);
+        assert_float_eq!(
+            &right[0..length / 2],
+            &vec![3.; length / 2][..],
+            abs_all <= 0.
+        );
+        assert_float_eq!(
+            &right[length / 2..],
+            &vec![0.; length / 2][..],
+            abs_all <= 0.
+        );
+    }
+}

src/node/channel_splitter.rs

@@ -7,6 +7,38 @@ use super::{
     AudioNode, ChannelConfig, ChannelConfigOptions, ChannelCountMode, ChannelInterpretation,
 };
 
+/// Assert that the channel count mode is valid for the ChannelSplitterNode
+/// see <https://webaudio.github.io/web-audio-api/#audionode-channelcountmode-constraints>
+///
+/// # Panics
+///
+/// This function panics if the mode is not equal to Explicit
+///
+#[track_caller]
+#[inline(always)]
+fn assert_valid_channel_count_mode(mode: ChannelCountMode) {
+    assert!(
+        mode == ChannelCountMode::Explicit,
+        "InvalidStateError - channel count of ChannelSplitterNode must be set to Explicit"
+    );
+}
+
+/// Assert that the channel interpretation is valid for the ChannelSplitterNode
+/// see <https://webaudio.github.io/web-audio-api/#audionode-channelinterpretation-constraints>
+///
+/// # Panics
+///
+/// This function panics if the mode is not equal to Explicit
+///
+#[track_caller]
+#[inline(always)]
+fn assert_valid_channel_interpretation(interpretation: ChannelInterpretation) {
+    assert!(
+        interpretation == ChannelInterpretation::Discrete,
+        "InvalidStateError - channel interpretation of ChannelSplitterNode must be set to Discrete"
+    );
+}
+
 /// Options for constructing a [`ChannelSplitterNode`]
 // dictionary ChannelSplitterOptions : AudioNodeOptions {
 //   unsigned long numberOfOutputs = 6;
@@ -45,16 +77,22 @@ impl AudioNode for ChannelSplitterNode {
         &self.channel_config
     }
 
-    fn set_channel_count(&self, _v: usize) {
-        panic!("InvalidStateError - Cannot edit channel count of ChannelSplitterNode")
+    fn set_channel_count(&self, count: usize) {
+        assert_eq!(
+            count,
+            self.channel_count(),
+            "InvalidStateError - Cannot edit channel count of ChannelSplitterNode"
+        );
     }
 
-    fn set_channel_count_mode(&self, _v: ChannelCountMode) {
-        panic!("InvalidStateError - Cannot edit channel count mode of ChannelSplitterNode")
+    fn set_channel_count_mode(&self, mode: ChannelCountMode) {
+        assert_valid_channel_count_mode(mode);
+        self.channel_config.set_count_mode(mode);
     }
 
-    fn set_channel_interpretation(&self, _v: ChannelInterpretation) {
-        panic!("InvalidStateError - Cannot edit channel interpretation of ChannelSplitterNode")
+    fn set_channel_interpretation(&self, interpretation: ChannelInterpretation) {
+        assert_valid_channel_interpretation(interpretation);
+        self.channel_config.set_interpretation(interpretation);
     }
 
     fn number_of_inputs(&self) -> usize {
@@ -72,6 +110,9 @@ impl ChannelSplitterNode {
             crate::assert_valid_number_of_channels(options.number_of_outputs);
             options.channel_config.count = options.number_of_outputs;
 
+            assert_valid_channel_count_mode(options.channel_config.count_mode);
+            assert_valid_channel_interpretation(options.channel_config.interpretation);
+
             let node = ChannelSplitterNode {
                 registration,
                 channel_config: options.channel_config.into(),
@@ -119,3 +160,35 @@ impl AudioProcessor for ChannelSplitterRenderer {
         false
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::context::{BaseAudioContext, OfflineAudioContext};
+    use crate::node::{AudioNode, AudioScheduledSourceNode};
+    use crate::AudioBuffer;
+
+    use float_eq::assert_float_eq;
+
+    #[test]
+    fn test_splitter() {
+        let sample_rate = 48000.;
+        let mut context = OfflineAudioContext::new(1, 128, sample_rate);
+
+        let splitter = context.create_channel_splitter(2);
+        // connect the 2nd output to the destination
+        splitter.connect_at(&context.destination(), 1, 0);
+
+        // create buffer with sample value 1. left, value -1. right
+        let audio_buffer = AudioBuffer::from(vec![vec![1.], vec![-1.]], 48000.);
+        let mut src = context.create_buffer_source();
+        src.set_buffer(audio_buffer);
+        src.set_loop(true);
+        src.start();
+        src.connect(&splitter);
+
+        let buffer = context.start_rendering_sync();
+
+        let mono = buffer.get_channel_data(0);
+        assert_float_eq!(mono, &[-1.; 128][..], abs_all <= 0.);
+    }
+}

src/node/destination.rs

@@ -66,14 +66,16 @@ impl AudioNode for AudioDestinationNode {
         self.channel_config.set_count(v);
     }
 
-    fn set_channel_count_mode(&self, _v: ChannelCountMode) {
+    fn set_channel_count_mode(&self, v: ChannelCountMode) {
         // [spec] If the AudioDestinationNode is the destination node of an
         // OfflineAudioContext, then the channel count mode cannot be changed.
         // An InvalidStateError exception MUST be thrown for any attempt to change the value.
         assert!(
             !self.registration.context().offline(),
             "InvalidStateError - AudioDestinationNode has channel count mode constraints",
         );
+
+        self.channel_config.set_count_mode(v);
     }
 }
 

src/node/panner.rs

@@ -15,6 +15,22 @@ use super::{
     AudioNode, ChannelConfig, ChannelConfigOptions, ChannelCountMode, ChannelInterpretation,
 };
 
+/// Assert that the given value number is a valid value for coneOuterGain
+///
+/// # Panics
+///
+/// This function will panic if:
+/// - the given value is not finite and lower than zero
+#[track_caller]
+#[inline(always)]
+#[allow(clippy::manual_range_contains)]
+pub(crate) fn assert_valid_cone_outer_gain(value: f64) {
+    assert!(
+        value >= 0. && value <= 1.,
+        "InvalidStateError - coneOuterGain must be in the range [0, 1]"
+    );
+}
+
 /// Load the HRTF processor for the given sample_rate
 ///
 /// The included data contains the impulse responses at 44100 Hertz, so it needs to be resampled
@@ -393,6 +409,22 @@ impl PannerNode {
                 panning_model,
             } = options;
 
+            assert!(
+                ref_distance >= 0.,
+                "RangeError - refDistance cannot be negative"
+            );
+            assert!(
+                max_distance > 0.,
+                "RangeError - maxDistance must be positive"
+            );
+            assert!(
+                rolloff_factor >= 0.,
+                "RangeError - rolloffFactor cannot be negative"
+            );
+            assert_valid_cone_outer_gain(cone_outer_gain);
+            assert_valid_channel_count(channel_config.count);
+            assert_valid_channel_count_mode(channel_config.count_mode);
+
             // position params
             let (param_px, render_px) = context.create_audio_param(PARAM_OPTS, &registration);
             let (param_py, render_py) = context.create_audio_param(PARAM_OPTS, &registration);
@@ -540,7 +572,7 @@ impl PannerNode {
     ///
     /// Panics if the provided value is negative.
     pub fn set_max_distance(&mut self, value: f64) {
-        assert!(value >= 0., "RangeError - maxDistance cannot be negative");
+        assert!(value > 0., "RangeError - maxDistance must be positive");
         self.max_distance = value;
         self.registration
             .post_message(ControlMessage::MaxDistance(value));
@@ -591,12 +623,8 @@ impl PannerNode {
     /// # Panics
     ///
     /// Panics if the provided value is not in the range [0, 1]
-    #[allow(clippy::manual_range_contains)]
     pub fn set_cone_outer_gain(&mut self, value: f64) {
-        assert!(
-            value >= 0. && value <= 1.,
-            "InvalidStateError - coneOuterGain must be in the range [0, 1]"
-        );
+        assert_valid_cone_outer_gain(value);
         self.cone_outer_gain = value;
         self.registration
             .post_message(ControlMessage::ConeOuterGain(value));