Init

src/state/audio.rs

@@ -0,0 +1,292 @@
+use doux::audio::AudioDeviceInfo;
+use std::path::PathBuf;
+
+#[derive(Clone, Copy, PartialEq, Eq, Default)]
+pub enum RefreshRate {
+    #[default]
+    Fps60,
+    Fps30,
+}
+
+impl RefreshRate {
+    pub fn from_fps(fps: u32) -> Self {
+        if fps >= 60 {
+            RefreshRate::Fps60
+        } else {
+            RefreshRate::Fps30
+        }
+    }
+
+    pub fn toggle(self) -> Self {
+        match self {
+            RefreshRate::Fps60 => RefreshRate::Fps30,
+            RefreshRate::Fps30 => RefreshRate::Fps60,
+        }
+    }
+
+    pub fn millis(self) -> u64 {
+        match self {
+            RefreshRate::Fps60 => 16,
+            RefreshRate::Fps30 => 33,
+        }
+    }
+
+    pub fn label(self) -> &'static str {
+        match self {
+            RefreshRate::Fps60 => "60",
+            RefreshRate::Fps30 => "30",
+        }
+    }
+
+    pub fn to_fps(self) -> u32 {
+        match self {
+            RefreshRate::Fps60 => 60,
+            RefreshRate::Fps30 => 30,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct AudioConfig {
+    pub output_device: Option<String>,
+    pub input_device: Option<String>,
+    pub channels: u16,
+    pub buffer_size: u32,
+    pub sample_rate: f32,
+    pub sample_paths: Vec<PathBuf>,
+    pub sample_count: usize,
+    pub refresh_rate: RefreshRate,
+}
+
+impl Default for AudioConfig {
+    fn default() -> Self {
+        Self {
+            output_device: None,
+            input_device: None,
+            channels: 2,
+            buffer_size: 512,
+            sample_rate: 44100.0,
+            sample_paths: Vec::new(),
+            sample_count: 0,
+            refresh_rate: RefreshRate::default(),
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Default)]
+pub enum AudioFocus {
+    #[default]
+    OutputDevice,
+    InputDevice,
+    Channels,
+    BufferSize,
+    RefreshRate,
+    RuntimeHighlight,
+    SamplePaths,
+    LinkEnabled,
+    StartStopSync,
+    Quantum,
+}
+
+pub struct Metrics {
+    pub event_count: usize,
+    pub active_voices: usize,
+    pub peak_voices: usize,
+    pub cpu_load: f32,
+    pub schedule_depth: usize,
+    pub scope: [f32; 64],
+    pub peak_left: f32,
+    pub peak_right: f32,
+}
+
+impl Default for Metrics {
+    fn default() -> Self {
+        Self {
+            event_count: 0,
+            active_voices: 0,
+            peak_voices: 0,
+            cpu_load: 0.0,
+            schedule_depth: 0,
+            scope: [0.0; 64],
+            peak_left: 0.0,
+            peak_right: 0.0,
+        }
+    }
+}
+
+pub struct AudioSettings {
+    pub config: AudioConfig,
+    pub focus: AudioFocus,
+    pub output_devices: Vec<AudioDeviceInfo>,
+    pub input_devices: Vec<AudioDeviceInfo>,
+    pub restart_pending: bool,
+    pub error: Option<String>,
+}
+
+impl Default for AudioSettings {
+    fn default() -> Self {
+        Self {
+            config: AudioConfig::default(),
+            focus: AudioFocus::default(),
+            output_devices: doux::audio::list_output_devices(),
+            input_devices: doux::audio::list_input_devices(),
+            restart_pending: false,
+            error: None,
+        }
+    }
+}
+
+impl AudioSettings {
+    pub fn refresh_devices(&mut self) {
+        self.output_devices = doux::audio::list_output_devices();
+        self.input_devices = doux::audio::list_input_devices();
+    }
+
+    pub fn next_focus(&mut self) {
+        self.focus = match self.focus {
+            AudioFocus::OutputDevice => AudioFocus::InputDevice,
+            AudioFocus::InputDevice => AudioFocus::Channels,
+            AudioFocus::Channels => AudioFocus::BufferSize,
+            AudioFocus::BufferSize => AudioFocus::RefreshRate,
+            AudioFocus::RefreshRate => AudioFocus::RuntimeHighlight,
+            AudioFocus::RuntimeHighlight => AudioFocus::SamplePaths,
+            AudioFocus::SamplePaths => AudioFocus::LinkEnabled,
+            AudioFocus::LinkEnabled => AudioFocus::StartStopSync,
+            AudioFocus::StartStopSync => AudioFocus::Quantum,
+            AudioFocus::Quantum => AudioFocus::OutputDevice,
+        };
+    }
+
+    pub fn prev_focus(&mut self) {
+        self.focus = match self.focus {
+            AudioFocus::OutputDevice => AudioFocus::Quantum,
+            AudioFocus::InputDevice => AudioFocus::OutputDevice,
+            AudioFocus::Channels => AudioFocus::InputDevice,
+            AudioFocus::BufferSize => AudioFocus::Channels,
+            AudioFocus::RefreshRate => AudioFocus::BufferSize,
+            AudioFocus::RuntimeHighlight => AudioFocus::RefreshRate,
+            AudioFocus::SamplePaths => AudioFocus::RuntimeHighlight,
+            AudioFocus::LinkEnabled => AudioFocus::SamplePaths,
+            AudioFocus::StartStopSync => AudioFocus::LinkEnabled,
+            AudioFocus::Quantum => AudioFocus::StartStopSync,
+        };
+    }
+
+    pub fn next_output_device(&mut self) {
+        if self.output_devices.is_empty() {
+            return;
+        }
+        let current_idx = self.current_output_device_index();
+        let next_idx = (current_idx + 1) % self.output_devices.len();
+        self.config.output_device = Some(self.output_devices[next_idx].name.clone());
+    }
+
+    pub fn prev_output_device(&mut self) {
+        if self.output_devices.is_empty() {
+            return;
+        }
+        let current_idx = self.current_output_device_index();
+        let prev_idx = (current_idx + self.output_devices.len() - 1) % self.output_devices.len();
+        self.config.output_device = Some(self.output_devices[prev_idx].name.clone());
+    }
+
+    fn current_output_device_index(&self) -> usize {
+        match &self.config.output_device {
+            Some(name) => self
+                .output_devices
+                .iter()
+                .position(|d| &d.name == name)
+                .unwrap_or(0),
+            None => self
+                .output_devices
+                .iter()
+                .position(|d| d.is_default)
+                .unwrap_or(0),
+        }
+    }
+
+    pub fn next_input_device(&mut self) {
+        if self.input_devices.is_empty() {
+            return;
+        }
+        let current_idx = self.current_input_device_index();
+        let next_idx = (current_idx + 1) % self.input_devices.len();
+        self.config.input_device = Some(self.input_devices[next_idx].name.clone());
+    }
+
+    pub fn prev_input_device(&mut self) {
+        if self.input_devices.is_empty() {
+            return;
+        }
+        let current_idx = self.current_input_device_index();
+        let prev_idx = (current_idx + self.input_devices.len() - 1) % self.input_devices.len();
+        self.config.input_device = Some(self.input_devices[prev_idx].name.clone());
+    }
+
+    fn current_input_device_index(&self) -> usize {
+        match &self.config.input_device {
+            Some(name) => self
+                .input_devices
+                .iter()
+                .position(|d| &d.name == name)
+                .unwrap_or(0),
+            None => self
+                .input_devices
+                .iter()
+                .position(|d| d.is_default)
+                .unwrap_or(0),
+        }
+    }
+
+    pub fn adjust_channels(&mut self, delta: i16) {
+        let new_val = (self.config.channels as i16 + delta).clamp(1, 64) as u16;
+        self.config.channels = new_val;
+    }
+
+    pub fn adjust_buffer_size(&mut self, delta: i32) {
+        let new_val = (self.config.buffer_size as i32 + delta).clamp(64, 4096) as u32;
+        self.config.buffer_size = new_val;
+    }
+
+    pub fn toggle_refresh_rate(&mut self) {
+        self.config.refresh_rate = self.config.refresh_rate.toggle();
+    }
+
+    pub fn current_output_device_name(&self) -> &str {
+        match &self.config.output_device {
+            Some(name) => name,
+            None => self
+                .output_devices
+                .iter()
+                .find(|d| d.is_default)
+                .map(|d| d.name.as_str())
+                .unwrap_or("Default"),
+        }
+    }
+
+    pub fn current_input_device_name(&self) -> &str {
+        match &self.config.input_device {
+            Some(name) => name,
+            None => self
+                .input_devices
+                .iter()
+                .find(|d| d.is_default)
+                .map(|d| d.name.as_str())
+                .unwrap_or("None"),
+        }
+    }
+
+    pub fn add_sample_path(&mut self, path: PathBuf) {
+        if !self.config.sample_paths.contains(&path) {
+            self.config.sample_paths.push(path);
+        }
+    }
+
+    pub fn remove_last_sample_path(&mut self) {
+        self.config.sample_paths.pop();
+    }
+
+    pub fn trigger_restart(&mut self) {
+        self.restart_pending = true;
+    }
+}