Merge pull request #332 from uklotzde/onmessage-mut

AudioProcessor::onmessage(): Pass message as mutable reference

Author: orottier

examples/worklet.rs

@@ -1,3 +1,5 @@
+use std::any::Any;
+
 use rand::Rng;
 
 use web_audio_api::context::{
@@ -141,15 +143,12 @@ impl AudioProcessor for WhiteNoiseProcessor {
         true // source node will always be active
     }
 
-    fn onmessage(&mut self, msg: Box<dyn std::any::Any + Send + 'static>) {
+    fn onmessage(&mut self, msg: &mut dyn Any) {
         // handle incoming signals requesting for change of color
-        let msg = match msg.downcast::<NoiseColor>() {
-            Ok(color) => {
-                self.color = *color;
-                return;
-            }
-            Err(msg) => msg,
-        };
+        if let Some(color) = msg.downcast_ref::<NoiseColor>() {
+            self.color = *color;
+            return;
+        }
 
         // ...add more message handlers here...
 

src/buffer.rs

@@ -66,8 +66,8 @@ pub struct AudioBufferOptions {
 ///
 #[derive(Clone, Debug)]
 pub struct AudioBuffer {
-    channels: Vec<ChannelData>,
-    sample_rate: f32,
+    pub(crate) channels: Vec<ChannelData>,
+    pub(crate) sample_rate: f32,
 }
 
 impl AudioBuffer {

src/context/mod.rs

@@ -1,5 +1,5 @@
 //! The `BaseAudioContext` interface and the `AudioContext` and `OfflineAudioContext` types
-use std::ops::Range;
+use std::{any::Any, ops::Range};
 
 mod base;
 pub use base::*;
@@ -105,7 +105,7 @@ impl AudioContextRegistration {
     ///
     /// The message will be handled by
     /// [`AudioProcessor::onmessage`](crate::render::AudioProcessor::onmessage).
-    pub fn post_message<M: std::any::Any + Send + 'static>(&self, msg: M) {
+    pub fn post_message<M: Any + Send + 'static>(&self, msg: M) {
         let wrapped = crate::message::ControlMessage::NodeMessage {
             id: self.id,
             msg: Box::new(msg),

src/message.rs

@@ -1,5 +1,7 @@
 //! Message passing from control to render node
 
+use std::any::Any;
+
 use crate::context::AudioNodeId;
 use crate::node::ChannelConfig;
 use crate::render::graph::Graph;
@@ -47,6 +49,6 @@ pub(crate) enum ControlMessage {
     /// Generic message to be handled by AudioProcessor
     NodeMessage {
         id: AudioNodeId,
-        msg: Box<dyn std::any::Any + Send + 'static>,
+        msg: Box<dyn Any + Send + 'static>,
     },
 }

src/node/audio_buffer_source.rs

@@ -1,3 +1,4 @@
+use std::any::Any;
 use std::cell::OnceCell;
 use std::sync::atomic::{AtomicBool, Ordering};
 
@@ -769,21 +770,25 @@ impl AudioProcessor for AudioBufferSourceRenderer {
         true
     }
 
-    fn onmessage(&mut self, msg: Box<dyn std::any::Any + Send + 'static>) {
-        let msg = match msg.downcast::<ControlMessage>() {
-            Ok(control) => {
-                self.handle_control_message(*control);
-                return;
-            }
-            Err(msg) => msg,
+    fn onmessage(&mut self, msg: &mut dyn Any) {
+        if let Some(control) = msg.downcast_ref::<ControlMessage>() {
+            self.handle_control_message(*control);
+            return;
         };
 
-        let msg = match msg.downcast::<AudioBuffer>() {
-            Ok(buffer) => {
-                self.buffer = Some(*buffer);
-                return;
+        if let Some(buffer) = msg.downcast_mut::<AudioBuffer>() {
+            if let Some(current_buffer) = &mut self.buffer {
+                // Avoid deallocation in the render thread by swapping the buffers.
+                std::mem::swap(current_buffer, buffer);
+            } else {
+                // Creating the tombstone buffer does not cause allocations.
+                let tombstone_buffer = AudioBuffer {
+                    channels: Default::default(),
+                    sample_rate: Default::default(),
+                };
+                self.buffer = Some(std::mem::replace(buffer, tombstone_buffer));
             }
-            Err(msg) => msg,
+            return;
         };
 
         log::warn!("AudioBufferSourceRenderer: Dropping incoming message {msg:?}");

src/node/constant_source.rs

@@ -1,3 +1,5 @@
+use std::any::Any;
+
 use crate::context::{AudioContextRegistration, AudioParamId, BaseAudioContext};
 use crate::param::{AudioParam, AudioParamDescriptor, AutomationRate};
 use crate::render::{AudioParamValues, AudioProcessor, AudioRenderQuantum, RenderScope};
@@ -202,17 +204,14 @@ impl AudioProcessor for ConstantSourceRenderer {
         still_running
     }
 
-    fn onmessage(&mut self, msg: Box<dyn std::any::Any + Send + 'static>) {
-        let msg = match msg.downcast::<Schedule>() {
-            Ok(schedule) => {
-                match *schedule {
-                    Schedule::Start(v) => self.start_time = v,
-                    Schedule::Stop(v) => self.stop_time = v,
-                }
-                return;
+    fn onmessage(&mut self, msg: &mut dyn Any) {
+        if let Some(schedule) = msg.downcast_ref::<Schedule>() {
+            match *schedule {
+                Schedule::Start(v) => self.start_time = v,
+                Schedule::Stop(v) => self.stop_time = v,
             }
-            Err(msg) => msg,
-        };
+            return;
+        }
 
         log::warn!("ConstantSourceRenderer: Dropping incoming message {msg:?}");
     }

src/node/oscillator.rs

@@ -1,11 +1,12 @@
+use std::any::Any;
 use std::fmt::Debug;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Arc;
 
 use crate::context::{AudioContextRegistration, AudioParamId, BaseAudioContext};
 use crate::param::{AudioParam, AudioParamDescriptor, AutomationRate};
-use crate::periodic_wave::PeriodicWave;
 use crate::render::{AudioParamValues, AudioProcessor, AudioRenderQuantum, RenderScope};
+use crate::PeriodicWave;
 use crate::RENDER_QUANTUM_SIZE;
 
 use super::{
@@ -431,35 +432,32 @@ impl AudioProcessor for OscillatorRenderer {
         true
     }
 
-    fn onmessage(&mut self, msg: Box<dyn std::any::Any + Send + 'static>) {
-        let msg = match msg.downcast::<OscillatorType>() {
-            Ok(type_) => {
-                self.shared_type.store(*type_ as u32, Ordering::Release);
-                self.type_ = *type_;
-                return;
-            }
-            Err(msg) => msg,
-        };
+    fn onmessage(&mut self, msg: &mut dyn Any) {
+        if let Some(&type_) = msg.downcast_ref::<OscillatorType>() {
+            self.shared_type.store(type_ as u32, Ordering::Release);
+            self.type_ = type_;
+            return;
+        }
 
-        let msg = match msg.downcast::<Schedule>() {
-            Ok(schedule) => {
-                match *schedule {
-                    Schedule::Start(v) => self.start_time = v,
-                    Schedule::Stop(v) => self.stop_time = v,
-                }
-                return;
+        if let Some(&schedule) = msg.downcast_ref::<Schedule>() {
+            match schedule {
+                Schedule::Start(v) => self.start_time = v,
+                Schedule::Stop(v) => self.stop_time = v,
             }
-            Err(msg) => msg,
-        };
+            return;
+        }
 
-        let msg = match msg.downcast::<PeriodicWave>() {
-            Ok(periodic_wave) => {
-                self.periodic_wave = Some(*periodic_wave);
-                self.type_ = OscillatorType::Custom; // shared type is already updated by control
-                return;
+        if let Some(periodic_wave) = msg.downcast_mut::<PeriodicWave>() {
+            if let Some(current_periodic_wave) = &mut self.periodic_wave {
+                // Avoid deallocation in the render thread by swapping the wavetable buffers.
+                std::mem::swap(current_periodic_wave, periodic_wave)
+            } else {
+                // The default wavetable buffer is empty and does not cause allocations.
+                self.periodic_wave = Some(std::mem::take(periodic_wave));
             }
-            Err(msg) => msg,
-        };
+            self.type_ = OscillatorType::Custom; // shared type is already updated by control
+            return;
+        }
 
         log::warn!("OscillatorRenderer: Dropping incoming message {msg:?}");
     }

src/param.rs

@@ -1,4 +1,5 @@
 //! AudioParam interface
+use std::any::Any;
 use std::slice::{Iter, IterMut};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -641,22 +642,27 @@ impl AudioProcessor for AudioParamProcessor {
         true // has intrinsic value
     }
 
-    fn onmessage(&mut self, msg: Box<dyn std::any::Any + Send + 'static>) {
-        let msg = match msg.downcast::<AutomationRate>() {
-            Ok(automation_rate) => {
-                self.automation_rate = *automation_rate;
-                self.shared_parts.store_automation_rate(*automation_rate);
-                return;
-            }
-            Err(msg) => msg,
-        };
+    fn onmessage(&mut self, msg: &mut dyn Any) {
+        if let Some(automation_rate) = msg.downcast_ref::<AutomationRate>() {
+            self.automation_rate = *automation_rate;
+            self.shared_parts.store_automation_rate(*automation_rate);
+            return;
+        }
 
-        let msg = match msg.downcast::<AudioParamEvent>() {
-            Ok(event) => {
-                self.handle_incoming_event(*event);
-                return;
-            }
-            Err(msg) => msg,
+        if let Some(event) = msg.downcast_mut::<AudioParamEvent>() {
+            // Avoid deallocation of the event by replacing it with a tombstone.
+            let tombstone_event = AudioParamEvent {
+                event_type: AudioParamEventType::SetValue,
+                value: Default::default(),
+                time: Default::default(),
+                time_constant: None,
+                cancel_time: None,
+                duration: None,
+                values: None,
+            };
+            let event = std::mem::replace(event, tombstone_event);
+            self.handle_incoming_event(event);
+            return;
         };
 
         log::warn!("AudioParamProcessor: Dropping incoming message {msg:?}");
@@ -3161,7 +3167,7 @@ mod tests {
         };
         let (param, mut render) = audio_param_pair(opts, context.mock_registration());
 
-        render.onmessage(Box::new(AutomationRate::K));
+        render.onmessage(&mut AutomationRate::K);
         render.handle_incoming_event(param.set_value_at_time_raw(2., 0.000001));
 
         let vs = render.compute_intrinsic_values(0., 1., 10);
@@ -3180,7 +3186,7 @@ mod tests {
         };
         let (param, mut render) = audio_param_pair(opts, context.mock_registration());
 
-        render.onmessage(Box::new(AutomationRate::A));
+        render.onmessage(&mut AutomationRate::A);
         render.handle_incoming_event(param.set_value_at_time_raw(2., 0.000001));
 
         let vs = render.compute_intrinsic_values(0., 1., 10);

src/periodic_wave.rs

@@ -69,7 +69,7 @@ pub struct PeriodicWaveOptions {
 /// - `cargo run --release --example oscillators`
 ///
 // Basically a wrapper around Arc<Vec<f32>>, so `PeriodicWave`s are cheap to clone
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct PeriodicWave {
     wavetable: Arc<Vec<f32>>,
 }

src/render/graph.rs

@@ -1,4 +1,5 @@
 //! The audio graph topology and render algorithm
+use std::any::Any;
 use std::cell::RefCell;
 use std::panic::{self, AssertUnwindSafe};
 
@@ -190,11 +191,7 @@ impl Graph {
         self.nodes.get_mut(&index).unwrap().get_mut().cycle_breaker = true;
     }
 
-    pub fn route_message(
-        &mut self,
-        index: AudioNodeId,
-        msg: Box<dyn std::any::Any + Send + 'static>,
-    ) {
+    pub fn route_message(&mut self, index: AudioNodeId, msg: &mut dyn Any) {
         self.nodes
             .get_mut(&index)
             .unwrap()