Skip to main content

skenion_runtime/
audio_backend.rs

1use std::time::Duration;
2
3use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
4use thiserror::Error;
5
6use crate::{
7    AudioDspPlanOptions, AudioRealtimeDspError, AudioRealtimeDspExecutor, AudioRealtimeDspOptions,
8    ProjectRequestCurrent,
9};
10
11#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12pub struct AudioBackendConfig {
13    pub block_size: u32,
14}
15
16impl Default for AudioBackendConfig {
17    fn default() -> Self {
18        Self { block_size: 64 }
19    }
20}
21
22#[derive(Debug, Clone, PartialEq, Eq)]
23pub struct AudioBackendInfo {
24    pub device_name: String,
25    pub sample_rate: u32,
26    pub channels: u16,
27    pub sample_format: String,
28}
29
30pub struct RunningAudioBackend {
31    stream: cpal::Stream,
32    info: AudioBackendInfo,
33}
34
35impl RunningAudioBackend {
36    pub fn info(&self) -> &AudioBackendInfo {
37        &self.info
38    }
39
40    pub fn stream(&self) -> &cpal::Stream {
41        &self.stream
42    }
43
44    pub fn keep_alive_for(self, duration: Duration) {
45        std::thread::sleep(duration);
46    }
47}
48
49#[derive(Debug, Error)]
50pub enum AudioBackendError {
51    #[error("no default audio output device is available")]
52    NoDefaultOutputDevice,
53    #[error("audio backend error: {0}")]
54    Backend(#[from] cpal::Error),
55    #[error("default output sample format {0:?} is not supported by audio backend v0")]
56    UnsupportedSampleFormat(cpal::SampleFormat),
57    #[error("{0}")]
58    Dsp(#[from] AudioRealtimeDspError),
59}
60
61pub fn start_default_audio_output_backend(
62    request: &ProjectRequestCurrent,
63    config: AudioBackendConfig,
64) -> Result<RunningAudioBackend, AudioBackendError> {
65    let host = cpal::default_host();
66    let device = host
67        .default_output_device()
68        .ok_or(AudioBackendError::NoDefaultOutputDevice)?;
69    let device_name = format!("{device}");
70    let output_config = device.default_output_config()?;
71    let sample_format = output_config.sample_format();
72    if sample_format != cpal::SampleFormat::F32 {
73        return Err(AudioBackendError::UnsupportedSampleFormat(sample_format));
74    }
75
76    let sample_rate = output_config.sample_rate();
77    let channels = output_config.channels();
78    let stream_config = output_config.config();
79    let mut executor = AudioRealtimeDspExecutor::new(
80        request,
81        AudioRealtimeDspOptions {
82            plan: AudioDspPlanOptions {
83                block_size: config.block_size,
84                sample_rate,
85            },
86            channels: usize::from(channels),
87        },
88    )?;
89    let stream = device.build_output_stream(
90        stream_config,
91        move |data: &mut [f32], _| {
92            executor.process_interleaved_output(data);
93        },
94        |error| eprintln!("skenion audio backend stream error: {error}"),
95        None,
96    )?;
97    stream.play()?;
98
99    Ok(RunningAudioBackend {
100        stream,
101        info: AudioBackendInfo {
102            device_name,
103            sample_rate,
104            channels,
105            sample_format: format!("{sample_format:?}"),
106        },
107    })
108}