From fb30d291ce4ce87bbe80c0a997ff12e364a4e532 Mon Sep 17 00:00:00 2001 From: Alex Moon Date: Wed, 18 Nov 2020 10:22:41 -0700 Subject: [PATCH] Avoid calling alsa::PCM::new() multiple times. Ensures that alsa::PCM::new() is called only once for a given Device so that we are not rapidly opening and closing ALSA devices. --- Cargo.toml | 1 + src/host/alsa/enumerate.rs | 36 ++++++++++++++++---------- src/host/alsa/mod.rs | 53 ++++++++++++++++++++++++++++++++------ 3 files changed, 68 insertions(+), 22 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index fd831e9..b5daa78 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,6 +30,7 @@ lazy_static = "1.3" alsa = "0.4.3" nix = "0.15.0" libc = "0.2.65" +parking_lot = "0.11" jack = { version = "0.6.5", optional = true } [target.'cfg(any(target_os = "macos", target_os = "ios"))'.dependencies] diff --git a/src/host/alsa/enumerate.rs b/src/host/alsa/enumerate.rs index a269d7b..00e2bb9 100644 --- a/src/host/alsa/enumerate.rs +++ b/src/host/alsa/enumerate.rs @@ -1,4 +1,5 @@ use super::alsa; +use super::parking_lot::Mutex; use super::Device; use {BackendSpecificError, DevicesError}; @@ -48,21 +49,16 @@ impl Iterator for Devices { }; // See if the device has an available output stream. - let has_available_output = { - let playback_handle = - alsa::pcm::PCM::new(&name, alsa::Direction::Playback, true); - playback_handle.is_ok() - }; + let playback = alsa::pcm::PCM::new(&name, alsa::Direction::Playback, true).ok(); // See if the device has an available input stream. - let has_available_input = { - let capture_handle = - alsa::pcm::PCM::new(&name, alsa::Direction::Capture, true); - capture_handle.is_ok() - }; + let capture = alsa::pcm::PCM::new(&name, alsa::Direction::Capture, true).ok(); - if has_available_output || has_available_input { - return Some(Device(name)); + if playback.is_some() || capture.is_some() { + return Some(Device { + name, + handles: Mutex::new(super::DeviceHandles { playback, capture }), + }); } } } @@ -72,12 +68,24 @@ impl Iterator for Devices { #[inline] pub fn default_input_device() -> Option { - Some(Device("default".to_owned())) + Some(Device { + name: "default".to_owned(), + handles: Mutex::new(super::DeviceHandles { + playback: None, + capture: None, + }), + }) } #[inline] pub fn default_output_device() -> Option { - Some(Device("default".to_owned())) + Some(Device { + name: "default".to_owned(), + handles: Mutex::new(super::DeviceHandles { + playback: None, + capture: None, + }), + }) } impl From for DevicesError { diff --git a/src/host/alsa/mod.rs b/src/host/alsa/mod.rs index b11e328..809709a 100644 --- a/src/host/alsa/mod.rs +++ b/src/host/alsa/mod.rs @@ -1,7 +1,9 @@ extern crate alsa; extern crate libc; +extern crate parking_lot; use self::alsa::poll::Descriptors; +use self::parking_lot::Mutex; use crate::{ BackendSpecificError, BufferSize, BuildStreamError, ChannelCount, Data, DefaultStreamConfigError, DeviceNameError, DevicesError, InputCallbackInfo, OutputCallbackInfo, @@ -163,8 +165,15 @@ impl Drop for TriggerReceiver { } } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Device(String); +struct DeviceHandles { + playback: Option, + capture: Option, +} + +pub struct Device { + name: String, + handles: Mutex, +} impl Device { fn build_stream_inner( @@ -173,10 +182,21 @@ impl Device { sample_format: SampleFormat, stream_type: alsa::Direction, ) -> Result { - let name = &self.0; + let name = &self.name; - let handle = match alsa::pcm::PCM::new(name, stream_type, true).map_err(|e| (e, e.errno())) - { + let device_handle = { + let mut guard = self.handles.lock(); + match stream_type { + alsa::Direction::Playback => guard.playback.take(), + alsa::Direction::Capture => guard.capture.take(), + } + }; + + let handle_result = Ok(device_handle).transpose().unwrap_or_else(|| { + alsa::pcm::PCM::new(name, stream_type, true).map_err(|e| (e, e.errno())) + }); + + let handle = match handle_result { Err((_, Some(nix::errno::Errno::EBUSY))) => { return Err(BuildStreamError::DeviceNotAvailable) } @@ -229,16 +249,33 @@ impl Device { #[inline] fn name(&self) -> Result { - Ok(self.0.clone()) + Ok(self.name.clone()) } fn supported_configs( &self, stream_t: alsa::Direction, ) -> Result, SupportedStreamConfigsError> { - let name = &self.0; + let name = &self.name; - let handle = match alsa::pcm::PCM::new(name, stream_t, true).map_err(|e| (e, e.errno())) { + let mut guard = self.handles.lock(); + + let device_handle = match stream_t { + alsa::Direction::Playback => &mut guard.playback, + alsa::Direction::Capture => &mut guard.capture, + }; + + let handle_result = match device_handle { + Some(handle) => Ok(handle), + None => alsa::pcm::PCM::new(name, stream_t, true) + .map(|handle| { + *device_handle = Some(handle); + device_handle.as_mut().unwrap() + }) + .map_err(|e| (e, e.errno())), + }; + + let handle = match handle_result { Err((_, Some(nix::errno::Errno::ENOENT))) | Err((_, Some(nix::errno::Errno::EBUSY))) => { return Err(SupportedStreamConfigsError::DeviceNotAvailable)