use std::{
collections::HashSet,
sync::{Arc, Mutex, OnceLock},
};
use rodio::{
DeviceSinkBuilder, DeviceSinkError, DeviceTrait, MixerDeviceSink, Player,
cpal::{BufferSize, traits::HostTrait},
};
use crate::{Backend, Device, OutputError};
#[derive(Clone)]
pub struct Output {
mixer_device_sink: Arc<Mutex<Option<MixerDeviceSink>>>,
backend: Option<Backend>,
device: Option<Device>,
}
impl Default for Output {
fn default() -> Self {
Self::new()
}
}
static CACHED_AUDIO_BACKENDS: OnceLock<Mutex<Option<Vec<Backend>>>> = OnceLock::new();
static CACHED_OUTPUT_DEVICES: OnceLock<Mutex<Option<Vec<Device>>>> = OnceLock::new();
pub fn switch_outputs_to_device<'a>(
outputs: impl IntoIterator<Item = &'a mut Output>,
device: &Device,
) -> Result<(), OutputError> {
for output in outputs {
output.switch_device(device)?;
}
Ok(())
}
pub fn switch_outputs_to_backend<'a>(
outputs: impl IntoIterator<Item = &'a mut Output>,
backend: Backend,
) -> Result<(), OutputError> {
for output in outputs {
output.switch_backend(backend)?;
}
Ok(())
}
impl Output {
pub fn new() -> Self {
let backend = Some(rodio::cpal::default_host().id());
let device = backend.and_then(Self::default_device_for_backend);
#[cfg(not(target_arch = "wasm32"))]
let mixer_device_sink: Option<MixerDeviceSink> = Self::open_default_sink();
#[cfg(target_arch = "wasm32")]
let mixer_device_sink = None;
Self {
mixer_device_sink: Arc::new(Mutex::new(mixer_device_sink)),
backend,
device,
}
}
pub fn available_backends() -> Vec<Backend> {
let cache = CACHED_AUDIO_BACKENDS.get_or_init(|| Mutex::new(None));
if let Some(backends) = cache.lock().unwrap().clone() {
return backends;
}
Self::refresh_available_backends()
}
pub fn refresh_available_backends() -> Vec<Backend> {
let backends = rodio::cpal::available_hosts();
*CACHED_AUDIO_BACKENDS
.get_or_init(|| Mutex::new(None))
.lock()
.unwrap() = Some(backends.clone());
*CACHED_OUTPUT_DEVICES
.get_or_init(|| Mutex::new(None))
.lock()
.unwrap() = None;
backends
}
pub fn available_devices() -> Vec<Device> {
let cache = CACHED_OUTPUT_DEVICES.get_or_init(|| Mutex::new(None));
if let Some(devices) = cache.lock().unwrap().clone() {
return devices;
}
Self::refresh_available_devices()
}
pub fn refresh_available_devices() -> Vec<Device> {
let backends = rodio::cpal::available_hosts();
let default_backend = rodio::cpal::default_host().id();
let mut devices: Vec<Device> = backends
.iter()
.flat_map(|backend| Self::available_devices_for_backend(*backend).unwrap_or_default())
.collect();
devices.sort_by(|first, second| {
second
.is_default
.cmp(&first.is_default)
.then_with(|| {
(second.backend == default_backend).cmp(&(first.backend == default_backend))
})
.then_with(|| first.name().cmp(second.name()))
.then_with(|| first.backend.name().cmp(second.backend.name()))
});
let mut seen = HashSet::new();
devices.retain(|device| seen.insert(device.name().to_string()));
devices.sort_by(|first, second| {
second
.is_default
.cmp(&first.is_default)
.then_with(|| first.name().cmp(second.name()))
});
*CACHED_AUDIO_BACKENDS
.get_or_init(|| Mutex::new(None))
.lock()
.unwrap() = Some(backends);
*CACHED_OUTPUT_DEVICES
.get_or_init(|| Mutex::new(None))
.lock()
.unwrap() = Some(devices.clone());
devices
}
pub fn backend_label(backend: Backend) -> String {
format!("{backend:?}")
}
pub fn parse_backend_label(label: &str) -> Option<Backend> {
Self::available_backends()
.into_iter()
.find(|backend| Self::backend_label(*backend).eq_ignore_ascii_case(label.trim()))
}
pub fn available_devices_for_backend(backend: Backend) -> Result<Vec<Device>, OutputError> {
let host = rodio::cpal::host_from_id(backend)
.map_err(|source| OutputError::BackendUnavailable { backend, source })?;
let default_device = host.default_output_device();
let default_id = default_device.as_ref().and_then(|device| device.id().ok());
let default_name = default_device
.as_ref()
.and_then(|device| device.description().ok())
.map(|description| description.name().to_string());
let mut devices: Vec<Device> = host
.output_devices()
.map_err(|source| OutputError::ListDevices { backend, source })?
.filter_map(|device| {
let is_default = match (&default_id, device.id().ok()) {
(Some(default_id), Some(id)) => &id == default_id,
_ => device.description().is_ok_and(|description| {
default_name.as_deref() == Some(description.name())
}),
};
Device::from_cpal_device(backend, &device, is_default)
})
.collect();
if let Some(default_device) = default_device
&& !devices.iter().any(|device| device.is_default)
&& let Some(default) = Device::from_cpal_device(backend, &default_device, true)
{
devices.push(default);
}
devices.sort_by(|first, second| {
second
.is_default
.cmp(&first.is_default)
.then_with(|| first.name().cmp(second.name()))
});
Ok(devices)
}
pub fn try_new_with_device(device: &Device) -> Result<Self, OutputError> {
#[cfg(not(target_arch = "wasm32"))]
let mixer_device_sink = Some(Self::open_device_sink(device)?);
#[cfg(target_arch = "wasm32")]
let mixer_device_sink = {
rodio::cpal::host_from_id(device.backend).map_err(|source| {
OutputError::BackendUnavailable {
backend: device.backend,
source,
}
})?;
None
};
Ok(Self {
mixer_device_sink: Arc::new(Mutex::new(mixer_device_sink)),
backend: Some(device.backend),
device: Some(device.clone()),
})
}
pub fn try_new_with_backend(backend: Backend) -> Result<Self, OutputError> {
#[cfg(not(target_arch = "wasm32"))]
let mixer_device_sink = Some(Self::open_backend_sink(backend)?);
#[cfg(target_arch = "wasm32")]
let mixer_device_sink = {
rodio::cpal::host_from_id(backend)
.map_err(|source| OutputError::BackendUnavailable { backend, source })?;
None
};
Ok(Self {
mixer_device_sink: Arc::new(Mutex::new(mixer_device_sink)),
backend: Some(backend),
device: Self::default_device_for_backend(backend),
})
}
pub(crate) fn new_with_preferred_backend(preferred: Option<Backend>) -> Self {
let Some(backend) = preferred else {
return Self::new();
};
match Self::try_new_with_backend(backend) {
Ok(output) => output,
Err(_) => Self::new_deferred(Some(backend)),
}
}
pub fn new_deferred(preferred: Option<Backend>) -> Self {
let backend = preferred.unwrap_or_else(|| rodio::cpal::default_host().id());
Self {
mixer_device_sink: Arc::new(Mutex::new(None)),
backend: Some(backend),
device: Self::default_device_for_backend(backend),
}
}
pub fn switch_backend(&mut self, backend: Backend) -> Result<(), OutputError> {
if self.backend == Some(backend) {
return Ok(());
}
let new = Self::try_new_with_backend(backend)?;
let _ = new.retry_sink(); *self = new;
Ok(())
}
pub fn switch_device(&mut self, device: &Device) -> Result<(), OutputError> {
if self.device.as_ref() == Some(device) {
return Ok(());
}
let new = Self::try_new_with_device(device)?;
let _ = new.retry_sink(); *self = new;
Ok(())
}
pub fn backend(&self) -> Option<Backend> {
self.backend
}
pub fn device(&self) -> Option<Device> {
self.device.clone()
}
pub fn display_name(&self) -> String {
let Some(backend) = self.backend else {
return "Custom".to_string();
};
let label = Self::backend_label(backend);
self.device.as_ref().map_or_else(
|| label.clone(),
|device| {
if device.name().is_empty() {
label.clone()
} else {
format!("{label} ({})", device.name())
}
},
)
}
pub fn from_sink(mixer_device_sink: MixerDeviceSink) -> Self {
Self {
mixer_device_sink: Arc::new(Mutex::new(Some(mixer_device_sink))),
backend: None,
device: None,
}
}
#[cfg(not(target_arch = "wasm32"))]
fn open_default_sink() -> Option<MixerDeviceSink> {
let device = cpal::default_host().default_output_device()?;
match Self::sink_builder(device).and_then(|builder| builder.open_sink_or_fallback()) {
Ok(mut sink) => {
sink.log_on_drop(false);
Some(sink)
}
Err(_) => None,
}
}
fn sink_builder(device: cpal::Device) -> Result<DeviceSinkBuilder, DeviceSinkError> {
Ok(DeviceSinkBuilder::from_device(device)?.with_buffer_size(BufferSize::Default))
}
fn open_backend_sink(backend: Backend) -> Result<MixerDeviceSink, OutputError> {
let host = rodio::cpal::host_from_id(backend)
.map_err(|source| OutputError::BackendUnavailable { backend, source })?;
let device = host
.default_output_device()
.or_else(|| host.output_devices().ok()?.next())
.ok_or(OutputError::NoOutputDevice(backend))?;
let mut sink = Self::sink_builder(device)
.and_then(|builder| builder.open_sink_or_fallback())
.map_err(|source| OutputError::OpenStream { backend, source })?;
sink.log_on_drop(false);
Ok(sink)
}
fn default_device_for_backend(backend: Backend) -> Option<Device> {
let host = rodio::cpal::host_from_id(backend).ok()?;
let device = host.default_output_device()?;
Device::from_cpal_device(backend, &device, true)
}
fn find_backend_device(device: &Device) -> Result<rodio::cpal::Device, OutputError> {
let host = rodio::cpal::host_from_id(device.backend).map_err(|source| {
OutputError::BackendUnavailable {
backend: device.backend,
source,
}
})?;
if let Some(id) = device.id.as_ref()
&& let Some(device) = host.device_by_id(id)
{
return Ok(device);
}
host.output_devices()
.map_err(|source| OutputError::ListDevices {
backend: device.backend,
source,
})?
.find(|candidate| device.matches_cpal_device(candidate))
.ok_or_else(|| OutputError::DeviceNotFound {
device: Box::new(device.clone()),
})
}
fn open_device_sink(device: &Device) -> Result<MixerDeviceSink, OutputError> {
let backend_device = Self::find_backend_device(device)?;
let mut sink = Self::sink_builder(backend_device)
.and_then(|builder| builder.open_sink_or_fallback())
.map_err(|source| OutputError::OpenDeviceStream {
device: Box::new(device.clone()),
source,
})?;
sink.log_on_drop(false);
Ok(sink)
}
pub fn retry_sink(&self) -> Result<(), OutputError> {
#[cfg(all(target_arch = "wasm32", feature = "nightly"))]
crate::patch::ensure_audioworklet_text_polyfill();
let mut mixer_device_sink = self.mixer_device_sink.lock().unwrap();
if mixer_device_sink.is_none() {
let sink = match (self.device.clone(), self.backend) {
(Some(device), _) => Self::open_device_sink(&device)?,
(None, Some(backend)) => Self::open_backend_sink(backend)?,
(None, None) => return Ok(()),
};
*mixer_device_sink = Some(sink);
}
Ok(())
}
pub fn has_output(&self) -> bool {
self.mixer_device_sink.lock().unwrap().is_some()
}
pub(crate) fn connect_player(&self) -> Option<Player> {
self.mixer_device_sink
.lock()
.unwrap()
.as_ref()
.map(|mixer_device_sink| Player::connect_new(mixer_device_sink.mixer()))
}
pub fn log_on_drop(&self, log: bool) {
if let Some(mixer_device_sink) = self.mixer_device_sink.lock().unwrap().as_mut() {
mixer_device_sink.log_on_drop(log);
}
}
}
#[cfg(test)]
mod tests {
use crate::{Output, switch_outputs_to_device};
#[test]
fn switching_many_outputs_to_the_current_device_is_a_noop() {
let Some(device) = Output::new_deferred(None).device() else {
eprintln!("Skipping batch assertions: no output device reported");
return;
};
let mut third = Output::new_deferred(None);
let mut fourth = Output::new_deferred(None);
switch_outputs_to_device([&mut third, &mut fourth], &device)
.expect("switching every output to its current device should succeed");
}
}