hodaun 0.2.0

Audio IO and synthesis
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

#[cfg(feature = "input")]
mod input;
#[cfg(feature = "output")]
mod output;

use self::cpal::{traits::DeviceTrait, *};
#[cfg(feature = "output")]
use crate::Frame;
#[cfg(feature = "input")]
pub use input::*;
#[cfg(feature = "output")]
pub use output::*;

/// Re-export of the [`cpal`](https://docs.rs/cpal) crate
pub mod cpal {
    pub use ::cpal::*;
}

/// A error encountered when trying to build audio I/O sources
#[derive(Debug, thiserror::Error)]
pub enum BuildSystemAudioError {
    /// An error building the audio stream
    #[error("{0}")]
    Stream(#[from] BuildStreamError),
    /// An error starting the audio stream
    #[error("{0}")]
    Play(#[from] PlayStreamError),
    /// An error querying stream configurations
    #[error("{0}")]
    SupportedConfigs(#[from] SupportedStreamConfigsError),
    /// An error getting a default stream configuration
    #[error("{0}")]
    DefaultConfig(#[from] DefaultStreamConfigError),
    /// No default input device is available
    #[error("No device available")]
    NoDevice,
    /// The device does not support the requested sample format
    #[error("Unsupported sample format")]
    UnsupportedSampleFormat,
}

/// A result type for trying to build audio I/O sources
pub type BuildSystemAudioResult<T> = Result<T, BuildSystemAudioError>;

/**

A builder for creating [`InputDeviceSource`]s and [`OutputDeviceMixer`]s
*/
#[derive(Default)]
pub struct DeviceIoBuilder {
    /// The device to use. If not set, the default device will be used.
    pub device: Option<Device>,
    /// The stream configuration to be used. If not set, the default will be used.
    pub config: Option<SupportedStreamConfig>,
}

impl DeviceIoBuilder {
    /// Initialize a builder with the default input device and stream configuration
    #[cfg(feature = "input")]
    pub fn default_input() -> Self {
        let device = default_input_device();
        let config = device
            .as_ref()
            .and_then(|device| device.default_input_config().ok());
        DeviceIoBuilder { device, config }
    }
    /// Initialize a builder with the default output device and stream configuration
    #[cfg(feature = "output")]
    pub fn default_output() -> Self {
        let device = default_output_device();
        let config = device
            .as_ref()
            .and_then(|device| device.default_output_config().ok());
        DeviceIoBuilder { device, config }
    }
    /// Set the input device
    pub fn device(self, device: Device) -> Self {
        DeviceIoBuilder {
            device: Some(device),
            ..self
        }
    }
    /// Set the stream configuration
    pub fn config(self, config: SupportedStreamConfig) -> Self {
        DeviceIoBuilder {
            config: Some(config),
            ..self
        }
    }
    /// Build an [`InputDeviceSource`]
    #[cfg(feature = "input")]
    pub fn build_input(self) -> BuildSystemAudioResult<InputDeviceSource> {
        InputDeviceSource::from_builder(self)
    }
    /// Build an [`OutputDeviceMixer`]
    #[cfg(feature = "output")]
    pub fn build_output<F>(self) -> BuildSystemAudioResult<OutputDeviceMixer<F>>
    where
        F: Frame + Send + 'static,
    {
        OutputDeviceMixer::from_builder(self)
    }
}