Change ScriptProcessorNode::onaudioprocess API - use owned buffer value

This is easier for the node bindings. We hook into the Drop call of the
event to ship the output buffer to the render thread.

TODO: I found a gnarly bug where the ScriptProcessorRenderer would be
cleared from the audio graph erroneously. AudioContextRegistration
should not be allowed to implement Clone because it has a very
meaningful Drop implementation. That's why I now resort to an `Arc` hack
to prevent the Drop method to run.

Author: orottier

examples/script_processor.rs

@@ -28,7 +28,7 @@ fn main() {
     });
 
     let node = context.create_script_processor(512, 1, 1);
-    node.set_onaudioprocess(|e| {
+    node.set_onaudioprocess(|mut e| {
         let mut rng = rand::thread_rng();
         e.output_buffer
             .get_channel_data_mut(0)

src/events.rs

@@ -52,6 +52,15 @@ 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>>,
+}
+
+impl Drop for AudioProcessingEvent {
+    fn drop(&mut self) {
+        if let Some(registration) = self.registration.take() {
+            registration.post_message(self.output_buffer.clone());
+        }
+    }
 }
 
 /// The OfflineAudioCompletionEvent Event interface

src/node/script_processor.rs

@@ -7,6 +7,7 @@ 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)]
@@ -139,18 +140,19 @@ impl ScriptProcessorNode {
     ///
     /// 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(&mut AudioProcessingEvent) + Send + 'static>(
+    pub fn set_onaudioprocess<F: FnMut(AudioProcessingEvent) + Send + 'static>(
         &self,
         mut callback: F,
     ) {
-        let registration = self.registration.clone();
+        // TODO, hack: use Arc to prevent drop of AudioContextRegistration
+        let registration = Arc::new(self.registration.clone());
         let callback = move |v| {
             let mut payload = match v {
                 EventPayload::AudioProcessing(v) => v,
                 _ => unreachable!(),
             };
-            callback(&mut payload);
-            registration.post_message(payload.output_buffer);
+            payload.registration = Some(Arc::clone(&registration));
+            callback(payload);
         };
 
         self.context().set_event_handler(
@@ -301,7 +303,7 @@ mod tests {
 
         let node = context.create_script_processor(BUFFER_SIZE, 0, 1);
         node.connect(&context.destination());
-        node.set_onaudioprocess(|e| {
+        node.set_onaudioprocess(|mut e| {
             e.output_buffer.get_channel_data_mut(0).fill(1.); // set all samples to 1.
         });
 

src/render/processor.rs

@@ -68,6 +68,7 @@ impl AudioWorkletGlobalScope {
             input_buffer,
             output_buffer,
             playback_time,
+            registration: None,
         };
         let dispatch = EventDispatch::audio_processing(self.node_id.get(), event);
         let _ = self.event_sender.try_send(dispatch);