Ensure AudioContext suspend/resume_sync block control thread until completed

Author: orottier

src/context/online.rs

@@ -7,7 +7,7 @@ use crate::events::{EventDispatch, EventHandler, EventPayload, EventType};
 use crate::io::{self, AudioBackendManager, ControlThreadInit, RenderThreadInit};
 use crate::media_devices::{enumerate_devices_sync, MediaDeviceInfoKind};
 use crate::media_streams::{MediaStream, MediaStreamTrack};
-use crate::message::ControlMessage;
+use crate::message::{ControlMessage, OneshotNotify};
 use crate::node::{self, ChannelConfigOptions};
 use crate::render::graph::Graph;
 use crate::MediaElement;
@@ -387,13 +387,19 @@ impl AudioContext {
     ///
     /// * The audio device is not available
     /// * For a `BackendSpecificError`
-    #[allow(clippy::missing_const_for_fn, clippy::unused_self)]
     pub fn suspend_sync(&self) {
-        if self.backend_manager.lock().unwrap().suspend() {
-            // TODO: state should signal device readiness hence should be updated by the render
-            // thread, not the control thread.
-            self.base().set_state(AudioContextState::Suspended);
-        }
+        // First, pause rendering via a control message
+        let (sender, receiver) = crossbeam_channel::bounded(0);
+        let notify = OneshotNotify::Sync(sender);
+        let suspend_msg = ControlMessage::Suspend { notify };
+        self.base.send_control_msg(suspend_msg);
+
+        // Wait for the render thread to have processed the suspend message.
+        // The AudioContextState will be updated by the render thread.
+        receiver.recv().ok();
+
+        // Then ask the audio host to suspend the stream
+        self.backend_manager.lock().unwrap().suspend();
     }
 
     /// Resumes the progression of time in an audio context that has previously been
@@ -408,13 +414,19 @@ impl AudioContext {
     ///
     /// * The audio device is not available
     /// * For a `BackendSpecificError`
-    #[allow(clippy::missing_const_for_fn, clippy::unused_self)]
     pub fn resume_sync(&self) {
-        if self.backend_manager.lock().unwrap().resume() {
-            // TODO: state should signal device readiness hence should be updated by the render
-            // thread, not the control thread.
-            self.base().set_state(AudioContextState::Running);
-        }
+        // First ask the audio host to resume the stream
+        self.backend_manager.lock().unwrap().resume();
+
+        // Then, ask to resume rendering via a control message
+        let (sender, receiver) = crossbeam_channel::bounded(0);
+        let notify = OneshotNotify::Sync(sender);
+        let suspend_msg = ControlMessage::Resume { notify };
+        self.base.send_control_msg(suspend_msg);
+
+        // Wait for the render thread to have processed the resume message
+        // The AudioContextState will be updated by the render thread.
+        receiver.recv().ok();
     }
 
     /// Closes the `AudioContext`, releasing the system resources being used.

src/message.rs

@@ -7,8 +7,6 @@ use crate::node::ChannelConfig;
 use crate::render::graph::Graph;
 use crate::render::AudioProcessor;
 
-use crossbeam_channel::Sender;
-
 /// Commands from the control thread to the render thread
 pub(crate) enum ControlMessage {
     /// Register a new node in the audio graph
@@ -42,11 +40,19 @@ pub(crate) enum ControlMessage {
     MarkCycleBreaker { id: AudioNodeId },
 
     /// Shut down and recycle the audio graph
-    Shutdown { sender: Sender<Graph> },
+    Shutdown {
+        sender: crossbeam_channel::Sender<Graph>,
+    },
 
     /// Start rendering with given audio graph
     Startup { graph: Graph },
 
+    /// Suspend and pause audio processing
+    Suspend { notify: OneshotNotify },
+
+    /// Resume audio processing after suspending
+    Resume { notify: OneshotNotify },
+
     /// Generic message to be handled by AudioProcessor
     NodeMessage {
         id: AudioNodeId,
@@ -56,3 +62,21 @@ pub(crate) enum ControlMessage {
     /// Request a diagnostic report of the audio graph
     RunDiagnostics { buffer: Vec<u8> },
 }
+
+/// Helper object to emit single notification
+pub(crate) enum OneshotNotify {
+    /// A synchronous oneshot sender
+    Sync(crossbeam_channel::Sender<()>),
+    /// An asynchronous oneshot sender
+    Async(futures::channel::oneshot::Sender<()>),
+}
+
+impl OneshotNotify {
+    /// Emit the notification
+    pub fn send(self) {
+        match self {
+            Self::Sync(s) => s.send(()).ok(),
+            Self::Async(s) => s.send(()).ok(),
+        };
+    }
+}

src/render/thread.rs

@@ -33,6 +33,7 @@ pub(crate) struct RenderThread {
     /// number of channels of the backend stream, i.e. sound card number of
     /// channels clamped to MAX_CHANNELS
     number_of_channels: usize,
+    suspended: bool,
     state: Arc<AtomicU8>,
     frames_played: Arc<AtomicU64>,
     receiver: Option<Receiver<ControlMessage>>,
@@ -77,6 +78,7 @@ impl RenderThread {
             sample_rate,
             buffer_size: 0,
             number_of_channels,
+            suspended: false,
             state,
             frames_played,
             receiver: Some(receiver),
@@ -181,6 +183,16 @@ impl RenderThread {
                             .expect("Unable to send diagnostics - channel is full");
                     }
                 }
+                Suspend { notify } => {
+                    self.suspended = true;
+                    self.set_state(AudioContextState::Suspended);
+                    notify.send();
+                }
+                Resume { notify } => {
+                    self.suspended = false;
+                    self.set_state(AudioContextState::Running);
+                    notify.send();
+                }
             }
         }
     }
@@ -366,8 +378,8 @@ impl RenderThread {
         // handle addition/removal of nodes/edges
         self.handle_control_messages();
 
-        // if the thread is still booting, or shutting down, fill with silence
-        if !self.graph.as_ref().is_some_and(Graph::is_active) {
+        // if the thread is still booting, suspended, or shutting down, fill with silence
+        if self.suspended || !self.graph.as_ref().is_some_and(Graph::is_active) {
             output_buffer.fill(S::from_sample_(0.));
             return;
         }

tests/online.rs

@@ -106,25 +106,18 @@ fn test_none_sink_id() {
     assert_eq!(context.sink_id(), "none");
 
     context.suspend_sync();
-
-    // give event thread some time to pick up events
-    std::thread::sleep(std::time::Duration::from_millis(20));
     assert_eq!(context.state(), AudioContextState::Suspended);
     assert_eq!(state_changes.load(Ordering::Relaxed), 2); // suspended
 
     context.resume_sync();
     assert_eq!(context.state(), AudioContextState::Running);
-
-    // give event thread some time to pick up events
-    std::thread::sleep(std::time::Duration::from_millis(20));
     assert_eq!(state_changes.load(Ordering::Relaxed), 3); // resumed
 
     context.close_sync();
-    std::thread::sleep(std::time::Duration::from_millis(20));
-    assert_eq!(context.state(), AudioContextState::Closed);
 
     // give event thread some time to pick up events
     std::thread::sleep(std::time::Duration::from_millis(20));
+    assert_eq!(context.state(), AudioContextState::Closed);
     assert!(sink_stable.load(Ordering::SeqCst));
     assert_eq!(state_changes.load(Ordering::Relaxed), 4); // closed
 }