lookas 1.10.0

Perception aligned terminal-based audio spectrum visualizer
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

mod device;
mod mic;
mod stream;
mod system;

pub use device::{best_config_for, pick_input_device};
pub use stream::build_stream;
pub use system::SystemHandle;

use crate::buffer::SharedBuf;
use anyhow::Result;
use std::sync::{Arc, Mutex};

use mic::start_mic;
use system::start_system;

const DEFAULT_SAMPLE_RATE: u32 = 48_000;

pub type AudioError = anyhow::Error;

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum AudioMode {
    Mic,
    System,
    Both,
}

pub struct CaptureInfo {
    pub label: String,
    pub sample_rate: u32,
}

pub struct AudioController {
    mode: AudioMode,
    mic: Option<mic::MicHandle>,
    sys: Option<system::SystemHandle>,
    info: CaptureInfo,
}

impl Default for AudioController {
    fn default() -> Self {
        Self::new()
    }
}

impl AudioController {
    #[must_use]
    pub fn new() -> Self {
        Self {
            mode: AudioMode::Mic,
            mic: None,
            sys: None,
            info: CaptureInfo {
                label: "mic".into(),
                sample_rate: DEFAULT_SAMPLE_RATE,
            },
        }
    }

    #[must_use]
    pub const fn mode(&self) -> AudioMode {
        self.mode
    }

    #[must_use]
    pub const fn info(&self) -> &CaptureInfo {
        &self.info
    }

    pub fn start(
        &mut self,
        mode: AudioMode,
        mic_shared: Arc<Mutex<SharedBuf>>,
        sys_shared: Arc<Mutex<SharedBuf>>,
    ) -> Result<()> {
        self.stop();

        match mode {
            AudioMode::Mic => {
                let mic = start_mic(mic_shared)?;
                self.info = CaptureInfo {
                    label: mic.label.clone(),
                    sample_rate: mic.sample_rate,
                };
                self.mic = Some(mic);
                self.mode = mode;
                Ok(())
            }
            AudioMode::System => {
                let sys =
                    start_system(sys_shared, DEFAULT_SAMPLE_RATE)?;
                self.info = CaptureInfo {
                    label: sys.label.clone(),
                    sample_rate: sys.sample_rate,
                };
                self.sys = Some(sys);
                self.mode = mode;
                Ok(())
            }
            AudioMode::Both => {
                let mic = start_mic(mic_shared)?;
                let sys = start_system(sys_shared, mic.sample_rate)?;
                self.info = CaptureInfo {
                    label: format!("{} + {}", mic.label, sys.label),
                    sample_rate: mic.sample_rate,
                };
                self.mic = Some(mic);
                self.sys = Some(sys);
                self.mode = mode;
                Ok(())
            }
        }
    }

    pub fn reset(
        &mut self,
        mic_shared: Arc<Mutex<SharedBuf>>,
        sys_shared: Arc<Mutex<SharedBuf>>,
    ) -> Result<()> {
        let mode = self.mode;
        self.start(mode, mic_shared, sys_shared)
    }

    pub fn stop(&mut self) {
        self.sys.take();
        self.mic.take();
    }
}