Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix(compositor): mask the tilted blur trail, trail from the previous camera
EtienneLescot6317c6bd1d8d
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex 4c070aa39..e3039c0a3 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -1691,7 +1691,8 @@ pub struct FrameGeometry {/// La rotation de base une frame d'écran plus tôt : avec `s_dst_prev` et `camera_prev`, le/// zoom d'AVANT, que le mode 8 floute (`tilt_trail`).pub zoom_rotation_prev: [f32; 3],- /// La caméra réelle une frame plus tôt : son poids et son zoom d'avant, sa visée d'à présent.+ /// La caméra réelle une frame plus tôt (poids, visée, orbite, zoom), `None` si elle n'y était+ /// pas active — même quand elle l'est à cette frame-ci, ou l'inverse.pub camera_prev: Option<crate::camera::CameraPose>,pub padding_scale: f32,/// Coupe source de l'écran en UV texture (crop utilisateur + zoom).@@ -1843,9 +1844,9 @@ impl FrameGeometry {/// floute (`tilted_screen_cb`). `None` quand l'écran est droit ou le flou coupé.////// La frame d'avant est celle du mode 0 : la boîte au zoom d'avant (`s_dst_prev`), et ici la- /// rotation de base d'avant (un angle fixe entre avec le zoom) ou le poids de la caméra réelle.- /// Parallaxe, impact et visée restent ceux de la frame, comme le focus du mode 0 : le flou suit- /// le zoom, borné à une frame.+ /// rotation de base d'avant (un angle fixe entre avec le zoom) ou la caméra réelle d'avant+ /// (`camera_prev`). Parallaxe et impact restent ceux de la frame, comme le focus du mode 0 : le+ /// flou suit le zoom et la caméra, borné à une frame.pub fn tilt_trail(&self, render_px: [f32; 2]) -> Option<TiltTrail> {if !self.tilted() || self.mb_taps < 2.0 || self.mb_amount <= 0.001 {return None;@@ -2390,8 +2391,7 @@ impl FrameGeometry {return Some(mask);}- // Écran incliné (le mode 8 n'a pas de flou de mouvement : pas de trace à couvrir).- // Même quad et même centre que le dessin de l'écran et que `plan_cursor`.+ // Écran incliné. Même quad et même centre que le dessin de l'écran et que `plan_cursor`.let s_px = [self.s_dst[2] * rw, self.s_dst[3] * rh];let quad = self.screen_tilt(s_px)?;let centre = [@@ -2411,6 +2411,42 @@ impl FrameGeometry {[centre[0] + px, centre[1] + py]};let pts = [at(x0, y0), at(x1, y0), at(x1, y1), at(x0, y1)];+ // Le mode 8 étale aussi chaque pixel vers là où le plan était une frame plus tôt+ // (`tilt_trail`) : une copie traînée du secret sort du quad courant. Le masque couvre alors+ // la boîte englobante du secret aux deux frames, en rect droit, comme le chemin droit.+ // Même warp que le shader sur les coins d'avant (le drapeau projectif est celui du plan).+ // La perspective grossit localement le côté proche : la force suit l'arête la plus+ // agrandie par rapport au rect droit zoomé, pour que nulle part le masque ne soit plus+ // fin, rapporté au contenu, qu'au repos.+ let (ew, eh) = ((x1 - x0) * s_px[0], (y1 - y0) * s_px[1]);+ let len = |a: [f32; 2], b: [f32; 2]| (b[0] - a[0]).hypot(b[1] - a[1]);+ let tilt_k = (len(pts[0], pts[1]) / ew)+ .max(len(pts[3], pts[2]) / ew)+ .max(len(pts[0], pts[3]) / eh)+ .max(len(pts[1], pts[2]) / eh);+ let strength = (zoom_k * tilt_k).max(1.0);+ // Sans mouvement, la traînée EST le quad (au bit près) : rien de plus à couvrir.+ if let Some(trail) = self.tilt_trail(render_px).filter(|t| t.corners != quad.corners) {+ let before = crate::regions::TiltedQuad { corners: trail.corners, ..quad };+ let then = |fx: f32, fy: f32| {+ let (px, py) = before.point_px(fx, fy);+ [centre[0] + px, centre[1] + py]+ };+ let (mut lo, mut hi) = ([f32::MAX; 2], [f32::MIN; 2]);+ for [px, py] in pts.into_iter().chain([then(x0, y0), then(x1, y0), then(x1, y1), then(x0, y1)]) {+ (lo, hi) = ([lo[0].min(px), lo[1].min(py)], [hi[0].max(px), hi[1].max(py)]);+ }+ let rect =+ [lo[0] / rw, lo[1] / rh, (hi[0] - lo[0]).max(1.0) / rw, (hi[1] - lo[1]).max(1.0) / rh];+ let rect = match self.screen_mask {+ Some(m) => m.clip(rect)?,+ None => rect,+ };+ let mut mask = PrivacyMask::upright(rect, render_px, strength);+ // Un ovale inscrit dans la boîte élargie ne couvrirait plus l'ovale courant.+ mask.oval_ok = false;+ return Some(mask);+ }let (mut min_x, mut min_y) = (f32::MAX, f32::MAX);let (mut max_x, mut max_y) = (f32::MIN, f32::MIN);for [px, py] in pts {@@ -2432,21 +2468,12 @@ impl FrameGeometry {quad_px = [c[2] * rw, c[3] * rh];dst = c;}- // La perspective grossit localement le côté proche : la force suit l'arête la plus- // agrandie par rapport au rect droit zoomé, pour que nulle part le masque ne soit plus- // fin, rapporté au contenu, qu'au repos.- let (ew, eh) = ((x1 - x0) * s_px[0], (y1 - y0) * s_px[1]);- let len = |a: [f32; 2], b: [f32; 2]| (b[0] - a[0]).hypot(b[1] - a[1]);- let tilt_k = (len(pts[0], pts[1]) / ew)- .max(len(pts[3], pts[2]) / ew)- .max(len(pts[0], pts[3]) / eh)- .max(len(pts[1], pts[2]) / eh);Some(PrivacyMask {dst,quad_px,warp: Some(local),projective: quad.projective,- strength: (zoom_k * tilt_k).max(1.0),+ strength,oval_ok: true,})}@@ -2620,6 +2647,7 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {let mut zoom_camera_prev = 0.0f32;let mut zoom_aim = [0.5f32; 2];let mut zoom_orbit = [0.5f32; 2];+ let (mut zoom_aim_prev, mut zoom_orbit_prev) = ([0.5f32; 2], [0.5f32; 2]);// Curseur masqué → pas de piste pour ce qui anime le plan (parallaxe, impact, caméra// `follow-cursor`) : l'export ne charge la piste que si le curseur est affiché// (`timeline_walk`), la preview toujours. Sans cette porte, la preview pencherait un@@ -2649,17 +2677,21 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {zoom_camera = zs.camera;zoom_aim = zs.aim;zoom_orbit = zs.orbit;+ // Même `CameraFrame` qu'à la frame courante : la caméra réelle d'avant (poids, visée,+ // orbite) sert au flou du mode 8. Échelle et focus n'en dépendent pas.let zs_p = crate::regions::zoom_state_in(zoom_regions,source_t_prev,cursor_for_zoom,- &crate::regions::CameraFrame::NONE,+ &camera,&clock,);pp.zoom = zs_p.scale;pp.focus = zs_p.focus;zoom_rotation_prev = zs_p.rotation;zoom_camera_prev = zs_p.camera;+ zoom_aim_prev = zs_p.aim;+ zoom_orbit_prev = zs_p.orbit;}// Full Camera ignore le rétrécissement réactif de la webcam (design web : mélanger// "rétrécit pour le zoom" et "grandit en plein cadre" dans la même frame n'a pas de sens).@@ -2872,10 +2904,15 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {zoom: p.zoom,press,});- let camera_prev = camera.map(|pose| crate::camera::CameraPose {+ // La caméra réelle de la frame d'avant, dès qu'elle y était active — y compris quand elle+ // ne l'est plus à celle-ci (fin de sa moitié d'une transition vers un angle fixe) ; `None`+ // quand elle ne l'était pas, et le mode 8 reprend alors la rotation d'avant.+ let camera_prev = (zoom_camera_prev > 0.0).then(|| crate::camera::CameraPose {weight: zoom_camera_prev,+ aim: focus_in_cut(u_max, v_max, active_crop, zoom_aim_prev, cut),+ orbit: focus_in_cut(u_max, v_max, active_crop, zoom_orbit_prev, cut),zoom: pp.zoom,- ..pose+ press,});let focus_plane = match camera {Some(pose) => pose.orbit,@@ -5714,6 +5751,45 @@ mod tests {assert_eq!(at(&ramp(zoomed_golden_scene_json()), 1.6).tilt_trail(render), None);}+ /// Transition chaînée caméra réelle → angle fixe : la frame d'avant peut encore être dans la+ /// moitié `follow-cursor` quand celle-ci est dans la moitié fixe. La traînée doit alors partir+ /// du plan vu par la caméra d'AVANT, pas d'un plan droit.+ #[test]+ fn the_trail_keeps_the_previous_camera_across_a_follow_to_fixed_handover() {+ let cfg = crate::config::all().pop().expect("au moins une config");+ let render = [1170.0, 658.0];+ let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(+ crate::cursor::CursorTrack::new((0..=300).map(|i| (i as f32 / 30.0, 0.8, 0.3)).collect(), vec![], vec![]),+ ));+ let json = zoomed_golden_scene_json().replace(+ r#"[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}]"#,+ r#"[{"clipIndex":0,"startSec":1.0,"endSec":4.0,"scale":2.0,"focusX":0.5,"focusY":0.5,"rotation":"follow-cursor"},+ {"clipIndex":0,"startSec":4.5,"endSec":8.0,"scale":2.0,"focusX":0.5,"focusY":0.5,"rotation":"iso"}]"#,+ );+ assert_ne!(json, zoomed_golden_scene_json(), "la substitution doit poser les deux régions");+ let scene = Scene::from_json(&json).expect("scène");+ let mut handover = None;+ for k in 0..=600 {+ let t = 4.0 + k as f32 / 600.0;+ let g = plan_frame(&FrameGeometryInput { cursor: Some(track), timeline_t_override: Some(t), ..golden_input(&scene, &cfg) });+ assert_eq!(g.camera_prev.is_some(), g.camera_prev.is_some_and(|p| p.weight > 0.0));+ if g.camera.is_none() && g.camera_prev.is_some() {+ handover = Some(g);+ break;+ }+ }+ let g = handover.expect("une frame où seule la frame d'avant a la caméra");+ let trail = g.tilt_trail(render).expect("traînée");+ let d = g.s_dst_prev;+ let px = [d[2] * render[0], d[3] * render[1]];+ let seen = crate::camera::View::new(px, g.camera_prev.unwrap()).quad(px);+ let upright = crate::regions::rotated_quad_corners_px(px[0], px[1], g.zoom_rotation_prev, g.zoom_rotation_dyn);+ let shape = |c: [(f32, f32); 4]| c.map(|(x, y)| (x - c[0].0, y - c[0].1));+ let close = |a: [(f32, f32); 4], b: [(f32, f32); 4]| a.iter().zip(b).all(|(p, q)| (p.0 - q.0).abs() < 1e-3 && (p.1 - q.1).abs() < 1e-3);+ assert!(close(shape(trail.corners), shape(seen.corners)), "la traînée n'est pas le plan de la caméra d'avant");+ assert!(!close(shape(trail.corners), shape(upright.corners)), "la traînée est retombée sur un plan droit");+ }+/// Le calque du mode 8 porte la traînée dans le repère de ses propres coins, y compris/// reporté dans le slot d'un layout en bloc ; sans elle, rien de ce qu'il portait ne change.#[test]diff --git a/crates/compositor/tests/privacy_blur_under_zoom.rs b/crates/compositor/tests/privacy_blur_under_zoom.rsindex 6542232c5..75d781890 100644--- a/crates/compositor/tests/privacy_blur_under_zoom.rs+++ b/crates/compositor/tests/privacy_blur_under_zoom.rs@@ -135,3 +135,47 @@ fn a_privacy_mask_keeps_covering_its_content_under_zoom_and_tilt() {}assert!(leaks.is_empty(), "le masque laisse voir le secret :\n{}", leaks.join("\n"));}++/// Pendant la rampe d'un zoom, le flou de mouvement étale chaque pixel vers là où il était une+/// frame plus tôt : une copie traînée du secret sort de la position courante. Le masque doit la+/// couvrir aussi, sur l'écran droit (mode 0) comme incliné (mode 8). Cas rapporté en revue : un+/// `iso` ×2 de 2 à 4 s visant (0,3 ; 0,3), flou au maximum, à 1,1 s en pleine montée.+#[test]+fn a_privacy_mask_covers_the_motion_blur_trail_of_a_zoom() {+ let Ok(secret) = std::env::var("OPENSCREEN_PRIVACY_SECRET") else {+ println!("SKIP: definir OPENSCREEN_PRIVACY_SECRET (voir l'en-tete du fichier).");+ return;+ };+ let gpu = Gpu::create(false).expect("device d3d11");+ let render_at = |masked: bool, rotation: &str, blur: f32, t: f64| {+ let json = scene_json(&secret, masked, Some((2.0, 0.3, 0.3, rotation)))+ .replace(r#""startSec":0,"endSec":6,"scale""#, r#""startSec":2,"endSec":4,"scale""#)+ .replace(r#""motionBlur":0.0}"#, &format!(r#""motionBlur":{blur}}}"#));+ let mut cfg = config::all().pop().expect("au moins une config");+ cfg.zoom = false;+ cfg.layout_anim = false;+ let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");+ let scene = Scene::from_json(&json).expect("scene valide");+ comp.set_live_params(live_params_from_scene(&scene));+ comp.set_scene(Some(scene));+ comp.clear_cursor();+ unsafe {+ let mut player = Player::open(&secret, "", &gpu).expect("ouvrir la source");+ player.present_frame(&comp, &cfg, t).expect("composer la frame");+ comp.readback_resized(W, H).expect("readback")+ }+ };+ let mut leaks = Vec::new();+ for rotation in [r#""iso""#, "null"] {+ for t in [1.1, 1.3, 1.6, 4.3] {+ let clear = red_pixels(&render_at(false, rotation, 1.0, t));+ let exposed = red_pixels(&render_at(true, rotation, 1.0, t));+ println!("{rotation:<6} t={t:<4} flou 1 : rouge sans masque {clear:>6} avec masque {exposed:>4}");+ assert!(clear > 500, "{rotation} t={t} : le pave rouge n'est pas visible ({clear} px)");+ if exposed > 0 {+ leaks.push(format!("{rotation} t={t} : {exposed} px rouges visibles"));+ }+ }+ }+ assert!(leaks.is_empty(), "la traînée du flou sort du masque :\n{}", leaks.join("\n"));+}diff --git a/docs/3d-effects-v2.md b/docs/3d-effects-v2.mdindex a7ba274d0..adf0b703e 100644--- a/docs/3d-effects-v2.md+++ b/docs/3d-effects-v2.md@@ -49,12 +49,15 @@ mobile, qui tourne autour de l'écran.ci-dessous, sous l'identifiant `follow-cursor`. Un projet qui les porte encore s'ouvre à plat(valeur inconnue).-Les trois angles fixes gardent leurs valeurs et leur rendu **à l'octet** (vérifié contre le-commit de base : présets, cadre, flou de confidentialité, profondeur de champ, parallaxe, impact-du clic, flèche modélisée), avec la parallaxe de vitesse et l'impact du clic.+Les trois angles fixes ne roulent plus : Z vaut 0, parce que le tilt entre avec le zoom et qu'une+caméra qui bouge ne roule jamais le métrage (l'ancien roulis de −2°/±1° penchait l'image pendant+chaque zoom). Sans roulis, la règle des 2° ne laisse que deux bandes de tangage, ≤ 9° ou ≥ 15° :+`left` [−6,5, −17, 0], `right` [−6,5, 17, 0], `iso` [−23, −25, 0] (`regions::rotation3d_for`). Ils+se dessinent au warp **projectif** exact, comme la caméra réelle : le warp bilinéaire penchait à+lui seul la verticale du milieu de l'écran.« Turned right » veut dire que la face de l'écran regarde vers la droite : le bord droit-recule. C'est ce que fait `right` [−8, 16, 1] depuis toujours.+recule. C'est ce que fait `right` [−6,5, 17, 0].### A.3 `follow-cursor` : une caméra en orbite@@ -124,10 +127,10 @@ Chaînée à un angle fixe, une région `follow-cursor` ne mélange jamais les dtransition passe par l'écran droit à mi-course. Entre deux régions `follow-cursor`, le cadreur nedépend pas de la région : l'orbite continue sans à-coup pendant que le zoom change.-**Rendu exact.** Le warp bilinéaire des angles fixes s'écarte de la projection de cette caméra de+**Rendu exact.** Le warp bilinéaire s'écarte de la projection de cette caméra deplusieurs centaines de px au pire pixel visible (703 px sur l'enveloppe, 264 px sur la grillerendue). Les modes 8, 10, 13 et 14 prennent donc un warp-**projectif** exact sous cette caméra : l'homographie des quatre coins (forme de Heckbert) résolue à+**projectif** exact sous cette caméra, et depuis sous les angles fixes aussi : l'homographie des quatre coins (forme de Heckbert) résolue àl'envers dans le shader, drapeau par mode (`TiltedQuad::warp_flag` : `dst_prev.w` au mode 8, `mb.w`au 10, `mb.x` au 13, `src.x` au 14). Mesuré sur une grille rendue par D3D11, caméra tournée vers uncoin au zoom 2,2 : 0,07 px d'écart à la projection. `TiltedQuad` porte la caméra complète :@@ -163,8 +166,10 @@ lointain.- **`swing-clicks`** : à refaire sur `camera.rs`, l'orbite en donne la mécanique.- **`dolly`** (vertigo) : la distance de l'œil par frame, que `TiltedQuad::perspective` saitdéjà transporter.-- **Flou de mouvement sous la caméra** : le mode 8 n'en a pas. Le lissage borne le mouvement (voir- les mesures ci-dessus), sans limite de vitesse explicite.+- **Flou de mouvement de la visée** : le mode 8 a le flou du mode 0, borné à une frame, sur le plan+ d'une frame plus tôt (boîte du zoom, rotation de base, caméra réelle d'avant ;+ `FrameGeometry::tilt_trail`, `LayerCB::trail_*`). La parallaxe et l'impact n'y entrent pas,+ comme le focus au mode 0. Un masque de confidentialité couvre alors le secret aux deux frames.- **Lumière du curseur modélisé** : elle reste fixée à la caméra ; l'œil en orbite la déplace aveclui. À fixer au monde avec le propriétaire du mode 15.@@ -259,10 +264,9 @@ Deux décisions :1. **Le hotspot est sur le rayon de vue** du point de contenu visé, à sa hauteur. Il ne glissedonc jamais à l'écran quand le modèle monte ou descend : seule l'ombre dit la hauteur.-2. **Ancrage** : sous un angle fixe, la vidéo est dessinée par un warp **bilinéaire** des coins- projetés, qui s'écarte de la perspective exacte de quelques pixels. Tout le rendu est décalé- de `point_px(plane_pt) − projection exacte`, pour que le hotspot tombe sur le pixel que- l'écran montre. Sous la caméra réelle le warp est exact et ce décalage est nul.+2. **Ancrage** : tout le rendu est décalé de `point_px(plane_pt) − projection exacte`, pour que+ le hotspot tombe sur le pixel que l'écran montre. Le warp de l'écran étant exact (projectif),+ sous un angle fixe comme sous la caméra réelle, ce décalage est nul.### B.5 La pose (fonction pure de `t`)@@ -351,7 +355,7 @@ Seulement quand `model3d` est allumé (un curseur sans modèle n'a pas de contac**Rendu** : un carré du plan centré sur le point, dont les coins passent par la projection ducontenu (`TiltedQuad::point_px`), comme le sprite du mode 13 ; le shader inverse le warp-(bilinéaire sous un angle fixe, projectif sous la caméra réelle) et dessine un disque dans le+(projectif, celui de l'écran) et dessine un disque dans lecarré. L'anneau est donc posé sur le plan : ellipse sous `iso`, perspective exacte sous`follow-cursor`. Rien n'est dessiné hors de l'écran. Rust porte la courbe dans le temps(`impact_at`) ; les trois shaders ne dessinent que la forme de l'instant (`cursor_impact`).@@ -377,7 +381,7 @@ de la pastille ; plus rien après sa fenêtre.dans les mêmes conditions. Une lecture de texture coûte moins que les dix arêtes du polygone.- **Mémoire** : un champ par sprite chargé, sans éviction ; les seize sprites du thème pèsent~2,6 Mo de R16F.-- **`LayerCB`** reste à 128 octets ; l'emploi des emplacements aux modes 15 et 16 est documenté+- **`LayerCB`** fait 176 octets (les trois derniers vec4 portent la traînée du mode 8) ; l'emploi des emplacements aux modes 15 et 16 est documentéen tête des sections « Curseur modélisé » et « Impact du clic » de `frame_geometry.rs` et dansles trois structs de shader.- **Traînée au contact** : elle lit la position convergée (B.5.1), donc se replie sur une seule@@ -682,8 +686,8 @@ dans la boîte de dessin.- **Emplacements du cbuffer** : en tête de `device_frame_cb` (`frame_geometry.rs`), qui fait foi.`radius_px` / `color.b` = rayons des coins hauts / bas, concentriques, calculés côté Rust ;`dst_prev` = (angle du socle, rayon de l'ouverture, recouvrement, pénombre de l'ombre). Le plan- proche n'a pas d'emplacement : les shaders le tirent de `src.z / src.w` et de `mb.xy`. `LayerCB`- reste à 128 octets.+ proche n'a pas d'emplacement : les shaders le tirent de `src.z / src.w` et de `mb.xy`.+ (`LayerCB` n'y gagne rien.)### C.8 Limites