valentine

preset.rs (7075B)

---

 //! Presets — capture the device's user-settable state to a serializable snapshot,
 //! and apply one back. This powers "save/load a configuration" in the TUI and is
 //! independent of the device's own standalone (NVRAM) save.
 //!
 //! What's captured: the per-input switches (Air / Pad / Inst), the 48 V phantom
 //! groups, the monitor Mute / Dim, and the full mixer matrix. **Not** captured:
 //! the master monitor level (it's read-only — owned by the hardware knob) and
 //! routing (edit path isn't validated yet). Applying only writes fields present,
 //! so older/newer presets degrade gracefully.
 
 use serde::{Deserialize, Serialize};
 
 use crate::controls::{InputState, InputSwitch, MonitorButton, MonitorState};
 use crate::matrix::db_to_mixer_value;
 use crate::protocol::Scarlett;
 use crate::transport::{Transport, TransportError};
 
 /// Snapshot format version, so future readers can adapt.
 pub const PRESET_VERSION: u32 = 1;
 
 /// A saved device configuration.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Preset {
     pub version: u32,
     /// Free-text label shown in the UI.
     pub name: String,
     /// Device product id this was captured from (sanity check on load).
     pub pid: u16,
     pub air: Vec<bool>,
     pub pad: Vec<bool>,
     pub inst: Vec<bool>,
     pub phantom: Vec<bool>,
     pub mute: bool,
     pub dim: bool,
     /// Mixer matrix as `[bus][input]` in dB.
     pub mixer: Vec<Vec<f32>>,
     /// Full routing as a flat `mux[dest_num] = source_num` array (port numbers).
     /// Empty in older presets; when present, applying restores routing too.
     #[serde(default)]
     pub routing: Vec<u16>,
 }
 
 impl Preset {
     /// Build a preset from already-read state (no device I/O). `routing` is the
     /// flat `mux[dest]=src` port-number array (empty = don't capture routing).
     pub fn from_state(
         name: impl Into<String>,
         pid: u16,
         inputs: &InputState,
         monitor: &MonitorState,
         mixer: &[Vec<f32>],
         routing: &[u16],
     ) -> Self {
         Preset {
             version: PRESET_VERSION,
             name: name.into(),
             pid,
             air: inputs.air.clone(),
             pad: inputs.pad.clone(),
             inst: inputs.inst.clone(),
             phantom: inputs.phantom.clone(),
             mute: monitor.mute,
             dim: monitor.dim,
             mixer: mixer.to_vec(),
             routing: routing.to_vec(),
         }
     }
 
     /// Serialize to pretty JSON (human-editable on disk).
     pub fn to_json(&self) -> String {
         serde_json::to_string_pretty(self).unwrap_or_default()
     }
 
     /// Parse from JSON.
     pub fn from_json(s: &str) -> Result<Self, serde_json::Error> {
         serde_json::from_str(s)
     }
 }
 
 impl<T: Transport> Scarlett<T> {
     /// Apply a preset to the device. Writes each switch + activates, sets phantom
     /// groups, monitor mute/dim, and every mixer crosspoint. Returns the number
     /// of device writes performed (useful for a status line).
     pub fn apply_preset(&mut self, p: &Preset) -> Result<usize, TransportError> {
         let mut writes = 0;
 
         for (i, &on) in p.air.iter().enumerate() {
             self.set_input_switch(InputSwitch::Air, i as u8, on)?;
             writes += 1;
         }
         for (i, &on) in p.pad.iter().enumerate() {
             self.set_input_switch(InputSwitch::Pad, i as u8, on)?;
             writes += 1;
         }
         for (i, &on) in p.inst.iter().enumerate() {
             self.set_input_switch(InputSwitch::Inst, i as u8, on)?;
             writes += 1;
         }
         for (g, &on) in p.phantom.iter().enumerate() {
             self.set_phantom(g as u8, on)?;
             writes += 1;
         }
 
         self.set_monitor_button(MonitorButton::Mute, p.mute)?;
         self.set_monitor_button(MonitorButton::Dim, p.dim)?;
         writes += 2;
 
         for (bus, inputs) in p.mixer.iter().enumerate() {
             let levels: Vec<u16> = inputs.iter().map(|&db| db_to_mixer_value(db)).collect();
             if !levels.is_empty() {
                 self.set_mix(bus as u16, &levels)?;
                 writes += 1;
             }
         }
 
         // Routing last, as one atomic write (the big visible change).
         if !p.routing.is_empty() {
             use crate::mux::{mux_assignment_18i20_gen3, MuxState, PORT_COUNT_18I20_GEN3};
             let pc = PORT_COUNT_18I20_GEN3;
             let state = MuxState { pc, mux: p.routing.clone() };
             let tables = state.encode_all(&mux_assignment_18i20_gen3());
             self.write_routing_tables(&tables)?;
             writes += 1;
         }
 
         Ok(writes)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::protocol::op;
     use crate::transport::mock::MockTransport;
 
     fn sample() -> Preset {
         Preset {
             version: PRESET_VERSION,
             name: "Vocal chain".into(),
             pid: 0x8215,
             air: vec![true, false],
             pad: vec![false],
             inst: vec![true],
             phantom: vec![true, false],
             mute: false,
             dim: true,
             mixer: vec![vec![0.0, -6.0]],
             routing: vec![],
         }
     }
 
     #[test]
     fn json_round_trips() {
         let p = sample();
         let json = p.to_json();
         let back = Preset::from_json(&json).unwrap();
         assert_eq!(p, back);
         assert!(json.contains("\"name\": \"Vocal chain\""));
     }
 
     #[test]
     fn from_state_captures_fields() {
         let inputs = InputState {
             air: vec![true, true],
             pad: vec![false, false],
             inst: vec![false, true],
             phantom: vec![true, false],
         };
         let mon = MonitorState { master_db: -3, mute: true, dim: false };
         let mixer = vec![vec![0.0, 0.0]];
         let p = Preset::from_state("test", 0x8215, &inputs, &mon, &mixer, &[]);
         assert_eq!(p.air, vec![true, true]);
         assert_eq!(p.inst, vec![false, true]);
         assert!(p.mute);
         assert_eq!(p.pid, 0x8215);
         // master volume is intentionally not stored (read-only hardware knob)
     }
 
     #[test]
     fn apply_preset_writes_and_activates() {
         // apply_preset interleaves set_data/activate/set_mix; an echoing mock
         // returns a matching empty success for each, so we just assert the count
         // of high-level writes and that the right commands were emitted.
         let mut dev = Scarlett::new(MockTransport::echoing());
         let writes = dev.apply_preset(&sample()).unwrap();
         // 2 air + 1 pad + 1 inst + 2 phantom + 2 monitor + 1 mixer bus = 9
         assert_eq!(writes, 9);
 
         let m = dev.into_transport();
         let set_mix = m.sent.iter().filter(|(c, _)| *c == op::SET_MIX).count();
         let set_data = m.sent.iter().filter(|(c, _)| *c == op::SET_DATA).count();
         assert_eq!(set_mix, 1); // one mixer bus
         // SET_DATA = 2 air + 1 pad + 1 inst + 2 phantom + 2 monitor(mute,dim) = 8
         // (phantom and monitor buttons are byte writes via set_data too)
         assert_eq!(set_data, 8);
     }
 }