Prevent the wpt-runner from crashing (only that, no true fixes here)

Author: orottier

src/node/channel_merger.rs

@@ -65,6 +65,7 @@ impl AudioNode for ChannelMergerNode {
 impl ChannelMergerNode {
     pub fn new<C: BaseAudioContext>(context: &C, mut 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;
 
             let node = ChannelMergerNode {

src/node/channel_splitter.rs

@@ -69,6 +69,7 @@ impl AudioNode for ChannelSplitterNode {
 impl ChannelSplitterNode {
     pub fn new<C: BaseAudioContext>(context: &C, mut options: ChannelSplitterOptions) -> Self {
         context.register(move |registration| {
+            crate::assert_valid_number_of_channels(options.number_of_outputs);
             options.channel_config.count = options.number_of_outputs;
 
             let node = ChannelSplitterNode {

src/node/mod.rs

@@ -211,6 +211,8 @@ impl ChannelConfig {
 
 impl From<ChannelConfigOptions> for ChannelConfig {
     fn from(opts: ChannelConfigOptions) -> Self {
+        crate::assert_valid_number_of_channels(opts.count);
+
         let inner = ChannelConfigInner {
             count: AtomicUsize::from(opts.count),
             count_mode: AtomicU32::from(opts.count_mode as u32),

src/node/panner.rs

@@ -23,21 +23,27 @@ use super::{
 pub(crate) fn load_hrtf_processor(sample_rate: u32) -> (HrtfProcessor, usize) {
     static INSTANCE: OnceLock<Mutex<HashMap<u32, (HrtfProcessor, usize)>>> = OnceLock::new();
     let cache = INSTANCE.get_or_init(|| Mutex::new(HashMap::new()));
-    let mut guard = cache.lock().unwrap();
-    guard
-        .entry(sample_rate)
-        .or_insert_with(|| {
-            let resource = include_bytes!("../../resources/IRC_1003_C.bin");
-            let hrir_sphere = HrirSphere::new(&resource[..], sample_rate).unwrap();
-            let len = hrir_sphere.len();
-
-            let interpolation_steps = 1; // TODO?
-            let samples_per_step = RENDER_QUANTUM_SIZE / interpolation_steps;
-            let processor = HrtfProcessor::new(hrir_sphere, interpolation_steps, samples_per_step);
-
-            (processor, len)
-        })
-        .clone()
+
+    // To avoid poisening the cache mutex, don't use the `entry()` API on HashMap
+    {
+        if let Some(value) = cache.lock().unwrap().get(&sample_rate) {
+            return value.clone();
+        }
+    }
+
+    // The following snippet might panic
+    let resource = include_bytes!("../../resources/IRC_1003_C.bin");
+    let hrir_sphere = HrirSphere::new(&resource[..], sample_rate).unwrap();
+    let len = hrir_sphere.len();
+
+    let interpolation_steps = 1; // TODO?
+    let samples_per_step = RENDER_QUANTUM_SIZE / interpolation_steps;
+    let processor = HrtfProcessor::new(hrir_sphere, interpolation_steps, samples_per_step);
+
+    let value = (processor, len);
+    cache.lock().unwrap().insert(sample_rate, value.clone());
+
+    value
 }
 
 /// Spatialization algorithm used to position the audio in 3D space

src/render/quantum.rs

@@ -573,7 +573,8 @@ impl AudioRenderQuantum {
                         .zip(center.iter())
                         .for_each(|(r, c)| *r += sqrt05 * c);
                 }
-
+                _ => (),
+                /*
                 _ => panic!(
                     "{mixing} from {from} to {to} channels not supported",
                     mixing = if self.number_of_channels() < computed_number_of_channels {
@@ -584,6 +585,7 @@ impl AudioRenderQuantum {
                     from = self.number_of_channels(),
                     to = computed_number_of_channels,
                 ),
+                */
             }
         }
     }

tests/online.rs

@@ -107,6 +107,17 @@ fn test_none_sink_id() {
     assert!(sink_stable.load(Ordering::SeqCst));
 }
 
+#[test]
+fn test_weird_sample_rate() {
+    let options = AudioContextOptions {
+        sink_id: "none".into(),
+        sample_rate: Some(24000.),
+        ..AudioContextOptions::default()
+    };
+
+    AudioContext::new(options);
+}
+
 #[test]
 fn test_channels() {
     let options = AudioContextOptions {