valentine

sources.rs (6684B)

---

 //! The full catalog of input *sources* on the device — every signal that can be
 //! metered, named, faded into the monitor mix, and routed: analogue preamps,
 //! ADAT, S/PDIF, and the DAW (PCM) returns.
 //!
 //! The old Inputs page only listed the 8 analogue preamps, so ADAT/SPDIF/PCM
 //! sources were invisible. This module is the single source of truth for "what
 //! inputs exist and what each can do", built from the device descriptor.
 
 use crate::model::{DeviceInfo, PortType};
 
 /// One input source: its kind, zero-based index within that kind, and which
 /// preamp features it supports (only analogue preamps have these).
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Source {
     pub kind: PortType,
     /// 0-based index within the kind (analogue 0 = "Analogue 1").
     pub index: u16,
     /// Default display name, e.g. "Analogue 1", "ADAT 3", "PCM 12".
     pub name: String,
     /// Preamp capabilities (false for everything except analogue preamps).
     pub has_air: bool,
     pub has_pad: bool,
     pub has_inst: bool,
     /// 48 V phantom group this source belongs to, if any (analogue only).
     pub phantom_group: Option<u8>,
 }
 
 impl Source {
     /// True if this source has any preamp switch worth showing.
     pub fn has_preamp(&self) -> bool {
         self.has_air || self.has_pad || self.has_inst || self.phantom_group.is_some()
     }
 
     /// The device hardware ID for this source (kind base | index), matching the
     /// mux/routing encoding. Used to find where the source is routed.
     pub fn hw_id(&self) -> u16 {
         let base = match self.kind {
             PortType::Analogue => 0x080,
             PortType::Spdif => 0x180,
             PortType::Adat => 0x200,
             PortType::Mix => 0x300,
             PortType::Pcm => 0x600,
         };
         base | self.index
     }
 }
 
 fn kind_word(kind: PortType) -> &'static str {
     match kind {
         PortType::Analogue => "Analogue",
         PortType::Spdif => "S/PDIF",
         PortType::Adat => "ADAT",
         PortType::Pcm => "PCM",
         PortType::Mix => "Mix",
     }
 }
 
 /// Build the ordered source catalog for a device: analogue (incl. talkback as
 /// the last analogue), then ADAT, S/PDIF, then PCM/DAW returns.
 pub fn catalog(info: &DeviceInfo) -> Vec<Source> {
     let mut out = Vec::new();
 
     // Analogue sources (the descriptor's analogue *source* count includes the
     // talkback mic as the last one on the 18i20 g3).
     let analogue_srcs = info.port_count(PortType::Analogue).0 as u16;
     for i in 0..analogue_srcs {
         let is_talkback = info.has_talkback && i + 1 == analogue_srcs;
         let name = if is_talkback {
             "Talkback".to_string()
         } else {
             format!("Analogue {}", i + 1)
         };
         out.push(Source {
             kind: PortType::Analogue,
             index: i,
             name,
             has_air: i < info.air_input_count as u16 && !is_talkback,
             has_pad: i < info.pad_input_count as u16 && !is_talkback,
             has_inst: i < info.level_input_count as u16 && !is_talkback,
             phantom_group: if !is_talkback && info.inputs_per_phantom > 0 {
                 let g = (i / info.inputs_per_phantom as u16) as u8;
                 (g < info.phantom_count).then_some(g)
             } else {
                 None
             },
         });
     }
 
     // ADAT, then S/PDIF, then PCM — meter/route/name only, no preamp.
     for kind in [PortType::Adat, PortType::Spdif, PortType::Pcm] {
         let n = info.port_count(kind).0 as u16;
         for i in 0..n {
             out.push(Source {
                 kind,
                 index: i,
                 name: format!("{} {}", kind_word(kind), i + 1),
                 has_air: false,
                 has_pad: false,
                 has_inst: false,
                 phantom_group: None,
             });
         }
     }
 
     out
 }
 
 /// A stereo pairing of catalog entries: consecutive odd/even within the same
 /// kind (1-2, 3-4 …). An odd trailing source becomes a mono pair.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Pair {
     pub left: usize,
     /// `None` for a leftover mono source (or talkback).
     pub right: Option<usize>,
 }
 
 /// Group catalog indices into stereo pairs by kind. Talkback stays mono.
 pub fn stereo_pairs(catalog: &[Source]) -> Vec<Pair> {
     let mut pairs = Vec::new();
     let mut i = 0;
     while i < catalog.len() {
         let a = &catalog[i];
         let mono = a.name == "Talkback";
         if !mono
             && i + 1 < catalog.len()
             && catalog[i + 1].kind == a.kind
             && a.index % 2 == 0
             && catalog[i + 1].index == a.index + 1
         {
             pairs.push(Pair { left: i, right: Some(i + 1) });
             i += 2;
         } else {
             pairs.push(Pair { left: i, right: None });
             i += 1;
         }
     }
     pairs
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::model::S18I20_GEN3;
 
     #[test]
     fn catalog_includes_adat_spdif_pcm_not_just_analogue() {
         let c = catalog(&S18I20_GEN3);
         let kinds: std::collections::HashSet<_> = c.iter().map(|s| s.kind).collect();
         assert!(kinds.contains(&PortType::Analogue));
         assert!(kinds.contains(&PortType::Adat)); // the user's missing inputs
         assert!(kinds.contains(&PortType::Spdif));
         assert!(kinds.contains(&PortType::Pcm));
         // 9 analogue + 8 adat + 2 spdif + 20 pcm = 39
         assert_eq!(c.len(), 9 + 8 + 2 + 20);
     }
 
     #[test]
     fn talkback_is_last_analogue_and_has_no_preamp() {
         let c = catalog(&S18I20_GEN3);
         let tb = c.iter().find(|s| s.name == "Talkback").unwrap();
         assert_eq!(tb.kind, PortType::Analogue);
         assert!(!tb.has_preamp());
     }
 
     #[test]
     fn analogue_1_has_full_preamp_adat_has_none() {
         let c = catalog(&S18I20_GEN3);
         let a1 = &c[0];
         assert_eq!(a1.name, "Analogue 1");
         assert!(a1.has_air && a1.has_pad && a1.has_inst);
         assert_eq!(a1.phantom_group, Some(0));
 
         let adat = c.iter().find(|s| s.kind == PortType::Adat).unwrap();
         assert!(!adat.has_preamp());
     }
 
     #[test]
     fn stereo_pairs_group_odd_even_within_kind() {
         let c = catalog(&S18I20_GEN3);
         let pairs = stereo_pairs(&c);
         // Analogue 1-2 should be a stereo pair.
         let first = &pairs[0];
         assert_eq!(c[first.left].name, "Analogue 1");
         assert_eq!(first.right.map(|r| c[r].name.clone()), Some("Analogue 2".into()));
         // Talkback (9th analogue, odd one out) must be mono.
         let tb_pair = pairs.iter().find(|p| c[p.left].name == "Talkback").unwrap();
         assert_eq!(tb_pair.right, None);
     }
 }