Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
Merge branch 'main' into fix/speed-clip-waveforms
Richie McIlroy989f5d224eb6
diff --cc apps/desktop-gpui/src/editor_timeline.rsindex 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();