soundcheck 1.0.0

A terminal-based audio monitoring application that displays real-time audio levels and exits when sound exceeds a specified threshold.
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

//! Application state management

use std::sync::{Arc, Mutex};

/// Type alias for audio processing shared state references
pub type AudioStateRefs = (
    Arc<Mutex<Vec<f32>>>,
    Arc<Mutex<Vec<f32>>>,
    Arc<Mutex<Vec<f32>>>,
    Arc<Mutex<Vec<bool>>>,
);

/// Internal application state
pub struct AppState {
    pub device_name: String,
    pub current_db: Vec<f32>,
    pub smoothed_db: Vec<f32>,
    pub display_db: Vec<f32>,
    pub threshold_db: i32,
    pub status: String,
    pub threshold_reached: Vec<bool>,
}

impl AppState {
    /// Create a new application state with default values
    pub fn new(device_name: String, threshold_db: i32, num_channels: usize) -> Self {
        let default_db = crate::constants::audio::MIN_DB_LEVEL as f32;
        Self {
            device_name: device_name.clone(),
            current_db: vec![default_db; num_channels],
            smoothed_db: vec![default_db; num_channels],
            display_db: vec![default_db; num_channels],
            threshold_db,
            status: format!(
                "Monitoring {}... Press Ctrl+C or Escape to quit.",
                device_name
            ),
            threshold_reached: vec![false; num_channels],
        }
    }

    /// Update state from shared audio processing values
    pub fn update_from_audio(
        &mut self,
        current_db: &Arc<Mutex<Vec<f32>>>,
        smoothed_db: &Arc<Mutex<Vec<f32>>>,
        display_db: &Arc<Mutex<Vec<f32>>>,
        threshold_reached: &Arc<Mutex<Vec<bool>>>,
    ) {
        self.current_db = current_db.lock().unwrap().clone();
        self.smoothed_db = smoothed_db.lock().unwrap().clone();
        self.display_db = display_db.lock().unwrap().clone();
        self.threshold_reached = threshold_reached.lock().unwrap().clone();
    }
}

/// Thread-safe shared state wrapper
pub struct SharedState {
    pub current_db: Arc<Mutex<Vec<f32>>>,
    pub smoothed_db: Arc<Mutex<Vec<f32>>>,
    pub display_db: Arc<Mutex<Vec<f32>>>,
    pub threshold_reached: Arc<Mutex<Vec<bool>>>,
}

impl SharedState {
    /// Create new shared state with default values
    pub fn new(num_channels: usize) -> Self {
        let default_db = crate::constants::audio::MIN_DB_LEVEL as f32;
        Self {
            current_db: Arc::new(Mutex::new(vec![default_db; num_channels])),
            smoothed_db: Arc::new(Mutex::new(vec![default_db; num_channels])),
            display_db: Arc::new(Mutex::new(vec![default_db; num_channels])),
            threshold_reached: Arc::new(Mutex::new(vec![false; num_channels])),
        }
    }

    /// Get clones of all shared state references for audio processing
    pub fn audio_refs(&self) -> AudioStateRefs {
        (
            Arc::clone(&self.current_db),
            Arc::clone(&self.smoothed_db),
            Arc::clone(&self.display_db),
            Arc::clone(&self.threshold_reached),
        )
    }
}