valentine

adatset.rs (3205B)

---

 //! Persisting ADAT attenuation test. Sets the ADAT monitor group to a given dB
 //! via the exact TUI path (route via mixer + set_group_level) and LEAVES it
 //! there so you can listen. This isolates "does the bus write audibly change
 //! ADAT?" from all TUI plumbing.
 //!
 //!   cargo run -p spike --bin adatset -- -40     # quiet it, listen
 //!   cargo run -p spike --bin adatset -- 0       # back to unity (via mixer)
 //!   cargo run -p spike --bin adatset -- direct  # restore ADAT ← PCM direct
 //!
 //! Run with Focusrite Control quit.
 
 use scarlett_core::matrix::MonitorGroup;
 use scarlett_core::model::S18I20_GEN3;
 use scarlett_core::mux::PORT_COUNT_18I20_GEN3;
 use scarlett_core::{Scarlett, UsbTransport};
 
 fn main() {
     if let Err(e) = run() {
         eprintln!("\x1b[31mADATSET FAILED:\x1b[0m {e}");
         std::process::exit(1);
     }
 }
 
 fn adat() -> &'static MonitorGroup {
     scarlett_core::matrix::MONITOR_GROUPS
         .iter()
         .find(|g| g.name.starts_with("ADAT"))
         .unwrap()
 }
 
 fn run() -> Result<(), Box<dyn std::error::Error>> {
     let arg = std::env::args().nth(1).unwrap_or_else(|| "-40".into());
     let mut dev = Scarlett::new(UsbTransport::open_default()?);
     dev.init()?;
     let pc = PORT_COUNT_18I20_GEN3;
     let g = adat();
     let inputs = S18I20_GEN3.mixer_inputs() as usize;
 
     if arg == "direct" {
         dev.route_group_direct(pc, g)?;
         println!("ADAT restored to direct-from-DAW (ADAT Out ← PCM 13-20). Listen.");
         return Ok(());
     }
 
     let db: f32 = arg.parse().map_err(|_| "pass a dB number, or 'direct'")?;
     println!("Routing ADAT via mixer and setting level to {db} dB (persisting)…");
 
     // Write the 3 sample-rate-band tables SEPARATELY to see which one fails.
     use scarlett_core::mux::{id_to_num, mux_assignment_18i20_gen3, num_dsts, Dir, MuxState};
     let n = |dir, id| id_to_num(&pc, dir, id).unwrap_or(0);
     let entries = dev.get_mux(num_dsts(&pc))?;
     let mut st = MuxState::from_entries(pc, &entries);
     for i in 0..g.count {
         st.set(n(Dir::Out, 0x300 + g.mix_in_base + i), n(Dir::In, 0x600 + g.pcm_base + i));
         st.set(n(Dir::Out, g.out_id_base + i), n(Dir::In, 0x300 + g.bus_base + i));
     }
     let tables = st.encode_all(&mux_assignment_18i20_gen3());
     for (i, t) in tables.iter().enumerate() {
         match dev.write_routing_table(i as u16, t) {
             Ok(()) => println!("  table {i} ({} entries): OK", t.len()),
             Err(e) => println!("  table {i} ({} entries): FAILED — {e}", t.len()),
         }
     }
     if let Err(e) = dev.set_group_level(g, db, inputs) {
         println!("  set_group_level: FAILED — {e}");
     } else {
         println!("  set_group_level: OK");
     }
 
     // Read back so we report the truth.
     let raw = dev.get_mix(g.bus_base, inputs)?;
     let got = scarlett_core::matrix::mixer_value_to_db(
         raw.get(g.mix_in_base as usize).copied().unwrap_or(0),
     );
     println!("done. Mix bus {} input {} now reads {got:.1} dB.", g.bus_base, g.mix_in_base + 1);
     println!("\n>>> LISTEN NOW: did your ADAT monitoring get quieter? <<<");
     println!("(restore with: cargo run -p spike --bin adatset -- direct)");
     Ok(())
 }