No Clone for AudioContextRegistration because the Drop has side effects

Rewrite the AudioProcessingEvent a bit to circumvent this limitation

Author: orottier

src/context/mod.rs

@@ -88,9 +88,8 @@ impl From<u8> for AudioContextState {
 /// Only when implementing the AudioNode trait manually, this struct is of any concern.
 ///
 /// This object allows for communication with the render thread and dynamic lifetime management.
-//
-// The only way to construct this object is by calling [`BaseAudioContext::register`]
-#[derive(Clone)]
+// The only way to construct this object is by calling [`BaseAudioContext::register`].
+// This struct should not derive Clone because of the Drop handler.
 pub struct AudioContextRegistration {
     /// the audio context in which nodes and connections lives
     context: ConcreteBaseAudioContext,

src/events.rs

@@ -1,3 +1,4 @@
+use crate::context::ConcreteBaseAudioContext;
 use crate::context::{AudioContextState, AudioNodeId};
 use crate::{AudioBuffer, AudioRenderCapacityEvent};
 
@@ -52,13 +53,17 @@ pub struct AudioProcessingEvent {
     /// The time when the audio will be played in the same time coordinate system as the
     /// AudioContext's currentTime.
     pub playback_time: f64,
-    pub(crate) registration: Option<Arc<crate::context::AudioContextRegistration>>,
+    pub(crate) registration: Option<(ConcreteBaseAudioContext, AudioNodeId)>,
 }
 
 impl Drop for AudioProcessingEvent {
     fn drop(&mut self) {
-        if let Some(registration) = self.registration.take() {
-            registration.post_message(self.output_buffer.clone());
+        if let Some((context, id)) = self.registration.take() {
+            let wrapped = crate::message::ControlMessage::NodeMessage {
+                id,
+                msg: llq::Node::new(Box::new(self.output_buffer.clone())),
+            };
+            context.send_control_msg(wrapped);
         }
     }
 }

src/node/script_processor.rs

@@ -7,7 +7,6 @@ use crate::render::{
 use crate::{AudioBuffer, RENDER_QUANTUM_SIZE};
 
 use std::any::Any;
-use std::sync::Arc;
 
 /// Options for constructing an [`ScriptProcessorNode`]
 #[derive(Clone, Debug)]
@@ -138,20 +137,25 @@ impl ScriptProcessorNode {
     /// the inputBuffer attribute. The audio data which is the result of the processing (or the
     /// synthesized data if there are no inputs) is then placed into the outputBuffer.
     ///
+    /// The output buffer is shipped back to the render thread when the AudioProcessingEvent goes
+    /// out of scope, so be sure not to store it somewhere.
+    ///
     /// Only a single event handler is active at any time. Calling this method multiple times will
     /// override the previous event handler.
     pub fn set_onaudioprocess<F: FnMut(AudioProcessingEvent) + Send + 'static>(
         &self,
         mut callback: F,
     ) {
-        // TODO, hack: use Arc to prevent drop of AudioContextRegistration
-        let registration = Arc::new(self.registration.clone());
+        // We need these fields to ship the output buffer to the render thread
+        let base = self.registration().context().clone();
+        let id = self.registration().id();
+
         let callback = move |v| {
             let mut payload = match v {
                 EventPayload::AudioProcessing(v) => v,
                 _ => unreachable!(),
             };
-            payload.registration = Some(Arc::clone(&registration));
+            payload.registration = Some((base.clone(), id));
             callback(payload);
         };