valentine

metermap.rs (4846B)

---

 //! Meter-map probe v2 (read-only). Two parts:
 //!   1. Prints your full decoded routing (sink ← source) so we can see where
 //!      each physical input (esp. ADAT) is actually routed.
 //!   2. Peak-holds all 65 raw GET_METER indices over ~12s and prints each with
 //!      its destination + the source currently routed there — so when you feed a
 //!      specific input we can see EXACTLY which raw index moves and how high
 //!      (for both channel mapping AND full-scale calibration vs your DAW).
 //!
 //! Run with Focusrite Control quit:  cargo run -p spike --bin metermap
 //! Feed ONE input you can name (e.g. ADAT 1) the whole time. Reads only.
 
 use scarlett_core::model::{PortType, S18I20_GEN3};
 use scarlett_core::ports::{sink_name, source_name};
 use scarlett_core::{Scarlett, UsbTransport};
 
 fn main() {
     if let Err(e) = run() {
         eprintln!("\x1b[31mMETERMAP FAILED:\x1b[0m {e}");
         eprintln!("(If access/busy: quit Focusrite Control first.)");
         std::process::exit(1);
     }
 }
 
 /// Destination index → human label, in the gen3c destination numbering
 /// (Analogue Out 1-10, S/PDIF Out 1-2, ADAT Out 1-8, Mixer In 1-25, PCM cap 1-20).
 fn dest_label(d: usize) -> String {
     let an = S18I20_GEN3.port_count(PortType::Analogue).1 as usize; // 10
     let sp = S18I20_GEN3.port_count(PortType::Spdif).1 as usize; // 2
     let ad = S18I20_GEN3.port_count(PortType::Adat).1 as usize; // 8
     let mx = S18I20_GEN3.port_count(PortType::Mix).1 as usize; // 25
     let mut base = 0;
     if d < base + an {
         return format!("AnalogueOut {}", d - base + 1);
     }
     base += an;
     if d < base + sp {
         return format!("S/PDIF Out {}", d - base + 1);
     }
     base += sp;
     if d < base + ad {
         return format!("ADAT Out {}", d - base + 1);
     }
     base += ad;
     if d < base + mx {
         return format!("MixerIn {}", d - base + 1);
     }
     base += mx;
     format!("PCM cap {}", d - base + 1)
 }
 
 fn run() -> Result<(), Box<dyn std::error::Error>> {
     let mut dev = Scarlett::new(UsbTransport::open_default()?);
     dev.init()?;
     println!("connected: {}\n", S18I20_GEN3.name);
 
     // --- Part 1: full routing, decoded ---
     let num_dsts = S18I20_GEN3.mux_dst_count();
     let mux = dev.get_mux(num_dsts)?;
     println!("=== ROUTING (sink ← source), non-Off only ===");
     for e in &mux {
         if e.source != 0 {
             println!(
                 "  {:<16} ← {:<16}  (dest hw {:#05x} / src hw {:#05x})",
                 sink_name(e.dest),
                 source_name(e.source),
                 e.dest,
                 e.source
             );
         }
     }
 
     // --- Part 2: peak-hold every raw index over ~12s while you feed an input ---
     let n = S18I20_GEN3.meter_count as usize;
     let mut peak = vec![0u32; n];
     println!("\n=== Feed ONE input now. Holding peaks for ~12s… ===");
     // ~12s: 60 reads with 4 throwaway reads between each as a crude delay.
     for _ in 0..60 {
         let raw = dev.get_meters(S18I20_GEN3.meter_count)?;
         for (i, &v) in raw.iter().enumerate() {
             if v > peak[i] {
                 peak[i] = v;
             }
         }
         for _ in 0..6 {
             let _ = dev.get_meters(4);
         }
     }
 
     // Print every raw index that saw signal, with which destination it is and
     // what source is routed there — sorted by peak descending.
     println!("\n=== RAW INDICES THAT MOVED (peak desc) ===");
     // raw index i corresponds to the i-th destination in meter_map order; we
     // reconstruct that destination list to label each raw index.
     let meter_map: [(u16, u16); 5] = [(45, 8), (55, 10), (0, 20), (53, 2), (20, 25)];
     let mut raw_to_dest = Vec::with_capacity(n);
     for (start, count) in meter_map {
         for j in 0..count {
             raw_to_dest.push((start + j) as usize);
         }
     }
     // source routed to a dest (for labeling), from the mux table
     let mut src_at = vec![0u16; num_dsts];
     for e in &mux {
         if (e.dest as usize) < src_at.len() {
             src_at[e.dest as usize] = e.source;
         }
     }
 
     let mut rows: Vec<(u32, usize, usize)> = peak
         .iter()
         .enumerate()
         .filter(|(_, &p)| p > 20)
         .map(|(i, &p)| (p, i, raw_to_dest.get(i).copied().unwrap_or(usize::MAX)))
         .collect();
     rows.sort_by(|a, b| b.0.cmp(&a.0));
 
     for (p, raw_i, dest) in rows {
         let src = src_at.get(dest).copied().unwrap_or(0);
         let src_txt = if src == 0 { "(off/none)".to_string() } else { source_name(src) };
         let dlabel = if dest == usize::MAX { "?".to_string() } else { dest_label(dest) };
         println!(
             "  raw{raw_i:>2}  peak {p:>5}  dest{dest:>2} {dlabel:<16}  source: {src_txt}"
         );
     }
 
     println!("\nMETERMAP DONE (read-only). Tell me which input you fed.");
     Ok(())
 }