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.