Merge pull request #466 from orottier/feature/continue-playing-after-drop

Online AudioContext improvements (continue playing after drop, terminate event loop)

Author: orottier

examples/roundtrip_latency_test.rs

@@ -138,7 +138,7 @@ fn main() {
 
     let estimated_latency = Arc::new(AtomicF64::new(0.));
 
-    let _context = if test {
+    if test {
         // emulate loopback
         let latency: f32 = 0.017;
         println!(
@@ -169,8 +169,6 @@ fn main() {
 
         latency_tester.connect(&delay);
         delay.connect(&latency_tester);
-
-        context
     } else {
         // full round trip
         let devices = enumerate_devices_sync();
@@ -221,8 +219,6 @@ fn main() {
         // create media stream source node with mic stream
         let stream_source = context.create_media_stream_source(&mic);
         stream_source.connect(&latency_tester);
-
-        context
     };
 
     loop {

src/context/concrete_base.rs

@@ -356,10 +356,14 @@ impl ConcreteBaseAudioContext {
 
     /// Updates state of current context
     pub(super) fn set_state(&self, state: AudioContextState) {
+        // Only to be used from OfflineAudioContext, the online one should emit the state changes
+        // from the render thread
+        debug_assert!(self.offline());
+
         let current_state = self.state();
         if current_state != state {
             self.inner.state.store(state as u8, Ordering::Release);
-            let _ = self.send_event(EventDispatch::state_change());
+            let _ = self.send_event(EventDispatch::state_change(state));
         }
     }
 

src/context/online.rs

@@ -4,7 +4,7 @@ use std::sync::Mutex;
 
 use crate::context::{AudioContextState, BaseAudioContext, ConcreteBaseAudioContext};
 use crate::events::{EventDispatch, EventHandler, EventPayload, EventType};
-use crate::io::{self, AudioBackendManager, ControlThreadInit, RenderThreadInit};
+use crate::io::{self, AudioBackendManager, ControlThreadInit, NoneBackend, RenderThreadInit};
 use crate::media_devices::{enumerate_devices_sync, MediaDeviceInfoKind};
 use crate::media_streams::{MediaStream, MediaStreamTrack};
 use crate::message::{ControlMessage, OneshotNotify};
@@ -129,6 +129,17 @@ impl std::fmt::Debug for AudioContext {
     }
 }
 
+impl Drop for AudioContext {
+    fn drop(&mut self) {
+        // Continue playing the stream if the AudioContext goes out of scope
+        if self.state() == AudioContextState::Running {
+            let tombstone = Box::new(NoneBackend::void());
+            let original = std::mem::replace(self.backend_manager.get_mut().unwrap(), tombstone);
+            Box::leak(original);
+        }
+    }
+}
+
 impl BaseAudioContext for AudioContext {
     fn base(&self) -> &ConcreteBaseAudioContext {
         &self.base

src/events.rs

@@ -1,4 +1,4 @@
-use crate::context::AudioNodeId;
+use crate::context::{AudioContextState, AudioNodeId};
 use crate::{AudioBuffer, AudioRenderCapacityEvent};
 
 use std::any::Any;
@@ -55,6 +55,7 @@ pub(crate) enum EventPayload {
     ProcessorError(ErrorEvent),
     Diagnostics(Vec<u8>),
     Message(Box<dyn Any + Send + 'static>),
+    AudioContextState(AudioContextState),
 }
 
 #[derive(Debug)]
@@ -78,10 +79,10 @@ impl EventDispatch {
         }
     }
 
-    pub fn state_change() -> Self {
+    pub fn state_change(state: AudioContextState) -> Self {
         EventDispatch {
             type_: EventType::StateChange,
-            payload: EventPayload::None,
+            payload: EventPayload::AudioContextState(state),
         }
     }
 
@@ -130,11 +131,22 @@ impl EventLoop {
     }
 
     pub fn run(&self, event_channel: Receiver<EventDispatch>) {
+        log::debug!("Entering event loop");
         let self_clone = self.clone();
 
-        std::thread::spawn(move || loop {
-            // this thread is dedicated to event handling so we can block
-            for event in event_channel.iter() {
+        std::thread::spawn(move || {
+            // This thread is dedicated to event handling so we can block
+            for mut event in event_channel.iter() {
+                // Terminate the event loop when the audio context is closing
+                let mut terminate = false;
+                if matches!(
+                    event.payload,
+                    EventPayload::AudioContextState(AudioContextState::Closed)
+                ) {
+                    event.payload = EventPayload::None; // the statechange handler takes no argument
+                    terminate = true;
+                }
+
                 let mut event_handler_lock = self_clone.event_handlers.lock().unwrap();
                 let callback_option = event_handler_lock.remove(&event.type_);
                 drop(event_handler_lock); // release Mutex while running callback
@@ -152,7 +164,13 @@ impl EventLoop {
                         }
                     };
                 }
+
+                if terminate {
+                    break;
+                }
             }
+
+            log::debug!("Event loop has terminated");
         });
     }
 

src/io/cpal.rs

@@ -417,10 +417,6 @@ impl AudioBackendManager for CpalBackend {
         self.sink_id.as_str()
     }
 
-    fn boxed_clone(&self) -> Box<dyn AudioBackendManager> {
-        Box::new(self.clone())
-    }
-
     fn enumerate_devices_sync() -> Vec<MediaDeviceInfo>
     where
         Self: Sized,

src/io/cubeb.rs

@@ -395,10 +395,6 @@ impl AudioBackendManager for CubebBackend {
         self.sink_id.as_str()
     }
 
-    fn boxed_clone(&self) -> Box<dyn AudioBackendManager> {
-        Box::new(self.clone())
-    }
-
     fn enumerate_devices_sync() -> Vec<MediaDeviceInfo>
     where
         Self: Sized,

src/io/mod.rs

@@ -14,6 +14,7 @@ use crate::message::ControlMessage;
 use crate::{AudioRenderCapacityLoad, RENDER_QUANTUM_SIZE};
 
 mod none;
+pub(crate) use none::NoneBackend;
 
 #[cfg(feature = "cpal")]
 mod cpal;
@@ -91,7 +92,7 @@ pub(crate) fn build_output(
     render_thread_init: RenderThreadInit,
 ) -> Box<dyn AudioBackendManager> {
     if options.sink_id == "none" {
-        let backend = none::NoneBackend::build_output(options, render_thread_init);
+        let backend = NoneBackend::build_output(options, render_thread_init);
         return Box::new(backend);
     }
 
@@ -185,9 +186,6 @@ pub(crate) trait AudioBackendManager: Send + Sync + 'static {
     /// The audio output device - `""` means the default device
     fn sink_id(&self) -> &str;
 
-    /// Clone the stream reference
-    fn boxed_clone(&self) -> Box<dyn AudioBackendManager>;
-
     fn enumerate_devices_sync() -> Vec<MediaDeviceInfo>
     where
         Self: Sized;
@@ -225,12 +223,12 @@ fn buffer_size_for_latency_category(
 pub(crate) fn enumerate_devices_sync() -> Vec<MediaDeviceInfo> {
     #[cfg(feature = "cubeb")]
     {
-        crate::io::cubeb::CubebBackend::enumerate_devices_sync()
+        cubeb::CubebBackend::enumerate_devices_sync()
     }
 
     #[cfg(all(not(feature = "cubeb"), feature = "cpal"))]
     {
-        crate::io::cpal::CpalBackend::enumerate_devices_sync()
+        cpal::CpalBackend::enumerate_devices_sync()
     }
 
     #[cfg(all(not(feature = "cubeb"), not(feature = "cpal")))]

src/io/none.rs

@@ -23,6 +23,16 @@ pub(crate) struct NoneBackend {
     sample_rate: f32,
 }
 
+impl NoneBackend {
+    /// Creates a mock backend to be used as tombstones
+    pub(crate) fn void() -> Self {
+        Self {
+            sample_rate: 0.,
+            sender: crossbeam_channel::bounded(0).0,
+        }
+    }
+}
+
 struct Callback {
     receiver: Receiver<NoneBackendMessage>,
     render_thread: RenderThread,
@@ -160,11 +170,6 @@ impl AudioBackendManager for NoneBackend {
         "none"
     }
 
-    /// Clone the stream reference
-    fn boxed_clone(&self) -> Box<dyn AudioBackendManager> {
-        Box::new(self.clone())
-    }
-
     fn enumerate_devices_sync() -> Vec<MediaDeviceInfo>
     where
         Self: Sized,

src/render/thread.rs

@@ -461,7 +461,7 @@ impl RenderThread {
     fn set_state(&self, state: AudioContextState) {
         self.state.store(state as u8, Ordering::Relaxed);
         if let Some(sender) = self.event_sender.as_ref() {
-            sender.try_send(EventDispatch::state_change()).ok();
+            sender.try_send(EventDispatch::state_change(state)).ok();
         }
     }
 }