From ca2aceb5369aa3a3d4ffa2c0b4857842c34a66ca Mon Sep 17 00:00:00 2001 From: mitchmindtree Date: Sun, 12 Jan 2020 19:30:04 +0100 Subject: [PATCH] Fix state transition synchronisation in ASIO This makes some tweaks to the ASIO backend in order to fix some cases where races may have occured. This should allow us to remove the `Sync` bound on the `Device` and `Host` types. --- asio-sys/src/bindings/mod.rs | 89 +++++++++++++++++++++--------------- 1 file changed, 53 insertions(+), 36 deletions(-) diff --git a/asio-sys/src/bindings/mod.rs b/asio-sys/src/bindings/mod.rs index eee5c8b..0d38801 100644 --- a/asio-sys/src/bindings/mod.rs +++ b/asio-sys/src/bindings/mod.rs @@ -7,7 +7,7 @@ use self::errors::{AsioError, AsioErrorWrapper, LoadDriverError}; use std::ffi::CStr; use std::ffi::CString; use std::os::raw::{c_char, c_double, c_long, c_void}; -use std::sync::{Arc, Mutex, Weak}; +use std::sync::{Arc, Mutex, MutexGuard, Weak}; // Bindings import use self::asio_import as ai; @@ -85,7 +85,7 @@ pub struct SampleRate { } /// Holds the pointer to the callbacks that come from cpal -struct BufferCallback(Box); +struct BufferCallback(Box); /// Input and Output streams. /// @@ -422,6 +422,8 @@ impl Driver { // To pass as ai::ASIOCallbacks let mut callbacks = create_asio_callbacks(); + let mut state = self.inner.lock_state(); + // Retrieve the available buffer sizes. let buffer_sizes = asio_get_buffer_sizes()?; if buffer_sizes.pref <= 0 { @@ -432,13 +434,12 @@ impl Driver { } // Ensure the driver is in the `Initialized` state. - if let DriverState::Running = self.inner.state() { - self.stop()?; + if let DriverState::Running = *state { + state.stop()?; } - if let DriverState::Prepared = self.inner.state() { - self.dispose_buffers()?; + if let DriverState::Prepared = *state { + state.dispose_buffers()?; } - unsafe { asio_result!(ai::ASIOCreateBuffers( buffer_infos.as_mut_ptr() as *mut _, @@ -447,8 +448,8 @@ impl Driver { &mut callbacks as *mut _ as *mut _, ))?; } + *state = DriverState::Prepared; - self.inner.set_state(DriverState::Prepared); Ok(buffer_sizes.pref) } @@ -569,13 +570,14 @@ impl Driver { /// /// No-op if already `Running`. pub fn start(&self) -> Result<(), AsioError> { - if let DriverState::Running = self.inner.state() { + let mut state = self.inner.lock_state(); + if let DriverState::Running = *state { return Ok(()); } unsafe { asio_result!(ai::ASIOStart())?; } - self.inner.set_state(DriverState::Running); + *state = DriverState::Running; Ok(()) } @@ -635,55 +637,70 @@ impl Driver { } } -impl DriverInner { - fn state(&self) -> DriverState { - *self.state.lock().expect("failed to lock `DriverState`") - } - - fn set_state(&self, state: DriverState) { - *self.state.lock().expect("failed to lock `DriverState`") = state; - } - - fn stop_inner(&self) -> Result<(), AsioError> { - if let DriverState::Running = self.state() { +impl DriverState { + fn stop(&mut self) -> Result<(), AsioError> { + if let DriverState::Running = *self { unsafe { asio_result!(ai::ASIOStop())?; } - self.set_state(DriverState::Prepared); + *self = DriverState::Prepared; } Ok(()) } - fn dispose_buffers_inner(&self) -> Result<(), AsioError> { - if let DriverState::Initialized = self.state() { + fn dispose_buffers(&mut self) -> Result<(), AsioError> { + if let DriverState::Initialized = *self { return Ok(()); } - if let DriverState::Running = self.state() { - self.stop_inner()?; + if let DriverState::Running = *self { + self.stop()?; } unsafe { asio_result!(ai::ASIODisposeBuffers())?; } - self.set_state(DriverState::Initialized); + *self = DriverState::Initialized; Ok(()) } - fn destroy_inner(&mut self) -> Result<(), AsioError> { - // Drop back through the driver state machine one state at a time. - if let DriverState::Running = self.state() { - self.stop_inner()?; + fn destroy(&mut self) -> Result<(), AsioError> { + if let DriverState::Running = *self { + self.stop()?; } - if let DriverState::Prepared = self.state() { - self.dispose_buffers_inner()?; + if let DriverState::Prepared = *self { + self.dispose_buffers()?; } unsafe { asio_result!(ai::ASIOExit())?; ai::remove_current_driver(); } + Ok(()) + } +} - // Clear any existing stream callbacks. - if let Ok(mut bcs) = BUFFER_CALLBACK.lock() { - bcs.clear(); +impl DriverInner { + fn lock_state(&self) -> MutexGuard { + self.state.lock().expect("failed to lock `DriverState`") + } + + fn stop_inner(&self) -> Result<(), AsioError> { + let mut state = self.lock_state(); + state.stop() + } + + fn dispose_buffers_inner(&self) -> Result<(), AsioError> { + let mut state = self.lock_state(); + state.dispose_buffers() + } + + fn destroy_inner(&mut self) -> Result<(), AsioError> { + { + let mut state = self.lock_state(); + state.destroy()?; + + // Clear any existing stream callbacks. + if let Ok(mut bcs) = BUFFER_CALLBACK.lock() { + bcs.clear(); + } } // Signal that the driver has been destroyed.