refactor(spectrogram): isolate history ring state

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

Author: httpsworldview

src/visuals/spectrogram/state.rs

@@ -74,22 +74,8 @@ impl Default for SpectrogramStyle {
     }
 }
 
-pub(in crate::visuals) struct SpectrogramState {
-    pub(in crate::visuals) style: SpectrogramStyle,
-    pub(in crate::visuals) palette: [Color; SPECTROGRAM_PALETTE_SIZE],
-    pub(in crate::visuals) stop_positions: [f32; SPECTROGRAM_PALETTE_SIZE],
-    pub(in crate::visuals) stop_spreads: [f32; SPECTROGRAM_PALETTE_SIZE],
-    key: u64,
-    pub(in crate::visuals) piano_roll_overlay: PianoRollOverlay,
-    pub(in crate::visuals) rotation: i8,
-    sample_rate: f32,
-    fft_size: usize,
-    hop_size: usize,
-    pub(in crate::visuals) freq_scale: FrequencyScale,
+struct SpectrogramHistory {
     col_kind: ColumnKind,
-    zoom: f32,
-    pan: f32,
-    pub(in crate::visuals) view_width: u32,
     points_per_column: usize,
     reassigned_points_per_slot: u32,
     ring_capacity: u32,
@@ -101,25 +87,10 @@ pub(in crate::visuals) struct SpectrogramState {
     pending_copy: Option<RingCopyPlan>,
 }
 
-impl SpectrogramState {
-    pub fn new() -> Self {
-        let cfg = SpectrogramConfig::default();
+impl Default for SpectrogramHistory {
+    fn default() -> Self {
         Self {
-            style: SpectrogramStyle::default(),
-            palette: palettes::spectrogram::COLORS,
-            stop_positions: palettes::spectrogram::DEFAULT_POSITIONS,
-            stop_spreads: [1.0; SPECTROGRAM_PALETTE_SIZE],
-            key: crate::visuals::next_key(),
-            piano_roll_overlay: PianoRollOverlay::Off,
-            rotation: 0,
-            sample_rate: cfg.sample_rate,
-            fft_size: cfg.fft_size * cfg.zero_padding_factor.max(1),
-            hop_size: cfg.hop_size,
-            freq_scale: cfg.frequency_scale,
             col_kind: ColumnKind::Reassigned,
-            zoom: 1.0,
-            pan: 0.5,
-            view_width: 0,
             points_per_column: 0,
             reassigned_points_per_slot: 1,
             ring_capacity: 0,
@@ -131,49 +102,12 @@ impl SpectrogramState {
             pending_copy: None,
         }
     }
+}
 
-    pub fn set_palette(&mut self, palette: &[Color; SPECTROGRAM_PALETTE_SIZE]) {
-        self.palette = *palette;
-    }
-
-    pub fn set_stop_positions(&mut self, positions: &[f32]) {
-        if let Ok(arr) = <[f32; SPECTROGRAM_PALETTE_SIZE]>::try_from(positions) {
-            self.stop_positions = arr;
-        }
-    }
-
-    pub fn set_stop_spreads(&mut self, spreads: &[f32]) {
-        if let Ok(arr) = <[f32; SPECTROGRAM_PALETTE_SIZE]>::try_from(spreads) {
-            self.stop_spreads = arr;
-        }
-    }
-
-    pub fn set_floor_db(&mut self, floor_db: f32) {
-        self.style.floor_db = sanitize_negative_db(floor_db, DB_FLOOR)
-            .min(self.style.ceiling_db - 1.0);
-    }
-
-    pub fn set_tilt_db(&mut self, tilt_db: f32) {
-        self.style.tilt_db = if tilt_db.is_finite() { tilt_db } else { 0.0 };
-    }
-
-    pub fn set_rotation(&mut self, rotation: i8) {
-        self.rotation = rotation.clamp(-1, 2);
-    }
-
-    pub fn apply_snapshot(&mut self, snap: SpectrogramUpdate) {
-        if snap.new_columns.is_empty() && !snap.reset {
-            return;
-        }
-        self.sample_rate = snap.sample_rate;
-        self.fft_size = snap.fft_size;
-        self.hop_size = snap.hop_size;
-        self.freq_scale = snap.frequency_scale;
-
+impl SpectrogramHistory {
+    fn apply_update(&mut self, snap: SpectrogramUpdate) {
         let ppc = snap.points_per_column;
-        if ppc == 0 {
-            return;
-        }
+        if ppc == 0 { return; }
         let new_kind = match snap.new_columns.first() {
             Some(SpectrogramColumn::Reassigned(_)) => ColumnKind::Reassigned,
             Some(SpectrogramColumn::Classic(_)) => ColumnKind::Classic,
@@ -185,21 +119,16 @@ impl SpectrogramState {
         let capacity = (snap.history_length as u32)
             .clamp(1, MAX_SPECTROGRAM_HISTORY_COLUMNS as u32)
             .min(max_cols);
-        if capacity == 0 {
-            return;
-        }
+        if capacity == 0 { return; }
 
         if snap.reset || self.points_per_column != ppc || new_kind != self.col_kind {
-            self.points_per_column = ppc;
-            self.reassigned_points_per_slot = 1;
-            self.ring_capacity = capacity;
-            self.gpu_capacity = 0;
-            self.col_kind = new_kind;
-            self.write_slot = 0;
-            self.col_count = 0;
-            self.slot_counts = vec![0; capacity as usize];
-            self.pending = VecDeque::new();
-            self.pending_copy = None;
+            *self = Self {
+                col_kind: new_kind,
+                points_per_column: ppc,
+                ring_capacity: capacity,
+                slot_counts: vec![0; capacity as usize],
+                ..Default::default()
+            };
         } else if capacity != self.ring_capacity {
             self.ensure_pending_copy();
             if capacity > self.ring_capacity && self.col_count >= self.ring_capacity {
@@ -227,14 +156,10 @@ impl SpectrogramState {
                 }
                 SpectrogramColumn::Classic(mags) => PendingUpload::Classic { slot, mags },
             };
-            if self.pending.len() as u32 >= self.ring_capacity {
-                self.pending.pop_front();
-            }
+            if self.pending.len() as u32 >= self.ring_capacity { self.pending.pop_front(); }
             self.pending.push_back(upload);
             self.write_slot = (self.write_slot + 1) % self.ring_capacity;
-            if self.col_count < self.ring_capacity {
-                self.col_count += 1;
-            }
+            if self.col_count < self.ring_capacity { self.col_count += 1; }
         }
         self.fit_reassigned_slot_capacity();
     }
@@ -256,9 +181,7 @@ impl SpectrogramState {
             .iter()
             .take(self.ring_capacity as usize)
             .copied()
-            .max()
-            .unwrap_or(0)
-            .max(1);
+            .fold(1, u32::max);
         let current = self.reassigned_points_per_slot.max(1);
         if needed > current || current > needed.saturating_mul(4).max(1) {
             self.ensure_pending_copy();
@@ -289,37 +212,117 @@ impl SpectrogramState {
             copies.retain_mut(|[_, dst]| remap(dst));
         }
     }
+}
+
+pub(in crate::visuals) struct SpectrogramState {
+    pub(in crate::visuals) style: SpectrogramStyle,
+    pub(in crate::visuals) palette: [Color; SPECTROGRAM_PALETTE_SIZE],
+    pub(in crate::visuals) stop_positions: [f32; SPECTROGRAM_PALETTE_SIZE],
+    pub(in crate::visuals) stop_spreads: [f32; SPECTROGRAM_PALETTE_SIZE],
+    key: u64,
+    pub(in crate::visuals) piano_roll_overlay: PianoRollOverlay,
+    pub(in crate::visuals) rotation: i8,
+    sample_rate: f32,
+    fft_size: usize,
+    hop_size: usize,
+    pub(in crate::visuals) freq_scale: FrequencyScale,
+    zoom: f32,
+    pan: f32,
+    pub(in crate::visuals) view_width: u32,
+    history: SpectrogramHistory,
+}
+
+impl SpectrogramState {
+    pub fn new() -> Self {
+        let cfg = SpectrogramConfig::default();
+        Self {
+            style: SpectrogramStyle::default(),
+            palette: palettes::spectrogram::COLORS,
+            stop_positions: palettes::spectrogram::DEFAULT_POSITIONS,
+            stop_spreads: [1.0; SPECTROGRAM_PALETTE_SIZE],
+            key: crate::visuals::next_key(),
+            piano_roll_overlay: PianoRollOverlay::Off,
+            rotation: 0,
+            sample_rate: cfg.sample_rate,
+            fft_size: cfg.fft_size * cfg.zero_padding_factor.max(1),
+            hop_size: cfg.hop_size,
+            freq_scale: cfg.frequency_scale,
+            zoom: 1.0,
+            pan: 0.5,
+            view_width: 0,
+            history: SpectrogramHistory::default(),
+        }
+    }
+
+    pub fn set_palette(&mut self, palette: &[Color; SPECTROGRAM_PALETTE_SIZE]) {
+        self.palette = *palette;
+    }
+
+    pub fn set_stop_positions(&mut self, positions: &[f32]) {
+        if let Ok(arr) = <[f32; SPECTROGRAM_PALETTE_SIZE]>::try_from(positions) {
+            self.stop_positions = arr;
+        }
+    }
+
+    pub fn set_stop_spreads(&mut self, spreads: &[f32]) {
+        if let Ok(arr) = <[f32; SPECTROGRAM_PALETTE_SIZE]>::try_from(spreads) {
+            self.stop_spreads = arr;
+        }
+    }
+
+    pub fn set_floor_db(&mut self, floor_db: f32) {
+        self.style.floor_db = sanitize_negative_db(floor_db, DB_FLOOR)
+            .min(self.style.ceiling_db - 1.0);
+    }
+
+    pub fn set_tilt_db(&mut self, tilt_db: f32) {
+        self.style.tilt_db = if tilt_db.is_finite() { tilt_db } else { 0.0 };
+    }
+
+    pub fn set_rotation(&mut self, rotation: i8) {
+        self.rotation = rotation.clamp(-1, 2);
+    }
+
+    pub fn apply_snapshot(&mut self, snap: SpectrogramUpdate) {
+        if snap.new_columns.is_empty() && !snap.reset { return; }
+        self.sample_rate = snap.sample_rate;
+        self.fft_size = snap.fft_size;
+        self.hop_size = snap.hop_size;
+        self.freq_scale = snap.frequency_scale;
+        self.history.apply_update(snap);
+    }
 
     pub fn visual_params(
         &mut self,
         bounds: Rectangle,
         uv_y_range: [f32; 2],
     ) -> Option<SpectrogramParams> {
-        if self.col_count == 0 && self.pending.is_empty() { return None; }
+        let history = &mut self.history;
+        if history.col_count == 0 && history.pending.is_empty() { return None; }
+        let copy_plan = history.pending_copy.take();
+        history.gpu_capacity = history.ring_capacity;
+        let slot_counts = if history.col_kind == ColumnKind::Reassigned {
+            history.slot_counts.clone()
+        } else {
+            Vec::new()
+        };
         let op = self.style.opacity.clamp(0.0, 1.0);
         let to_rgba = |c: Color| rgba_with_alpha(color_to_rgba(c), c.a * op);
         let bin_hz = self.sample_rate / (self.fft_size.max(1) as f32);
         let (freq_min, freq_max) = display_axis(self.sample_rate);
 
-        let copy_plan = self.pending_copy.take();
-        self.gpu_capacity = self.ring_capacity;
-
         Some(SpectrogramParams {
             key: self.key,
             bounds,
-            ring_capacity: self.ring_capacity,
-            points_per_column: self.points_per_column as u32,
-            reassigned_points_per_slot: self.reassigned_points_per_slot.max(1),
-            col_count: self.col_count,
-            write_slot: self.write_slot,
-            pending_uploads: std::mem::take(&mut self.pending),
+            ring_capacity: history.ring_capacity,
+            points_per_column: history.points_per_column as u32,
+            reassigned_points_per_slot: history.reassigned_points_per_slot.max(1),
+            col_count: history.col_count,
+            write_slot: history.write_slot,
+            pending_uploads: std::mem::take(&mut history.pending),
             copy_plan,
-            slot_counts: if self.col_kind == ColumnKind::Reassigned {
-                self.slot_counts.clone()
-            } else {
-                Vec::new()
-            },
-            col_kind: self.col_kind,
+            slot_counts,
+            col_kind: history.col_kind,
             freq_min,
             freq_max,
             bin_hz,
@@ -374,7 +377,7 @@ impl SpectrogramState {
     // 1 column = 1 logical pixel on the time axis, matching the shader.
     fn time_ago_at_cursor(&self, cursor: Point, bounds: Rectangle) -> Option<f32> {
         if !bounds.contains(cursor)
-            || self.col_count == 0
+            || self.history.col_count == 0
             || self.hop_size == 0
             || self.sample_rate <= 0.0
         {
@@ -387,7 +390,7 @@ impl SpectrogramState {
             3 => cursor.y - bounds.y,
             _ => return None,
         };
-        if age < 0.0 || age >= self.col_count as f32 { return None; }
+        if age < 0.0 || age >= self.history.col_count as f32 { return None; }
         let secs = age * (self.hop_size as f32 / self.sample_rate);
         secs.is_finite().then_some(secs)
     }