soundcheck 0.0.22

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

//! Application state management

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

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

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

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

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

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

impl SharedState {
    /// Create new shared state with default values
    pub fn new() -> Self {
        Self {
            current_db: Arc::new(Mutex::new(crate::constants::audio::MIN_DB_LEVEL)),
            smoothed_db: Arc::new(Mutex::new(crate::constants::audio::MIN_DB_LEVEL)),
            display_db: Arc::new(Mutex::new(crate::constants::audio::MIN_DB_LEVEL)),
            threshold_reached: Arc::new(Mutex::new(false)),
        }
    }

    /// 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),
        )
    }
}