fix: make block-driven events audio-driven so that they are consistent across framerates, etc.

Signed-off-by: Maika Namuo <httpworldview@gmail.com>

Author: httpsworldview

src/dsp.rs

@@ -234,6 +234,10 @@ impl<'a> AudioBlock<'a> {
         self.samples.len() / self.channels
     }
 
+    pub fn duration(&self) -> f32 {
+        self.frame_count() as f32 / self.sample_rate
+    }
+
     pub fn stereo_frames(
         &self,
     ) -> impl ExactSizeIterator<Item = [f32; 2]> + DoubleEndedIterator + '_ {

src/persistence/visuals.rs

@@ -214,16 +214,23 @@ visual_configs! {
     Stereometer(StereometerSettings),
 }
 
-fn finite_averaging_or(value: AveragingMode, default: AveragingMode) -> AveragingMode {
-    let parameter = match value {
-        AveragingMode::None => return value,
-        AveragingMode::Exponential { factor } => factor,
-        AveragingMode::PeakHold { decay_per_second } => decay_per_second,
-    };
-    if parameter.is_finite() {
-        value
-    } else {
-        default
+// Bounds hand-edited settings so new input keeps showing.
+const MAX_TIME_CONSTANT: f32 = 10.0;
+
+fn time_constant_or(value: f32, default: f32) -> f32 {
+    finite_or(value, default).clamp(0.0, MAX_TIME_CONSTANT)
+}
+
+fn averaging_or(value: AveragingMode, default: AveragingMode) -> AveragingMode {
+    match value {
+        AveragingMode::None => value,
+        AveragingMode::Exponential { time_constant } if time_constant.is_finite() => {
+            AveragingMode::Exponential {
+                time_constant: time_constant.clamp(0.0, MAX_TIME_CONSTANT),
+            }
+        }
+        AveragingMode::PeakHold { decay_per_second } if decay_per_second.is_finite() => value,
+        _ => default,
     }
 }
 
@@ -273,7 +280,7 @@ visual_settings!(OscilloscopeSettings from OscilloscopeConfig {
     segment_duration: f32 => finite_or, trigger_mode: TriggerMode, trigger_source: Channel,
     channel_1: Channel, channel_2: Channel,
 } extra {
-    persistence: f32 = 0.0 => finite_or,
+    persistence_time_constant: f32 = 0.0 => time_constant_or,
     stacked: bool = false,
 });
 
@@ -289,7 +296,7 @@ visual_settings!(WaveformSettings from WaveformConfig {
 
 visual_settings!(SpectrumSettings from SpectrumConfig {
     fft_size: usize, hop_size: usize, window: WindowKind,
-    averaging: AveragingMode => finite_averaging_or,
+    averaging: AveragingMode => averaging_or,
     source: Channel, secondary_source: Channel, floor_db: f32 => sanitize_negative_db,
 } extra {
     frequency_scale: FrequencyScale = FrequencyScale::Logarithmic,
@@ -315,7 +322,7 @@ visual_settings!(SpectrogramSettings from SpectrogramConfig {
 
 visual_settings!(StereometerSettings from StereometerConfig {
     segment_duration: f32 => finite_or, target_sample_count: usize,
-    correlation_window: f32 => finite_or,
+    correlation_window: f32 => time_constant_or,
 } extra {
     dot_radius: f32 = 1.0 => finite_or, mode: StereometerMode = StereometerMode::default(),
     scale: StereometerScale = StereometerScale::default(), rotation: i8 = -1, flip: bool = true,

src/ui/settings/oscilloscope.rs

@@ -46,7 +46,7 @@ impl fmt::Display for TriggerSourceChoice {
 
 settings_messages!(pane, settings, value {
     SegmentDuration(f32) => set_f32(&mut settings.segment_duration, value);
-    Persistence(f32) => set_f32(&mut settings.persistence, value);
+    Persistence(f32) => set_f32(&mut settings.persistence_time_constant, value);
     Preset(TriggerPreset) => {
         let mode = match value {
             TriggerPreset::Stable => TriggerMode::Stable { num_cycles: pane.num_cycles },
@@ -101,7 +101,10 @@ settings_view! {
     "Trigger" => trigger;
     "Display" => form!(
         toggle("Stacked", settings.stacked, Stacked);
-        slider!("Persistence", settings.persistence, PERSISTENCE_RANGE, Persistence, "{:.2}");
+        slider!(
+            "Persistence", settings.persistence_time_constant, PERSISTENCE_RANGE, Persistence,
+            format!("{:.0} ms", settings.persistence_time_constant * 1000.0)
+        );
     );
 }
 

src/ui/settings/spectrum.rs

@@ -11,12 +11,16 @@ use crate::ui::widgets::{SliderRange, chip, pick, split, toggle};
 use crate::util::audio::{Channel, FrequencyScale};
 use crate::visuals::options::{SpectrumDisplayMode, SpectrumWeightingMode as WeightingMode};
 use crate::visuals::spectrum::processor::{
-    AveragingMode, DEFAULT_SPECTRUM_EXP_FACTOR, DEFAULT_SPECTRUM_PEAK_DECAY, MAX_SPECTRUM_DB_FLOOR,
-    MAX_SPECTRUM_EXP_FACTOR, MAX_SPECTRUM_PEAK_DECAY, MIN_SPECTRUM_DB_FLOOR,
-    MIN_SPECTRUM_EXP_FACTOR, MIN_SPECTRUM_PEAK_DECAY,
+    AveragingMode, DEFAULT_SPECTRUM_PEAK_DECAY, DEFAULT_SPECTRUM_TIME_CONSTANT,
+    MAX_SPECTRUM_DB_FLOOR, MAX_SPECTRUM_PEAK_DECAY, MAX_SPECTRUM_TIME_CONSTANT,
+    MIN_SPECTRUM_DB_FLOOR, MIN_SPECTRUM_PEAK_DECAY, MIN_SPECTRUM_TIME_CONSTANT,
 };
 
-const EXP_R: SliderRange = SliderRange::new(MIN_SPECTRUM_EXP_FACTOR, MAX_SPECTRUM_EXP_FACTOR, 0.01);
+const TIME_CONSTANT_R: SliderRange = SliderRange::new(
+    MIN_SPECTRUM_TIME_CONSTANT,
+    MAX_SPECTRUM_TIME_CONSTANT,
+    0.005,
+);
 const DECAY_R: SliderRange =
     SliderRange::new(MIN_SPECTRUM_PEAK_DECAY, MAX_SPECTRUM_PEAK_DECAY, 0.5);
 const BARS_R: SliderRange = SliderRange::new(8.0, 128.0, 1.0);
@@ -36,7 +40,7 @@ crate::macros::choice_enum!(pub(in crate::ui) enum FrequencyDirection {
 
 struct AveragingControls {
     mode: AvgMode,
-    factor: f32,
+    time_constant: f32,
     peak_decay: f32,
 }
 
@@ -61,7 +65,9 @@ settings_messages!(pane, settings, value {
     Weighting(WeightingMode) => set(&mut settings.weighting_mode, value);
     SecondaryWeighting(WeightingMode) => set(&mut settings.secondary_weighting_mode, value);
     Averaging(AvgMode) => pane.update_avg(|average| set(&mut average.mode, value));
-    AvgFactor(f32) => pane.update_avg(|average| set_f32(&mut average.factor, value));
+    AvgTimeConstant(f32) => {
+        pane.update_avg(|average| set_f32(&mut average.time_constant, value))
+    };
     PeakDecay(f32) => pane.update_avg(|average| set_f32(&mut average.peak_decay, value));
     ShowGrid(bool) => set(&mut settings.show_grid, value);
     ShowPeakLabel(bool) => set(&mut settings.show_peak_label, value);
@@ -96,7 +102,8 @@ settings_view! {
         );
         let averaging = match pane.averaging.mode {
             AvgMode::Exponential => Some(slider!(
-                "Exp factor", pane.averaging.factor, EXP_R, AvgFactor, "{:.2}"
+                "Time constant", pane.averaging.time_constant, TIME_CONSTANT_R, AvgTimeConstant,
+                format!("{:.0} ms", pane.averaging.time_constant * 1000.0)
             )),
             AvgMode::PeakHold => Some(slider!(
                 "Peak decay", pane.averaging.peak_decay, DECAY_R, PeakDecay, "{:.1} dB/s"
@@ -161,7 +168,7 @@ impl Pane {
         self.settings.averaging = match self.averaging.mode {
             AvgMode::None => AveragingMode::None,
             AvgMode::Exponential => AveragingMode::Exponential {
-                factor: self.averaging.factor,
+                time_constant: self.averaging.time_constant,
             },
             AvgMode::PeakHold => AveragingMode::PeakHold {
                 decay_per_second: self.averaging.peak_decay,
@@ -172,18 +179,20 @@ impl Pane {
 }
 
 fn split_averaging(avg: AveragingMode) -> AveragingControls {
-    let default_factor = DEFAULT_SPECTRUM_EXP_FACTOR;
+    let default_time_constant = DEFAULT_SPECTRUM_TIME_CONSTANT;
     let default_peak_decay = DEFAULT_SPECTRUM_PEAK_DECAY;
-    let (mode, factor, peak_decay) = match avg {
-        AveragingMode::None => (AvgMode::None, default_factor, default_peak_decay),
-        AveragingMode::Exponential { factor } => (AvgMode::Exponential, factor, default_peak_decay),
+    let (mode, time_constant, peak_decay) = match avg {
+        AveragingMode::None => (AvgMode::None, default_time_constant, default_peak_decay),
+        AveragingMode::Exponential { time_constant } => {
+            (AvgMode::Exponential, time_constant, default_peak_decay)
+        }
         AveragingMode::PeakHold { decay_per_second } => {
-            (AvgMode::PeakHold, default_factor, decay_per_second)
+            (AvgMode::PeakHold, default_time_constant, decay_per_second)
         }
     };
     AveragingControls {
         mode,
-        factor,
+        time_constant,
         peak_decay,
     }
 }

src/util/audio.rs

@@ -50,6 +50,14 @@ pub fn sanitize_sample_rate(sample_rate: f32) -> f32 {
         .clamp(1.0, MAX_SAMPLE_RATE)
 }
 
+pub fn smoothing_weight(elapsed: f32, time_constant: f32) -> f32 {
+    if time_constant > 0.0 {
+        -(-elapsed / time_constant).exp_m1()
+    } else {
+        1.0
+    }
+}
+
 pub fn fmt_freq(frequency: f32) -> String {
     match frequency {
         99_950.0.. => format!("{:.0}kHz", frequency / 1_000.0),