diff --git a/tek/src/lib.rs b/tek/src/lib.rs index 7c27ccc0..89857ac4 100644 --- a/tek/src/lib.rs +++ b/tek/src/lib.rs @@ -151,9 +151,12 @@ impl TekCli { pub keys_scene: SourceIter<'static>, pub keys_mix: SourceIter<'static>, - pub fmt_beat: RwLock, - pub fmt_time: RwLock, - pub fmt_bpm: RwLock, + pub fmtd_beat: Arc>, + pub fmtd_time: Arc>, + pub fmtd_bpm: Arc>, + pub fmtd_sr: Arc>, + pub fmtd_buf: Arc>, + pub fmtd_lat: Arc>, } has_size!(|self: Tek|&self.size); has_clock!(|self: Tek|self.clock); @@ -229,9 +232,12 @@ impl Tek { keys_track: SourceIter(KEYS_TRACK), keys_scene: SourceIter(KEYS_SCENE), keys_mix: SourceIter(KEYS_MIX), - fmt_beat: String::with_capacity(16).into(), - fmt_time: String::with_capacity(16).into(), - fmt_bpm: String::with_capacity(16).into(), + fmtd_beat: Arc::new(RwLock::new(String::with_capacity(16))), + fmtd_time: Arc::new(RwLock::new(String::with_capacity(16))), + fmtd_bpm: Arc::new(RwLock::new(String::with_capacity(16))), + fmtd_sr: Arc::new(RwLock::new(String::with_capacity(16))), + fmtd_buf: Arc::new(RwLock::new(String::with_capacity(16))), + fmtd_lat: Arc::new(RwLock::new(String::with_capacity(16))), ..Default::default() }; tek.sync_lead(sync_lead); @@ -383,47 +389,57 @@ impl Tek { let compact = self.size.w() > 80; let clock = self.clock(); let delta = |start: &Moment|clock.global.usec.get() - start.usec.get(); - let mut fmt_beat = self.fmt_beat.write().unwrap(); - let mut fmt_time = self.fmt_time.write().unwrap(); - let mut fmt_bpm = self.fmt_bpm.write().unwrap(); - fmt_beat.clear(); - fmt_time.clear(); - fmt_bpm.clear(); + let mut fmtd_beat = self.fmtd_beat.write().unwrap(); + let mut fmtd_time = self.fmtd_time.write().unwrap(); + let mut fmtd_bpm = self.fmtd_bpm.write().unwrap(); + fmtd_beat.clear(); + fmtd_time.clear(); + fmtd_bpm.clear(); if let Some(now) = clock.started.read().unwrap().as_ref().map(delta) { - clock.timebase.format_beats_1_to(&mut*fmt_beat, clock.timebase.usecs_to_pulse(now)); - write!(&mut fmt_time, "{:.3}s", now/1000000.); - write!(&mut fmt_bpm, "{:.3}", clock.timebase.bpm.get()); + clock.timebase.format_beats_1_to(&mut*fmtd_beat, clock.timebase.usecs_to_pulse(now)); + write!(&mut fmtd_time, "{:.3}s", now/1000000.); + write!(&mut fmtd_bpm, "{:.3}", clock.timebase.bpm.get()); } else { - write!(&mut fmt_beat, "-.-.--"); - write!(&mut fmt_time, "-.---s"); - write!(&mut fmt_bpm, "---.---"); + write!(&mut fmtd_beat, "-.-.--"); + write!(&mut fmtd_time, "-.---s"); + write!(&mut fmtd_bpm, "---.---"); } let theme = ItemPalette::G[128]; Thunk::new(move||Either::new(compact, - row!(FieldH(theme, "BPM", self.fmt_bpm.read().unwrap()), - FieldH(theme, "Beat", self.fmt_beat.read().unwrap()), - FieldH(theme, "Time", self.fmt_time.read().unwrap())), - row!(FieldV(theme, "BPM", self.fmt_bpm.read().unwrap()), - FieldV(theme, "Beat", self.fmt_beat.read().unwrap()), - FieldV(theme, "Time", self.fmt_time.read().unwrap())))) + row!(FieldH(theme, "BPM", self.fmtd_bpm.clone()), + FieldH(theme, "Beat", self.fmtd_beat.clone()), + FieldH(theme, "Time", self.fmtd_time.clone())), + row!(FieldV(theme, "BPM", self.fmtd_bpm.clone()), + FieldV(theme, "Beat", self.fmtd_beat.clone()), + FieldV(theme, "Time", self.fmtd_time.clone())))) } fn view_engine_stats (&self) -> impl Content + use<'_> { let compact = self.size.w() > 80; let clock = self.clock(); let rate = clock.timebase.sr.get(); let chunk = clock.chunk.load(Relaxed); - let sr = move||format!("{}", if compact {format!("{:.1}kHz", rate / 1000.)} else {format!("{:.0}Hz", rate)}); - let buf = move||format!("{chunk}"); - let latency = move||format!("{:.1}ms", chunk as f64 / rate * 1000.); - let theme = ItemPalette::G[128]; + let mut fmtd_sr = self.fmtd_sr.write().unwrap(); + let mut fmtd_buf = self.fmtd_buf.write().unwrap(); + let mut fmtd_lat = self.fmtd_lat.write().unwrap(); + fmtd_sr.clear(); + write!(&mut fmtd_sr, "{}", if compact {format!("{:.1}kHz", rate / 1000.)} else {format!("{:.0}Hz", rate)}); + fmtd_buf.clear(); + write!(&mut fmtd_buf, "{chunk}"); + fmtd_lat.clear(); + write!(&mut fmtd_lat, "{:.1}ms", chunk as f64 / rate * 1000.); + let theme = ItemPalette::G[128]; Either::new(compact, - row!(FieldH(theme, "SR", sr()), FieldH(theme, "Buf", buf()), FieldH(theme, "Lat", latency())), - row!(FieldV(theme, "SR", sr()), FieldV(theme, "Buf", buf()), FieldV(theme, "Lat", latency()))) + row!(FieldH(theme, "SR", self.fmtd_sr.clone()), + FieldH(theme, "Buf", self.fmtd_buf.clone()), + FieldH(theme, "Lat", self.fmtd_lat.clone())), + row!(FieldV(theme, "SR", self.fmtd_sr.clone()), + FieldV(theme, "Buf", self.fmtd_buf.clone()), + FieldV(theme, "Lat", self.fmtd_lat.clone()))) } fn view_meter <'a> (&'a self, label: &'a str, value: f32) -> impl Content + 'a { col!( FieldH(ItemPalette::G[128], label, format!("{:>+9.3}", value)), - Fixed::xy(if value >= 0.0 { 13 } + Fixed::xy(if value >= 0.0 { 13 } else if value >= -1.0 { 12 } else if value >= -2.0 { 11 } else if value >= -3.0 { 10 } diff --git a/tui/src/tui_content.rs b/tui/src/tui_content.rs index 719a83b3..118650d4 100644 --- a/tui/src/tui_content.rs +++ b/tui/src/tui_content.rs @@ -20,6 +20,24 @@ impl Content for String { } } +impl> Content for std::sync::Arc { + fn layout (&self, to: [u16;4]) -> [u16;4] { + Content::::layout(&**self, to) + } + fn render (&self, to: &mut TuiOut) { + Content::::render(&**self, to) + } +} + +impl Content for std::sync::RwLock { + fn layout (&self, to: [u16;4]) -> [u16;4] { + Content::::layout(&self.read().unwrap(), to) + } + fn render (&self, to: &mut TuiOut) { + Content::::render(&self.read().unwrap(), to) + } +} + impl Content for std::sync::RwLockReadGuard<'_, String> { fn layout (&self, to: [u16;4]) -> [u16;4] { Content::::layout(&**self, to)