Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

Merge branch 'main' into fix/speed-clip-waveforms

Richie McIlroy989f5d224eb6
diff --cc apps/desktop-gpui/src/editor_timeline.rs
index e481c9502,58017b8d6..b7151d0f4
--- a/apps/desktop-gpui/src/editor_timeline.rs
+++ b/apps/desktop-gpui/src/editor_timeline.rs
@@@ -3240,17 -3319,17 +3316,18 @@@ fn render_waveform
] {
let geometry = WaveformGeometry {
peaks: peaks.clone(),
- range: (visible_start, visible_end),
- target_samples: samples,
+ range: layout.range,
+ target_samples: layout.samples,
holds: holds.clone(),
source_start: segment_start,
+ timescale,
- origin,
- size,
+ origin: layout.origin,
+ size: layout.size,
scale,
- clip_bounds,
+ clip_bounds: layout.clip_bounds,
};
if let Some(path) = paths.get_or_build((index, track), geometry) {
+ let path = translated_path(path, bounds.origin);
window.with_content_mask(Some(gpui::ContentMask { bounds }), |window| {
window.paint_path(path, wave_color)
});
@@@ -4705,78 -4782,125 +4782,251 @@@ mod tests
}
}
+ #[test]
+ fn waveform_path_retimes_trimmed_source_around_holds() {
+ let mut peaks = vec![-60.; 200];
+ peaks[140..160].fill(-6.);
+ let peaks = Arc::new(peaks);
+ for timescale in [0.25, 0.5, 2.0, 8.0] {
+ for holds in [vec![], vec![(1. / timescale, 1. / timescale + 1.)]] {
+ let held = if holds.is_empty() { 0. } else { 1. };
+ let duration = 8. / timescale + held;
+ for range in [(0., duration), (duration / 4., duration * 0.9)] {
+ let path = waveform_path(&WaveformGeometry {
+ peaks: peaks.clone(),
+ range,
+ target_samples: 1200,
+ holds: holds.clone(),
+ source_start: 10.,
+ timescale,
+ origin: gpui::point(px(0.), px(26.)),
+ size: gpui::size(px(600.), px(18.)),
+ scale: 1.,
+ clip_bounds: gpui::Bounds {
+ origin: gpui::point(px(0.), px(0.)),
+ size: gpui::size(px(600.), px(44.)),
+ },
+ })
+ .unwrap();
+ let (first, last) = path
+ .vertices
+ .iter()
+ .filter(|vertex| f32::from(vertex.xy_position.y) < 35.)
+ .map(|vertex| {
+ range.0
+ + f64::from(f32::from(vertex.xy_position.x)) / 600.
+ * (range.1 - range.0)
+ })
+ .fold((f64::INFINITY, f64::NEG_INFINITY), |(first, last), time| {
+ (first.min(time), last.max(time))
+ });
+ let expected_start = 4. / timescale + held;
+ let expected_end = 6. / timescale + held;
+ assert!(
+ (first - expected_start).abs() < 0.2 / timescale,
+ "{timescale}x, {holds:?}, {range:?}: first {first}, expected {expected_start}"
+ );
+ assert!(
+ (last - expected_end).abs() < 0.2 / timescale,
+ "{timescale}x, {holds:?}, {range:?}: last {last}, expected {expected_end}"
+ );
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn short_retimed_waveform_does_not_read_past_the_trim_end() {
+ let mut peaks = vec![-60.; 200];
+ peaks[103..105].fill(0.);
+ let geometry = WaveformGeometry {
+ range: (0., 0.025),
+ source_start: 10.,
+ timescale: 8.,
+ ..waveform_geometry(Arc::new(peaks))
+ };
+ let path = waveform_path(&geometry).unwrap();
+ let silent = waveform_path(&WaveformGeometry {
+ peaks: Arc::new(vec![-60.; 200]),
+ ..geometry
+ })
+ .unwrap();
+ assert_eq!(waveform_vertices(&path), waveform_vertices(&silent));
+ }
+
+ #[test]
+ fn the_waveform_window_always_covers_the_visible_slice() {
+ let duration = 120.;
+ let zoom = 20.;
+ let mut start = 0.;
+ while start + zoom <= duration {
+ let visible = (start, start + zoom);
+ let window = waveform_window(visible, zoom, duration);
+ assert!(
+ window.0 <= visible.0 && window.1 >= visible.1,
+ "{window:?} {visible:?}"
+ );
+ assert!(window.1 - window.0 <= zoom * 1.5 + 1e-9);
+ start += 0.37;
+ }
+ }
+
+ #[test]
+ fn a_fully_visible_segment_covers_exactly_its_visible_slice() {
+ assert_eq!(waveform_window((0., 8.), 30., 8.), (0., 8.));
+ assert_eq!(waveform_window((0., 30.), 30., 30.), (0., 30.));
+ }
+
+ #[test]
+ fn scrolling_reuses_the_window_for_a_quarter_viewport() {
+ let zoom = 20.;
+ let duration = 600.;
+ let mut windows = std::collections::HashSet::new();
+ // 60 s of follow-mode playback at 60 fps.
+ for frame in 0..3600 {
+ let start = 100. + frame as f64 / 60.;
+ let window = waveform_window((start, start + zoom), zoom, duration);
+ windows.insert((window.0.to_bits(), window.1.to_bits()));
+ }
+ assert!(windows.len() <= 13, "{} distinct windows", windows.len());
+ }
+
+ #[test]
+ fn a_translated_relative_path_matches_one_built_in_place() {
+ let peaks = speech_like_peaks(400, 7.);
+ let offset = gpui::point(px(250.5), px(312.25));
+ let relative = waveform_geometry(peaks.clone());
+ let path = waveform_path(&relative).unwrap();
+ let moved = translated_path(path.clone(), offset);
+ for (before, after) in path.vertices.iter().zip(&moved.vertices) {
+ assert_eq!(after.xy_position, before.xy_position + offset);
+ }
+ assert_eq!(moved.bounds.origin, path.bounds.origin + offset);
+ assert_eq!(moved.bounds.size, path.bounds.size);
+
+ // Building at the absolute position gives the same shape; the
+ // tessellator's triangle order can differ with float rounding, so the
+ // comparison is on the vertex count and the bounds.
+ let absolute = WaveformGeometry {
+ origin: relative.origin + offset,
+ clip_bounds: gpui::Bounds {
+ origin: relative.clip_bounds.origin + offset,
+ size: relative.clip_bounds.size,
+ },
+ ..relative.clone()
+ };
+ let built = waveform_path(&absolute).unwrap();
+ assert_eq!(built.vertices.len(), moved.vertices.len());
+ let close = |a: Pixels, b: Pixels| (f32::from(a) - f32::from(b)).abs() < 0.01;
+ assert!(close(built.bounds.origin.x, moved.bounds.origin.x));
+ assert!(close(built.bounds.origin.y, moved.bounds.origin.y));
+ assert!(close(built.bounds.size.width, moved.bounds.size.width));
+ assert!(close(built.bounds.size.height, moved.bounds.size.height));
+ }
+
+ #[test]
+ fn follow_mode_paths_are_built_once_per_window() {
+ let paths = WaveformPaths::default();
+ let slot = (0, WaveformTrack::Mic);
+ let peaks = speech_like_peaks(2000, 9.);
+ let zoom = 20.;
+ let segment = (12., 190.);
+ let full_width = 190. * 60.;
+ let canvas = (px(44.), px(full_width as f32), px(44.), px(18.));
+ for frame in 0..600 {
+ let position = 40. + frame as f64 / 60.;
+ let layout = waveform_layout((position, zoom), segment, full_width, canvas).unwrap();
+ let geometry = WaveformGeometry {
+ range: layout.range,
+ target_samples: layout.samples,
+ origin: layout.origin,
+ size: layout.size,
+ clip_bounds: layout.clip_bounds,
+ ..waveform_geometry(peaks.clone())
+ };
+ paths.get_or_build(slot, geometry).unwrap();
+ }
+ let stats = paths.stats();
+ assert!(stats.builds <= 3, "{stats:?}");
+ assert_eq!(stats.builds + stats.hits, 600);
+ }
+
++ #[test]
++ fn retimed_waveforms_stay_in_place_across_scrolled_windows() {
++ // A 2x clip from source 10 s with a 1 s hold at output 2..3 s: the
++ // loud source 30..32 s lands at segment-local output 11..12 s.
++ let mut peaks = vec![-60.; 600];
++ peaks[300..320].fill(-6.);
++ let peaks = Arc::new(peaks);
++ let zoom = 6.;
++ let segment = (12., 21.);
++ let full_width = 21. * 60.;
++ let canvas = (px(44.), px(full_width as f32), px(44.), px(18.));
++ let offset = gpui::point(px(100.), px(50.));
++ for visible_start in [6.5, 8., 9.5] {
++ let layout = waveform_layout(
++ (segment.0 + visible_start, zoom),
++ segment,
++ full_width,
++ canvas,
++ )
++ .unwrap();
++ assert!(layout.range.0 > 0. && layout.range.0 < visible_start);
++ let path = waveform_path(&WaveformGeometry {
++ peaks: peaks.clone(),
++ range: layout.range,
++ target_samples: layout.samples,
++ holds: vec![(2., 3.)],
++ source_start: 10.,
++ timescale: 2.,
++ origin: layout.origin,
++ size: layout.size,
++ scale: 1.,
++ clip_bounds: layout.clip_bounds,
++ })
++ .unwrap();
++ let path = translated_path(path, offset);
++ let (first, last) = path
++ .vertices
++ .iter()
++ .filter(|vertex| f32::from(vertex.xy_position.y) < 59.)
++ .map(|vertex| f64::from(f32::from(vertex.xy_position.x) - 100.) / 60.)
++ .fold((f64::INFINITY, f64::NEG_INFINITY), |(first, last), time| {
++ (first.min(time), last.max(time))
++ });
++ assert!(
++ (first - 11.).abs() < 0.1,
++ "{visible_start}: {layout:?} first {first}"
++ );
++ assert!(
++ (last - 12.).abs() < 0.1,
++ "{visible_start}: {layout:?} last {last}"
++ );
++ }
++ }
++
+ #[test]
+ fn an_off_screen_segment_has_no_waveform_layout() {
+ let canvas = (px(44.), px(600.), px(44.), px(18.));
+ assert!(waveform_layout((0., 20.), (30., 10.), 600., canvas).is_none());
+ assert!(waveform_layout((50., 20.), (30., 10.), 600., canvas).is_none());
+ }
+
+ #[test]
+ fn the_wider_window_keeps_the_on_screen_sample_density_at_the_cap() {
+ for (window, viewport) in [(15_000., 10_000.), (4_500., 3_000.), (900., 600.)] {
+ let samples = waveform_window_sample_count(window, viewport);
+ let window_density = samples as f64 / window;
+ let visible_density = waveform_sample_count(viewport) as f64 / viewport;
+ assert!(
+ (window_density - visible_density).abs() < 1e-3,
+ "{window} {viewport}: {window_density} vs {visible_density}"
+ );
+ }
+ assert_eq!(waveform_window_sample_count(300., 600.), 600);
+ assert_eq!(waveform_window_sample_count(300., 0.), 600);
+ }
+
#[test]
fn cached_waveform_matches_an_uncached_build_after_every_input_change() {
let paths = WaveformPaths::default();