refactor: various cleanups

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

Author: httpsworldview

src/meter.rs

@@ -62,6 +62,23 @@ impl DspBatcher {
         self.samples.extend_from_slice(&samples[ready..]);
     }
 
+    fn push_silence(&mut self, manager: &mut VisualManager, frames: u64, format: AudioFormat) {
+        let limit = (MAX_SILENCE_SECONDS as f64 * f64::from(format.sample_rate))
+            .round()
+            .max(1.0) as u64;
+        if frames > limit {
+            self.reset(manager);
+            return;
+        }
+        let capacity = SILENCE.len() / format.channels;
+        let mut remaining = frames;
+        while remaining > 0 {
+            let chunk = remaining.min(capacity as u64) as usize;
+            self.push(manager, &SILENCE[..chunk * format.channels], format);
+            remaining -= chunk as u64;
+        }
+    }
+
     fn reset(&mut self, manager: &mut VisualManager) {
         self.clear();
         manager.reset_audio();
@@ -108,7 +125,7 @@ impl MeterEngine {
                 batcher.push(&mut manager, samples, format);
             }
             CapturedSpan::Silence { frames, format } => {
-                ingest_silence(&mut manager, batcher, frames, format);
+                batcher.push_silence(&mut manager, frames, format);
             }
             CapturedSpan::Reset => batcher.reset(&mut manager),
         });
@@ -150,28 +167,6 @@ impl MeterEngine {
     }
 }
 
