Initial Phoenix analyzer

src/config.rs

@@ -0,0 +1,154 @@
+use std::path::PathBuf;
+
+use crate::model::{InputSource, PhoenixGlobalConfig, PhoenixRtaConfig};
+
+#[derive(Clone, Debug)]
+pub struct PhoenixConfig {
+    pub listen_addr: String,
+    pub alsa_card_index: u8,
+    pub alsa_device_name: Option<String>,
+    #[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+    pub sample_rate: u32,
+    #[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+    pub period_size: u32,
+    #[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+    pub buffer_size: u32,
+    pub global_config_path: PathBuf,
+    pub frontend_presets_path: PathBuf,
+    pub frontend_layouts_path: PathBuf,
+    pub recordings_dir_analyzer: PathBuf,
+    pub recordings_dir_volumio: PathBuf,
+    pub max_recording_upload_bytes: u64,
+    pub lr_fractional_delay_enabled: bool,
+    pub lr_fractional_delay_samples: f32,
+}
+
+impl PhoenixConfig {
+    pub fn from_env() -> Self {
+        Self {
+            listen_addr: std::env::var("PHOENIX_LISTEN")
+                .unwrap_or_else(|_| "127.0.0.1:8789".to_string()),
+            alsa_card_index: std::env::var("PHOENIX_ALSA_CARD")
+                .ok()
+                .and_then(|v| v.parse::<u8>().ok())
+                .unwrap_or(2),
+            alsa_device_name: std::env::var("PHOENIX_ALSA_DEVICE")
+                .ok()
+                .map(|v| v.trim().to_string())
+                .filter(|v| !v.is_empty()),
+            sample_rate: std::env::var("PHOENIX_SAMPLE_RATE")
+                .ok()
+                .and_then(|v| v.parse::<u32>().ok())
+                .unwrap_or(48_000),
+            period_size: std::env::var("PHOENIX_PERIOD_SIZE")
+                .ok()
+                .and_then(|v| v.parse::<u32>().ok())
+                .unwrap_or(128),
+            buffer_size: std::env::var("PHOENIX_BUFFER_SIZE")
+                .ok()
+                .and_then(|v| v.parse::<u32>().ok())
+                .unwrap_or(512),
+            global_config_path: std::env::var("PHOENIX_GLOBAL_CONFIG_PATH")
+                .ok()
+                .map(|v| PathBuf::from(v.trim()))
+                .filter(|v| !v.as_os_str().is_empty())
+                .unwrap_or_else(default_global_config_path),
+            frontend_presets_path: std::env::var("PHOENIX_FRONTEND_PRESETS_PATH")
+                .ok()
+                .map(|v| PathBuf::from(v.trim()))
+                .filter(|v| !v.as_os_str().is_empty())
+                .unwrap_or_else(default_frontend_presets_path),
+            frontend_layouts_path: std::env::var("PHOENIX_FRONTEND_LAYOUTS_PATH")
+                .ok()
+                .map(|v| PathBuf::from(v.trim()))
+                .filter(|v| !v.as_os_str().is_empty())
+                .unwrap_or_else(default_frontend_layouts_path),
+            recordings_dir_analyzer: std::env::var("PHOENIX_RECORDINGS_DIR_ANALYZER")
+                .ok()
+                .map(|v| PathBuf::from(v.trim()))
+                .filter(|v| !v.as_os_str().is_empty())
+                .unwrap_or_else(default_recordings_dir_analyzer),
+            recordings_dir_volumio: std::env::var("PHOENIX_RECORDINGS_DIR_VOLUMIO")
+                .ok()
+                .map(|v| PathBuf::from(v.trim()))
+                .filter(|v| !v.as_os_str().is_empty())
+                .unwrap_or_else(default_recordings_dir_volumio),
+            max_recording_upload_bytes: std::env::var("PHOENIX_MAX_RECORDING_UPLOAD_BYTES")
+                .ok()
+                .and_then(|v| v.trim().parse::<u64>().ok())
+                .filter(|v| *v > 0)
+                .unwrap_or(2 * 1024 * 1024 * 1024),
+            lr_fractional_delay_enabled: std::env::var("PHOENIX_LR_FRAC_DELAY_ENABLED")
+                .ok()
+                .map(|v| matches!(v.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on"))
+                .unwrap_or(true),
+            lr_fractional_delay_samples: std::env::var("PHOENIX_LR_FRAC_DELAY_SAMPLES")
+                .ok()
+                .and_then(|v| v.parse::<f32>().ok())
+                .unwrap_or(0.996),
+        }
+    }
+
+    pub fn alsa_device(&self) -> String {
+        if let Some(device) = &self.alsa_device_name {
+            return device.clone();
+        }
+        format!("hw:{},0", self.alsa_card_index)
+    }
+
+    pub fn default_rta_config(&self) -> PhoenixRtaConfig {
+        let mut config = PhoenixRtaConfig::default();
+        config.lr_fractional_delay_enabled = self.lr_fractional_delay_enabled;
+        config.lr_fractional_delay_samples = self.lr_fractional_delay_samples;
+        config
+    }
+
+    pub fn default_global_config(&self) -> PhoenixGlobalConfig {
+        let mut config = PhoenixGlobalConfig::default();
+        config.input_source = InputSource::Line;
+        config.lr_fractional_delay_enabled = self.lr_fractional_delay_enabled;
+        config.lr_fractional_delay_samples = self.lr_fractional_delay_samples;
+        config
+    }
+}
+
+fn default_global_config_path() -> PathBuf {
+    if let Some(home) = std::env::var_os("HOME") {
+        let mut path = PathBuf::from(home);
+        path.push(".config");
+        path.push("phoenix");
+        path.push("global-config.json");
+        return path;
+    }
+    PathBuf::from("phoenix-global-config.json")
+}
+
+fn default_frontend_presets_path() -> PathBuf {
+    if let Some(home) = std::env::var_os("HOME") {
+        let mut path = PathBuf::from(home);
+        path.push(".config");
+        path.push("phoenix");
+        path.push("frontend-presets.json");
+        return path;
+    }
+    PathBuf::from("phoenix-frontend-presets.json")
+}
+
+fn default_frontend_layouts_path() -> PathBuf {
+    if let Some(home) = std::env::var_os("HOME") {
+        let mut path = PathBuf::from(home);
+        path.push(".config");
+        path.push("phoenix");
+        path.push("frontend-layouts.json");
+        return path;
+    }
+    PathBuf::from("phoenix-frontend-layouts.json")
+}
+
+fn default_recordings_dir_analyzer() -> PathBuf {
+    PathBuf::from("/home/analyzer/Aufnahmen")
+}
+
+fn default_recordings_dir_volumio() -> PathBuf {
+    PathBuf::from("/home/volumio/Aufnahmen")
+}