Merge pull request #311 from orottier/feature/prevent-out-of-order-arrival

Prevent out-of-order arrival of audio node settings

Author: orottier

src/context/base.rs

@@ -25,6 +25,8 @@ pub trait BaseAudioContext {
     /// Construct a new pair of [`AudioNode`] and [`AudioProcessor`]
     ///
     /// The `AudioNode` lives in the user-facing control thread. The Processor is sent to the render thread.
+    ///
+    /// Check the `examples/worklet.rs` file for example usage of this method.
     fn register<
         T: AudioNode,
         F: FnOnce(AudioContextRegistration) -> (T, Box<dyn AudioProcessor>),

src/context/concrete_base.rs

@@ -7,7 +7,7 @@ use crate::context::{
 use crate::events::{EventDispatch, EventHandler, EventLoop, EventType};
 use crate::message::ControlMessage;
 use crate::node::{AudioDestinationNode, AudioNode, ChannelConfig, ChannelConfigOptions};
-use crate::param::{AudioParam, AudioParamEvent};
+use crate::param::AudioParam;
 use crate::render::AudioProcessor;
 use crate::spatial::AudioListenerParams;
 
@@ -267,6 +267,9 @@ impl ConcreteBaseAudioContext {
 
     /// Returns the `AudioListener` which is used for 3D spatialization
     pub(super) fn listener(&self) -> AudioListener {
+        // instruct to BaseContext to add the AudioListener if it has not already
+        self.base().ensure_audio_listener_present();
+
         let mut ids = LISTENER_PARAM_IDS.map(|i| AudioContextRegistration {
             id: AudioNodeId(i),
             context: self.clone(),
@@ -372,22 +375,6 @@ impl ConcreteBaseAudioContext {
         self.send_control_msg(message).unwrap();
     }
 
-    /// Pass an `AudioParam::AudioParamEvent` to the render thread
-    ///
-    /// This clunky setup (wrapping a Sender in a message sent by another Sender) ensures
-    /// automation events will never be handled out of order.
-    pub(crate) fn pass_audio_param_event(
-        &self,
-        to: &Sender<AudioParamEvent>,
-        event: AudioParamEvent,
-    ) {
-        let message = ControlMessage::AudioParamEvent {
-            to: to.clone(),
-            event,
-        };
-        self.send_control_msg(message).unwrap();
-    }
-
     /// Connect the `AudioListener` to a `PannerNode`
     pub(crate) fn connect_listener_to_panner(&self, panner: AudioNodeId) {
         self.connect(LISTENER_NODE_ID, panner, 0, usize::MAX);

src/context/mod.rs

@@ -100,6 +100,18 @@ impl AudioContextRegistration {
     pub(crate) fn context(&self) -> &ConcreteBaseAudioContext {
         &self.context
     }
+
+    /// Send a message to the corresponding audio processor of this node
+    ///
+    /// 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) {
+        let wrapped = crate::message::ControlMessage::NodeMessage {
+            id: self.id,
+            msg: Box::new(msg),
+        };
+        let _ = self.context.send_control_msg(wrapped);
+    }
 }
 
 impl Drop for AudioContextRegistration {

src/control.rs

@@ -1,161 +1,105 @@
-//! Scheduler and Controller for precise timings
-
+use crate::AtomicF64;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
-use crate::AtomicF64;
-
-/// Helper struct to start and stop audio streams
-#[derive(Clone, Debug)]
-pub(crate) struct Scheduler {
-    inner: Arc<SchedulerInner>,
-}
-
-#[derive(Debug)]
-struct SchedulerInner {
-    start: AtomicF64,
-    stop: AtomicF64,
+/// Helper struct to control playback settings
+pub(crate) struct Controller {
+    /// Raw values
+    values: ControllerValues,
+    /// Values to be shared with another thread
+    shared: Arc<ControllerShared>,
 }
 
-// Uses the canonical ordering for handover of values, i.e. `Acquire` on load and `Release` on
-// store.
-impl Scheduler {
-    /// Create a new Scheduler. Initial playback state will be: inactive.
-    pub fn new() -> Self {
-        let inner = SchedulerInner {
-            start: AtomicF64::new(f64::MAX),
-            stop: AtomicF64::new(f64::MAX),
-        };
+impl Default for Controller {
+    /// Create a new Controller. It will not be active
+    fn default() -> Self {
+        let values = ControllerValues::default();
         Self {
-            inner: Arc::new(inner),
+            values: values.clone(),
+            shared: Arc::new(values.into()),
         }
     }
+}
 
-    /// Retrieve playback start value
-    pub fn get_start_at(&self) -> f64 {
-        self.inner.start.load(Ordering::Acquire)
+impl Controller {
+    pub fn shared(&self) -> &Arc<ControllerShared> {
+        &self.shared
     }
 
-    /// Schedule playback start at this timestamp
-    pub fn start_at(&self, start: f64) {
-        // todo panic on invalid values, or when already called
-        self.inner.start.store(start, Ordering::Release);
+    pub fn loop_(&self) -> bool {
+        self.values.loop_
     }
 
-    /// Retrieve playback stop value
-    pub fn get_stop_at(&self) -> f64 {
-        self.inner.stop.load(Ordering::Acquire)
+    pub fn set_loop(&mut self, loop_: bool) {
+        self.values.loop_ = loop_;
+        self.shared.loop_.store(loop_, Ordering::Release);
     }
 
-    /// Stop playback at this timestamp
-    pub fn stop_at(&self, stop: f64) {
-        // todo panic on invalid values, or when already called
-        self.inner.stop.store(stop, Ordering::Release);
+    pub fn loop_start(&self) -> f64 {
+        self.values.loop_start
     }
-}
 
-impl Default for Scheduler {
-    fn default() -> Self {
-        Self::new()
+    pub fn set_loop_start(&mut self, loop_start: f64) {
+        self.values.loop_start = loop_start;
+        self.shared.loop_start.store(loop_start, Ordering::Release);
+    }
+
+    pub fn loop_end(&self) -> f64 {
+        self.values.loop_end
+    }
+
+    pub fn set_loop_end(&mut self, loop_end: f64) {
+        self.values.loop_end = loop_end;
+        self.shared.loop_end.store(loop_end, Ordering::Release);
     }
 }
 
-/// Helper struct to control audio streams
-#[derive(Clone, Debug)]
-pub(crate) struct Controller {
-    inner: Arc<ControllerInner>,
+#[derive(Debug, Clone)]
+pub(crate) struct ControllerValues {
+    pub loop_: bool,
+    pub loop_start: f64,
+    pub loop_end: f64,
+}
+
+impl Default for ControllerValues {
+    fn default() -> Self {
+        Self {
+            loop_: false,
+            loop_start: 0.,
+            loop_end: f64::MAX,
+        }
+    }
 }
 
 #[derive(Debug)]
-struct ControllerInner {
-    scheduler: Scheduler,
+pub(crate) struct ControllerShared {
     loop_: AtomicBool,
     loop_start: AtomicF64,
     loop_end: AtomicF64,
-    offset: AtomicF64,
-    duration: AtomicF64,
 }
 
-// Uses the canonical ordering for handover of values, i.e. `Acquire` on load and `Release` on
-// store.
-impl Controller {
-    /// Create a new Controller. It will not be active
-    pub fn new() -> Self {
-        let inner = ControllerInner {
-            scheduler: Scheduler::new(),
-            loop_: AtomicBool::new(false),
-            loop_start: AtomicF64::new(0.),
-            loop_end: AtomicF64::new(f64::MAX),
-            offset: AtomicF64::new(f64::MAX),
-            duration: AtomicF64::new(f64::MAX),
-        };
-
+impl From<ControllerValues> for ControllerShared {
+    fn from(values: ControllerValues) -> Self {
         Self {
-            inner: Arc::new(inner),
+            loop_: AtomicBool::new(values.loop_),
+            loop_start: AtomicF64::new(values.loop_start),
+            loop_end: AtomicF64::new(values.loop_end),
         }
     }
+}
 
-    pub fn scheduler(&self) -> &Scheduler {
-        &self.inner.scheduler
-    }
-
+// Uses the canonical ordering for handover of values, i.e. `Acquire` on load and `Release` on
+// store.
+impl ControllerShared {
     pub fn loop_(&self) -> bool {
-        self.inner.loop_.load(Ordering::Acquire)
-    }
-
-    pub fn set_loop(&self, loop_: bool) {
-        self.inner.loop_.store(loop_, Ordering::Release);
+        self.loop_.load(Ordering::Acquire)
     }
 
     pub fn loop_start(&self) -> f64 {
-        self.inner.loop_start.load(Ordering::Acquire)
-    }
-
-    pub fn set_loop_start(&self, loop_start: f64) {
-        self.inner.loop_start.store(loop_start, Ordering::Release);
+        self.loop_start.load(Ordering::Acquire)
     }
 
     pub fn loop_end(&self) -> f64 {
-        self.inner.loop_end.load(Ordering::Acquire)
-    }
-
-    pub fn set_loop_end(&self, loop_end: f64) {
-        self.inner.loop_end.store(loop_end, Ordering::Release);
-    }
-
-    pub fn offset(&self) -> f64 {
-        self.inner.offset.load(Ordering::Acquire)
-    }
-
-    pub fn set_offset(&self, offset: f64) {
-        self.inner.offset.store(offset, Ordering::Release);
-    }
-
-    pub fn duration(&self) -> f64 {
-        self.inner.duration.load(Ordering::Acquire)
-    }
-
-    pub fn set_duration(&self, duration: f64) {
-        self.inner.duration.store(duration, Ordering::Release)
-    }
-}
-
-impl Default for Controller {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_controller() {
-        let controller = Controller::new();
-
-        assert!(!controller.loop_());
-        assert!(controller.loop_start() == 0.);
-        assert!(controller.loop_end() == f64::MAX);
+        self.loop_end.load(Ordering::Acquire)
     }
 }

src/message.rs

@@ -1,11 +1,10 @@
 //! Message passing from control to render node
 
+use crate::context::AudioNodeId;
 use crate::node::ChannelConfig;
-use crate::param::AudioParamEvent;
 use crate::render::graph::Graph;
 use crate::render::AudioProcessor;
 
-use crate::context::AudioNodeId;
 use crossbeam_channel::Sender;
 
 /// Commands from the control thread to the render thread
@@ -36,12 +35,6 @@ pub(crate) enum ControlMessage {
     /// Notify the render thread this node is dropped in the control thread
     FreeWhenFinished { id: AudioNodeId },
 
-    /// Pass an AudioParam AutomationEvent to the relevant node
-    AudioParamEvent {
-        to: Sender<AudioParamEvent>,
-        event: AudioParamEvent,
-    },
-
     /// Mark node as a cycle breaker (DelayNode only)
     MarkCycleBreaker { id: AudioNodeId },
 
@@ -50,4 +43,10 @@ pub(crate) enum ControlMessage {
 
     /// Start rendering with given audio graph
     Startup { graph: Graph },
+
+    /// Generic message to be handled by AudioProcessor
+    NodeMessage {
+        id: AudioNodeId,
+        msg: Box<dyn std::any::Any + Send + 'static>,
+    },
 }