Fix loading of HRTF-sphere for panner node in onmessage handler

Author: orottier

src/node/panner.rs

@@ -114,10 +114,10 @@ impl Default for PannerOptions {
     }
 }
 
-#[derive(Debug, Copy, Clone)]
 enum ControlMessage {
     DistanceModel(u8),
-    PanningModel(u8),
+    // Box this payload - one large variant can penalize the memory layout of this enum
+    PanningModel(Box<Option<HrtfState>>),
     RefDistance(f64),
     MaxDistance(f64),
     RollOffFactor(f64),
@@ -340,7 +340,7 @@ impl PannerNode {
     /// Can panic when loading HRIR-sphere
     #[allow(clippy::missing_panics_doc)]
     pub fn new<C: BaseAudioContext>(context: &C, options: PannerOptions) -> Self {
-        let node = context.register(move |registration| {
+        let node = context.register(|registration| {
             use crate::spatial::PARAM_OPTS;
 
             let PannerOptions {
@@ -382,12 +382,6 @@ impl PannerNode {
             param_oy.set_value_at_time(orientation_y, 0.);
             param_oz.set_value_at_time(orientation_z, 0.);
 
-            // @note - we just pass the hrtf engine to every created panner node
-            // this might not be the best solution in terms of memory footprint
-            let resource = include_bytes!("../../resources/IRC_1003_C.bin");
-            let sample_rate = context.sample_rate() as u32;
-            let hrir_sphere = HrirSphere::new(&resource[..], sample_rate).unwrap();
-
             let render = PannerRenderer {
                 position_x: render_px,
                 position_y: render_py,
@@ -402,10 +396,7 @@ impl PannerNode {
                 cone_inner_angle,
                 cone_outer_angle,
                 cone_outer_gain,
-                panning_model,
-                // @note - The `Some`is just here as a dirty workaround of borrow
-                // stuff in PannerRenderer::process
-                hrtf_state: Some(HrtfState::new(hrir_sphere)),
+                hrtf_state: None,
                 tail_time_counter: 0,
             };
 
@@ -439,6 +430,9 @@ impl PannerNode {
             .base()
             .connect_listener_to_panner(node.registration().id());
 
+        // load the HRTF sphere if requested
+        node.set_panning_model(options.panning_model);
+
         node
     }
 
@@ -553,11 +547,21 @@ impl PannerNode {
         self.panning_model.load(Ordering::Acquire).into()
     }
 
+    #[allow(clippy::missing_panics_doc)] // loading the provided HRTF will not panic
     pub fn set_panning_model(&self, value: PanningModelType) {
-        let value = value as u8;
-        self.panning_model.store(value, Ordering::Release);
+        let hrtf_option = match value {
+            PanningModelType::EqualPower => None,
+            PanningModelType::HRTF => {
+                let resource = include_bytes!("../../resources/IRC_1003_C.bin");
+                let sample_rate = self.context().sample_rate() as u32;
+                let hrir_sphere = HrirSphere::new(&resource[..], sample_rate).unwrap();
+                Some(HrtfState::new(hrir_sphere))
+            }
+        };
+
+        self.panning_model.store(value as u8, Ordering::Release);
         self.registration
-            .post_message(ControlMessage::PanningModel(value));
+            .post_message(ControlMessage::PanningModel(Box::new(hrtf_option)));
     }
 }
 
@@ -577,17 +581,13 @@ struct PannerRenderer {
     orientation_y: AudioParamId,
     orientation_z: AudioParamId,
     distance_model: DistanceModelType,
-    panning_model: PanningModelType,
     ref_distance: f64,
     max_distance: f64,
     rolloff_factor: f64,
     cone_inner_angle: f64,
     cone_outer_angle: f64,
     cone_outer_gain: f64,
-    // hrtf engine to be used if panning model is set to "hrtf"
-    // @note - we keep the Some as a workaround of borrow reasons in process,
-    // this is quite dirty should be improved
-    hrtf_state: Option<HrtfState>,
+    hrtf_state: Option<HrtfState>, // use EqualPower panning model if `None`
     tail_time_counter: usize,
 }
 
@@ -609,20 +609,14 @@ impl AudioProcessor for PannerRenderer {
         // only handle mono for now (todo issue #44)
         output.mix(1, ChannelInterpretation::Speakers);
 
-        // for borrow reasons, take the hrtf_state out of self
-        let mut hrtf_state = self.hrtf_state.take();
-
         // early exit for silence
         if input.is_silent() {
             // HRTF panner has tail time equal to the max length of the impulse response buffers
             // (12 ms)
-            let tail_time = match self.panning_model {
-                PanningModelType::EqualPower => false,
-                PanningModelType::HRTF => {
-                    hrtf_state.as_ref().unwrap().tail_time_samples() > self.tail_time_counter
-                }
+            let tail_time = match &self.hrtf_state {
+                None => false,
+                Some(hrtf_state) => hrtf_state.tail_time_samples() > self.tail_time_counter,
             };
-
             if !tail_time {
                 return false;
             }
@@ -633,6 +627,9 @@ impl AudioProcessor for PannerRenderer {
         // convert mono to identical stereo
         output.mix(2, ChannelInterpretation::Speakers);
 
+        // for borrow reasons, take the hrtf_state out of self
+        let mut hrtf_state = self.hrtf_state.take();
+
         // source parameters (Panner)
         let source_position_x = params.get(&self.position_x);
         let source_position_y = params.get(&self.position_y);
@@ -698,9 +695,7 @@ impl AudioProcessor for PannerRenderer {
                 }
             });
 
-        if self.panning_model == PanningModelType::HRTF {
-            let Some(hrtf_state) = &mut hrtf_state else { unreachable!() };
-
+        if let Some(hrtf_state) = &mut hrtf_state {
             // HRTF panning - always k-rate so take a single value from the a-rate iter
             let SpatialParams {
                 dist_gain,
@@ -800,16 +795,16 @@ impl AudioProcessor for PannerRenderer {
     }
 
     fn onmessage(&mut self, msg: &mut dyn Any) {
-        if let Some(control) = msg.downcast_ref::<ControlMessage>() {
+        if let Some(control) = msg.downcast_mut::<ControlMessage>() {
             match control {
                 ControlMessage::DistanceModel(value) => self.distance_model = (*value).into(),
-                ControlMessage::PanningModel(value) => self.panning_model = (*value).into(),
                 ControlMessage::RefDistance(value) => self.ref_distance = *value,
                 ControlMessage::MaxDistance(value) => self.max_distance = *value,
                 ControlMessage::RollOffFactor(value) => self.rolloff_factor = *value,
                 ControlMessage::ConeInnerAngle(value) => self.cone_inner_angle = *value,
                 ControlMessage::ConeOuterAngle(value) => self.cone_outer_angle = *value,
                 ControlMessage::ConeOuterGain(value) => self.cone_outer_gain = *value,
+                ControlMessage::PanningModel(value) => self.hrtf_state = value.take(),
             }
 
             return;