use std::{
error::Error,
fmt,
iter::FusedIterator,
num::{NonZeroU16, NonZeroU32},
sync::{
Arc,
atomic::{AtomicBool, AtomicU64, Ordering},
},
time::Duration,
};
use rodio::{
DeviceSinkBuilder, DeviceSinkError, MixerDeviceSink, Source,
cpal::{
self, BufferSize, Sample as _,
traits::{DeviceTrait, HostTrait},
},
};
const MAX_BUFFER_FRAMES: u32 = 16_384;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AudioOutputConfig {
buffer_frames: u32,
device_buffer_fallback: bool,
}
impl AudioOutputConfig {
pub const fn new(buffer_frames: u32) -> Result<Self, AudioOutputError> {
if buffer_frames == 0 || buffer_frames > MAX_BUFFER_FRAMES {
return Err(AudioOutputError::InvalidBufferFrames {
requested: buffer_frames,
maximum: MAX_BUFFER_FRAMES,
});
}
Ok(Self {
buffer_frames,
device_buffer_fallback: false,
})
}
pub const fn buffer_frames(self) -> u32 {
self.buffer_frames
}
pub const fn with_device_buffer_fallback(mut self, enabled: bool) -> Self {
self.device_buffer_fallback = enabled;
self
}
pub const fn device_buffer_fallback(self) -> bool {
self.device_buffer_fallback
}
}
impl Default for AudioOutputConfig {
fn default() -> Self {
Self {
buffer_frames: 512,
device_buffer_fallback: false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AudioOutputInfo {
sample_rate: NonZeroU32,
channels: NonZeroU16,
requested_buffer_frames: u32,
configured_buffer_frames: Option<u32>,
used_device_buffer_fallback: bool,
}
impl AudioOutputInfo {
pub const fn sample_rate(self) -> NonZeroU32 {
self.sample_rate
}
pub const fn channels(self) -> NonZeroU16 {
self.channels
}
pub const fn requested_buffer_frames(self) -> u32 {
self.requested_buffer_frames
}
pub const fn configured_buffer_frames(self) -> Option<u32> {
self.configured_buffer_frames
}
pub const fn used_device_buffer_fallback(self) -> bool {
self.used_device_buffer_fallback
}
}
#[derive(Debug, Default)]
struct OutputState {
stream_errors: AtomicU64,
generated_samples: AtomicU64,
invalid_samples: AtomicU64,
finished: AtomicBool,
closed: AtomicBool,
}
#[derive(Debug, Clone)]
pub struct AudioOutputStatus {
state: Arc<OutputState>,
}
impl AudioOutputStatus {
fn new() -> Self {
Self {
state: Arc::new(OutputState::default()),
}
}
pub fn is_faulted(&self) -> bool {
self.stream_error_count() != 0
}
pub fn stream_error_count(&self) -> u64 {
self.state.stream_errors.load(Ordering::Relaxed)
}
pub fn generated_sample_count(&self) -> u64 {
self.state.generated_samples.load(Ordering::Relaxed)
}
pub fn invalid_sample_count(&self) -> u64 {
self.state.invalid_samples.load(Ordering::Relaxed)
}
pub fn is_finished(&self) -> bool {
self.state.finished.load(Ordering::Acquire)
}
pub fn is_closed(&self) -> bool {
self.state.closed.load(Ordering::Acquire)
}
fn record_stream_error(&self) {
increment(&self.state.stream_errors);
}
}
fn increment(counter: &AtomicU64) {
let _ = counter.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
Some(value.saturating_add(1))
});
}
#[derive(Debug)]
struct OutputLifetime {
status: AudioOutputStatus,
}
impl Drop for OutputLifetime {
fn drop(&mut self) {
self.status.state.closed.store(true, Ordering::Release);
}
}
#[derive(Debug)]
#[must_use = "dropping the output guard closes its audio device"]
pub struct AudioOutput {
device: MixerDeviceSink,
info: AudioOutputInfo,
lifetime: OutputLifetime,
}
impl AudioOutput {
pub fn open(config: AudioOutputConfig) -> Result<Self, AudioOutputError> {
let selected_device = cpal::default_host().default_output_device().ok_or(
AudioOutputError::DeviceConfiguration(DeviceSinkError::NoDevice),
)?;
let format = selected_device.default_output_config().map_err(|error| {
AudioOutputError::DeviceConfiguration(DeviceSinkError::DefaultSinkConfigError(error))
})?;
let ((mut device, status), used_fallback) = open_with_policy(config, |buffer_size| {
let status = AudioOutputStatus::new();
let callback_status = status.clone();
let device = DeviceSinkBuilder::default()
.with_device(selected_device.clone())
.with_supported_config(&format)
.with_buffer_size(buffer_size)
.with_error_callback(move |_| callback_status.record_stream_error())
.open_stream()?;
Ok((device, status))
})?;
device.log_on_drop(false);
let backend = device.config();
let info = AudioOutputInfo {
sample_rate: backend.sample_rate(),
channels: backend.channel_count(),
requested_buffer_frames: config.buffer_frames,
configured_buffer_frames: match backend.buffer_size() {
BufferSize::Fixed(frames) => Some(*frames),
BufferSize::Default => None,
},
used_device_buffer_fallback: used_fallback,
};
Ok(Self {
device,
info,
lifetime: OutputLifetime { status },
})
}
pub const fn info(&self) -> AudioOutputInfo {
self.info
}
pub fn status(&self) -> AudioOutputStatus {
self.lifetime.status.clone()
}
pub fn play_mono(self, source: impl Iterator<Item = f32> + Send + 'static) -> AudioPlayback {
let source = MonoSource {
source,
sample_rate: self.info.sample_rate,
status: self.status(),
ended: false,
};
self.device.mixer().add(source);
AudioPlayback { output: self }
}
}
#[derive(Debug)]
#[must_use = "dropping playback closes its audio output"]
pub struct AudioPlayback {
output: AudioOutput,
}
impl AudioPlayback {
pub const fn info(&self) -> AudioOutputInfo {
self.output.info()
}
pub fn status(&self) -> AudioOutputStatus {
self.output.status()
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum AudioOutputError {
InvalidBufferFrames {
requested: u32,
maximum: u32,
},
DeviceConfiguration(DeviceSinkError),
Open {
requested: DeviceSinkError,
fallback: Option<DeviceSinkError>,
},
}
impl fmt::Display for AudioOutputError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidBufferFrames { requested, maximum } => write!(
formatter,
"audio buffer request {requested} must be between 1 and {maximum} frames"
),
Self::DeviceConfiguration(error) => {
write!(
formatter,
"default audio device configuration failed: {error}"
)
}
Self::Open {
requested,
fallback,
} => {
write!(
formatter,
"requested audio buffer could not open: {requested}"
)?;
if let Some(fallback) = fallback {
write!(
formatter,
"; device-default buffer retry also failed: {fallback}"
)?;
}
Ok(())
}
}
}
}
impl Error for AudioOutputError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::InvalidBufferFrames { .. } => None,
Self::DeviceConfiguration(error) => Some(error),
Self::Open {
requested,
fallback,
} => Some(fallback.as_ref().unwrap_or(requested)),
}
}
}
fn open_with_policy<T>(
config: AudioOutputConfig,
mut open: impl FnMut(BufferSize) -> Result<T, DeviceSinkError>,
) -> Result<(T, bool), AudioOutputError> {
match open(BufferSize::Fixed(config.buffer_frames)) {
Ok(output) => Ok((output, false)),
Err(requested) => {
if !config.device_buffer_fallback {
return Err(AudioOutputError::Open {
requested,
fallback: None,
});
}
match open(BufferSize::Default) {
Ok(output) => Ok((output, true)),
Err(fallback) => Err(AudioOutputError::Open {
requested,
fallback: Some(fallback),
}),
}
}
}
}
struct MonoSource<I> {
source: I,
sample_rate: NonZeroU32,
status: AudioOutputStatus,
ended: bool,
}
impl<I: Iterator<Item = f32>> Iterator for MonoSource<I> {
type Item = rodio::Sample;
fn next(&mut self) -> Option<Self::Item> {
if self.ended {
return None;
}
let Some(sample) = self.source.next() else {
self.ended = true;
self.status.state.finished.store(true, Ordering::Release);
return None;
};
increment(&self.status.state.generated_samples);
let sanitized = if !sample.is_finite() {
increment(&self.status.state.invalid_samples);
0.0
} else if !(-1.0..=1.0).contains(&sample) {
increment(&self.status.state.invalid_samples);
sample.clamp(-1.0, 1.0)
} else {
sample
};
Some(rodio::Sample::from_sample(sanitized))
}
}
impl<I: Iterator<Item = f32>> FusedIterator for MonoSource<I> {}
impl<I: Iterator<Item = f32>> Source for MonoSource<I> {
fn current_span_len(&self) -> Option<usize> {
self.ended.then_some(0)
}
fn channels(&self) -> NonZeroU16 {
NonZeroU16::MIN
}
fn sample_rate(&self) -> NonZeroU32 {
self.sample_rate
}
fn total_duration(&self) -> Option<Duration> {
None
}
}
#[cfg(test)]
#[path = "output_tests.rs"]
mod tests;