-fn ingest_silence(
-    manager: &mut VisualManager,
-    batcher: &mut DspBatcher,
-    frames: u64,
-    format: AudioFormat,
-) {
-    let limit = (MAX_SILENCE_SECONDS as f64 * f64::from(format.sample_rate))
-        .round()
-        .max(1.0) as u64;
-    if frames > limit {
-        batcher.reset(manager);
-        return;
-    }
-    let capacity = SILENCE.len() / format.channels;
-    let mut remaining = frames;
-    while remaining > 0 {
-        let chunk = remaining.min(capacity as u64) as usize;
-        batcher.push(manager, &SILENCE[..chunk * format.channels], format);
-        remaining -= chunk as u64;
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -283,7 +278,7 @@ mod tests {
             let mut reference = LoudnessProcessor::new(Default::default());
             reference.process_block(&AudioBlock::new(&signal, 1, 48_000.0));
             batcher.push(&mut manager, &[0.0], format);
-            ingest_silence(&mut manager, &mut batcher, frames, format);
+            batcher.push_silence(&mut manager, frames, format);
             let expected = if frames > 192_000 {
                 assert!(batcher.samples.is_empty());
                 reset_level

src/util/color.rs

@@ -149,14 +149,13 @@ pub fn sanitize_stop_positions(raw: Option<&[f32]>, defaults: &[f32]) -> Vec<f32
 }
 
 pub fn sanitize_stop_spreads(raw: Option<&[f32]>, count: usize) -> Vec<f32> {
-    let mut out = vec![1.0; count];
-    let Some(raw) = raw.filter(|raw| raw.len() == count) else {
-        return out;
-    };
-    for (dst, &value) in out.iter_mut().zip(raw.iter()) {
-        *dst = finite_or(value, 1.0).clamp(STOP_SPREAD_MIN, STOP_SPREAD_MAX);
+    match raw.filter(|raw| raw.len() == count) {
+        Some(raw) => raw
+            .iter()
+            .map(|&value| finite_or(value, 1.0).clamp(STOP_SPREAD_MIN, STOP_SPREAD_MAX))
+            .collect(),
+        None => vec![1.0; count],
     }
-    out
 }
 
 #[cfg(test)]

src/visuals/loudness/render.rs

@@ -106,6 +106,8 @@ impl LoudnessParams {
         let y1 = bounds.y + bounds.height;
         let height = y1 - y0;
         let y_of = |db| (y1 - height * db_to_ratio(db)).clamp(y0, y1);
+        let hline =
+            |x0, x1, y, width, color| line_instance((x0, y), (x1, y), color, color, width, clip);
         let bars = self.bar_groups();
         let bar_count = bars.len();
         let vertices = &mut scratch.instances;
@@ -140,14 +142,8 @@ impl LoudnessParams {
                     let ceiling = ceiling.clamp(DB_RANGE.0, DB_RANGE.1);
                     let upper = value.min(ceiling);
                     if upper > lower {
-                        vertices.push(quad_instance(
-                            sx0,
-                            y_of(upper),
-                            sx1,
-                            y_of(lower),
-                            clip,
-                            color,
-                        ));
+                        let (top, bottom) = (y_of(upper), y_of(lower));
+                        vertices.push(quad_instance(sx0, top, sx1, bottom, clip, color));
                     }
                     lower = lower.max(ceiling);
                     if value <= ceiling {
@@ -156,44 +152,22 @@ impl LoudnessParams {
                 }
 
                 if let Some((db, color)) = fill.peak {
-                    let cy = y_of(db);
-                    vertices.push(line_instance(
-                        (sx0, cy),
-                        (sx1, cy),
-                        color,
-                        color,
-                        PEAK_THICKNESS,
-                        clip,
-                    ));
+                    vertices.push(hline(sx0, sx1, y_of(db), PEAK_THICKNESS, color));
                 }
             }
         }
 
-        let guide_anchor = meter_x - GUIDE_PADDING;
+        let guide = self.guide_color;
+        let guide_x1 = meter_x - GUIDE_PADDING;
         for db in GUIDE_LEVELS {
-            let cy = y_of(db);
-            vertices.push(line_instance(
-                (guide_anchor - GUIDE_LENGTH, cy),
-                (guide_anchor, cy),
-                self.guide_color,
-                self.guide_color,
-                GUIDE_THICKNESS,
-                clip,
-            ));
+            let x0 = guide_x1 - GUIDE_LENGTH;
+            vertices.push(hline(x0, guide_x1, y_of(db), GUIDE_THICKNESS, guide));
         }
 
         let cy = y_of(0.0);
         for i in 0..bar_count {
             let x0 = meter_x + i as f32 * stride;
-            let x1 = x0 + bar_width;
-            vertices.push(line_instance(
-                (x0, cy),
-                (x1, cy),
-                self.guide_color,
-                self.guide_color,
-                THRESHOLD_THICKNESS,
-                clip,
-            ));
+            vertices.push(hline(x0, x0 + bar_width, cy, THRESHOLD_THICKNESS, guide));
         }
     }
 }

src/visuals/loudness/state.rs

@@ -145,16 +145,12 @@ impl LoudnessState {
     }
 
     fn visual_params(&self, bounds: Rectangle) -> LoudnessParams {
-        let values = self.visible_values();
+        let meters = self.visible_meters();
         LoudnessParams {
             geometry: self.geometry,
             bounds,
             bg_color: color_to_rgba(self.palette[PAL_BACKGROUND]),
-            bars: [
-                self.meter_fill(0, self.settings.left_mode, values[0]),
-                self.meter_fill(1, self.settings.left_mode, values[1]),
-                self.meter_fill(2, self.settings.right_mode, values[2]),
-            ],
+            bars: std::array::from_fn(|i| self.meter_fill(self.peaks[i].db, meters[i])),
             guide_color: color_to_rgba(self.palette[PAL_GUIDE]),
         }
     }
@@ -174,33 +170,30 @@ impl LoudnessState {
             .unwrap_or(DB_RANGE.0)
     }
 
-    fn visible_values(&self) -> [f32; VISIBLE_METER_COUNT] {
+    fn visible_meters(&self) -> [(MeterMode, f32); VISIBLE_METER_COUNT] {
+        let (left, right) = (self.settings.left_mode, self.settings.right_mode);
         [
-            self.aggregate_channels(self.settings.left_mode, MeterSide::Left),
-            self.aggregate_channels(self.settings.left_mode, MeterSide::Right),
-            self.aggregate_channels(self.settings.right_mode, MeterSide::Both),
+            (left, MeterSide::Left),
+            (left, MeterSide::Right),
+            (right, MeterSide::Both),
         ]
+        .map(|(mode, side)| (mode, self.aggregate_channels(mode, side)))
     }
 
-    fn meter_fill(&self, peak_index: usize, mode: MeterMode, db: f32) -> MeterFill {
-        let peak_db = self.peaks[peak_index].db;
+    fn meter_fill(&self, peak_db: f32, (mode, db): (MeterMode, f32)) -> MeterFill {
+        let thresholds = zone_thresholds(mode);
+        let colors = &self.palette[PAL_LOW..];
         MeterFill {
             db,
-            segments: self.meter_segments(mode),
+            segments: std::array::from_fn(|i| (thresholds[i], color_to_rgba(colors[i]))),
             peak: (peak_db > DB_RANGE.0).then(|| {
-                let danger = peak_db >= zone_thresholds(mode)[DANGER_THRESHOLD_INDEX];
+                let danger = peak_db >= thresholds[DANGER_THRESHOLD_INDEX];
                 let color = self.palette[if danger { PAL_DANGER } else { PAL_PEAK }];
                 (peak_db, color_to_rgba(color))
             }),
         }
     }
 
-    fn meter_segments(&self, mode: MeterMode) -> [(f32, [f32; 4]); ZONE_COUNT] {
-        let [low, mid, high] = zone_thresholds(mode);
-        let thresholds = [low, mid, high, DB_RANGE.1];
-        std::array::from_fn(|i| (thresholds[i], color_to_rgba(self.palette[PAL_LOW + i])))
-    }
-
     fn refresh_value_label(&mut self) {
         let mode = self.settings.right_mode;
         let unit = match mode {
@@ -219,8 +212,8 @@ impl LoudnessState {
     }
 
     fn update_peak_holds(&mut self, now: Instant) {
-        let values = self.visible_values();
-        for (peak, value) in self.peaks.iter_mut().zip(values) {
+        let meters = self.visible_meters();
+        for (peak, (_, value)) in self.peaks.iter_mut().zip(meters) {
             peak.update(value.clamp(DB_RANGE.0, DB_RANGE.1), now);
         }
     }
@@ -254,10 +247,12 @@ fn channel_side(
     }
 }
 
-fn zone_thresholds(mode: MeterMode) -> [f32; 3] {
+fn zone_thresholds(mode: MeterMode) -> [f32; ZONE_COUNT] {
     match mode {
-        MeterMode::LufsShortTerm | MeterMode::LufsMomentary => [-24.0, -18.0, -9.0],
-        MeterMode::RmsFast | MeterMode::RmsSlow | MeterMode::TruePeak => [-12.0, -6.0, -1.0],
+        MeterMode::LufsShortTerm | MeterMode::LufsMomentary => [-24.0, -18.0, -9.0, DB_RANGE.1],
+        MeterMode::RmsFast | MeterMode::RmsSlow | MeterMode::TruePeak => {
+            [-12.0, -6.0, -1.0, DB_RANGE.1]
+        }
     }
 }
 

src/visuals/spectrum/render.rs

@@ -136,35 +136,28 @@ impl SpectrumParams {
             points2,
             ..
         } = scratch;
-        let normalized = self.normalized_points.as_ref();
-        let has_primary = normalized.len() >= MIN_TRACE_POINTS;
-        let has_secondary = self.secondary_points.len() >= MIN_TRACE_POINTS;
-        let primary_segments = normalized.len().min(pixel_budget).saturating_sub(1);
-        let secondary_segments = self
-            .secondary_points
-            .len()
-            .min(pixel_budget)
-            .saturating_sub(1);
-        vertices.reserve(primary_segments * 2 + secondary_segments);
+        let segments = |points: &[[f32; 2]]| points.len().min(pixel_budget).saturating_sub(1);
+        vertices.reserve(segments(&self.normalized_points) * 2 + segments(&self.secondary_points));
         let baseline = bounds.y + bounds.height;
+        let project = |out: &mut Vec<(f32, f32)>, normalized: &[[f32; 2]]| {
+            let visible = normalized.len() >= MIN_TRACE_POINTS;
+            if visible {
+                out.extend(
+                    normalized
+                        .iter()
+                        .map(|&p| normalized_to_cartesian(bounds, p)),
+                );
+                decimate_line(out, pixel_budget);
+            }
+            visible
+        };
 
+        let has_primary = project(points, &self.normalized_points);
         if has_primary {
-            points.extend(
-                normalized
-                    .iter()
-                    .map(|&p| normalized_to_cartesian(bounds, p)),
-            );
-            decimate_line(points, pixel_budget);
             self.push_highlight_columns(vertices, clip, baseline, bounds.height, points);
         }
 
-        if has_secondary {
-            points2.extend(
-                self.secondary_points
-                    .iter()
-                    .map(|&p| normalized_to_cartesian(bounds, p)),
-            );
-            decimate_line(points2, pixel_budget);
+        if project(points2, &self.secondary_points) {
             extend_aa_line_list(
                 vertices,
                 points2,

src/visuals/spectrum/state.rs

@@ -497,17 +497,12 @@ fn peak_bin(bins: &[f32], db: &[f32], min_f: f32, max_f: f32) -> Option<usize> {
 }
 
 fn interpolated_peak(bins: &[f32], db: &[f32], bin: usize) -> (f32, f32) {
-    let next = bin + 1;
     let bin_hz = bins[1] - bins[0];
     let (center_freq, center) = (bins[bin], db[bin]);
-    let (left, right) = (db[bin - 1], db[next]);
-    let offset = if left.is_finite() && right.is_finite() {
-        let denom = left - 2.0 * center + right;
-        if denom < -EPSILON {
-            (0.5 * (left - right) / denom).clamp(-0.5, 0.5)
-        } else {
-            0.0
-        }
+    let (left, right) = (db[bin - 1], db[bin + 1]);
+    let denom = left - 2.0 * center + right;
+    let offset = if left.is_finite() && right.is_finite() && denom < -EPSILON {
+        (0.5 * (left - right) / denom).clamp(-0.5, 0.5)
     } else {
         0.0
     };