libfoksalaudio 1.1.5

foksal audio library
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use anyhow::{Result, anyhow, bail};
use cpal::{
    Device as CpalDevice, FromSample, OutputCallbackInfo, SampleFormat, SizedSample,
    SupportedStreamConfig,
    platform::Stream as CpalStream,
    traits::{DeviceTrait, HostTrait, StreamTrait},
};
use crossbeam_channel as cbeam_chan;
use tracing::error;

use libfoksalcommon::CommonSample;

trait Sample: FromSample<CommonSample> + SizedSample + Send + 'static {}

impl Sample for i8 {}
impl Sample for i16 {}
impl Sample for i32 {}
impl Sample for i64 {}
impl Sample for u8 {}
impl Sample for u16 {}
impl Sample for u32 {}
impl Sample for u64 {}
impl Sample for f32 {}
impl Sample for f64 {}

pub struct Device {
    inner: CpalDevice,
    config: SupportedStreamConfig,
    stream: Option<CpalStream>,
}

impl TryFrom<CpalDevice> for Device {
    type Error = anyhow::Error;

    fn try_from(inner: CpalDevice) -> Result<Self> {
        let config = inner.default_output_config()?;
        Ok(Self {
            inner,
            config,
            stream: None,
        })
    }
}

impl Device {
    pub fn try_new(name: impl AsRef<str>) -> Result<Self> {
        let host = cpal::default_host();
        let inner = match host.output_devices()?.find(|x| {
            x.description()
                .ok()
                .map(|x| x.name() == name.as_ref())
                .unwrap_or(false)
        }) {
            Some(device) => device,
            None => {
                let mut err_msg = format!(
                    "audio backend `{}` unavailable, available backends: ",
                    name.as_ref()
                );
                for name in host
                    .output_devices()?
                    .filter_map(|x| x.description().ok().map(|x| x.name().to_owned()))
                {
                    err_msg.push_str(&name);
                    err_msg.push_str(", ");
                }
                bail!(err_msg)
            }
        };

        Self::try_from(inner)
    }

    pub fn try_default() -> Result<Self> {
        let host = cpal::default_host();
        let inner = host
            .default_output_device()
            .ok_or(anyhow!("default audio backend not found"))?;

        Self::try_from(inner)
    }

    pub fn n_channels(&self) -> usize {
        self.config.channels() as usize
    }

    pub fn sample_rate(&self) -> usize {
        self.config.sample_rate() as usize
    }

    pub fn init(&mut self, rx_samples: cbeam_chan::Receiver<CommonSample>) -> Result<()> {
        macro_rules! build_output_stream {
            ($type:ty) => {
                self.inner.build_output_stream(
                    &self.config.clone().into(),
                    self.create_data_callback::<$type>(rx_samples)?,
                    |e| error!("playback error ({})", e),
                    None,
                )?
            };
        }

        use SampleFormat as S;
        let stream = match self.config.sample_format() {
            S::I8 => build_output_stream!(i8),
            S::I16 => build_output_stream!(i16),
            S::I32 => build_output_stream!(i32),
            S::I64 => build_output_stream!(i64),
            S::U8 => build_output_stream!(u8),
            S::U16 => build_output_stream!(u16),
            S::U32 => build_output_stream!(u32),
            S::U64 => build_output_stream!(u64),
            S::F32 => build_output_stream!(f32),
            S::F64 => build_output_stream!(f64),
            x => bail!(format!("unsupported sample format `{:?}`", x)),
        };
        stream.play()?;
        self.stream.replace(stream);

        Ok(())
    }

    fn create_data_callback<T>(
        &self,
        rx_sample: cbeam_chan::Receiver<CommonSample>,
    ) -> Result<impl FnMut(&mut [T], &OutputCallbackInfo) + Send + 'static>
    where
        T: Sample,
    {
        let callback = move |data: &mut [T], _: &OutputCallbackInfo| {
            let mut i = 0;
            while let Ok(s) = rx_sample.try_recv() {
                data[i] = T::from_sample(s);
                i += 1;
                if i >= data.len() {
                    break;
                }
            }
            data[i..].fill(T::EQUILIBRIUM);
        };

        Ok(callback)
    }
}