auden 0.1.0

Audio Engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};

#[derive(Debug)]
pub enum StreamError {
    NoDevice,
    Play(cpal::PlayStreamError),
    Pause(cpal::PauseStreamError),
    Build(cpal::BuildStreamError),
}

pub struct Stream {
    stream: cpal::Stream,
}

impl Drop for Stream {
    fn drop(&mut self) {
        if let Err(e) = self.stream.pause() {
            log::error!("failed to stop stream : {e}");
        }
    }
}

impl Stream {
    pub fn launch(
        config: &cpal::StreamConfig,
        callback: impl FnMut(&mut [f32], usize) + Send + 'static,
    ) -> Result<Self, StreamError> {
        let device = default_device()?;
        log::info!("selected device : {}", device.name().unwrap_or_default());

        let stream = launch(&device, config, callback).map_err(StreamError::Build)?;
        stream.play().map_err(StreamError::Play)?;
        Ok(Self { stream })
    }

    pub fn launch_with_timeout(
        config: &cpal::StreamConfig,
        timeout: std::time::Duration,
        callback: impl FnMut(&mut [f32], usize) + Send + 'static,
    ) -> Result<(), StreamError> {
        let device = default_device()?;
        log::info!("selected device : {}", device.name().unwrap_or_default());

        let stream = launch(&device, config, callback).map_err(StreamError::Build)?;

        stream.play().map_err(StreamError::Play).and_then(|_| {
            std::thread::sleep(timeout);
            stream.pause().map_err(StreamError::Pause)
        })
    }
}

fn default_device() -> Result<cpal::Device, StreamError> {
    cpal::default_host()
        .default_output_device()
        .ok_or(StreamError::NoDevice)
}

fn launch(
    device: &cpal::Device,
    config: &cpal::StreamConfig,
    mut callback: impl FnMut(&mut [f32], usize) + Send + 'static,
) -> Result<cpal::Stream, cpal::BuildStreamError> {
    let channels = config.channels as usize;
    let stream = device.build_output_stream(
        config,
        move |output: &mut [f32], _: &cpal::OutputCallbackInfo| {
            callback(output, channels);
        },
        |e| log::error!("error occurred on stream : {e}"),
        None,
    )?;
    Ok(stream)
}