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): tilt the whole card under a filled format
EtienneLescot58fdafe13897
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex 2988aabc2..45909be89 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -3315,17 +3315,33 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {// ce correctif ; la coupe DESSINÉE ne porte plus que le crop. `remap_box` reporte la// seconde à travers le mapping de la première, ce qui conserve le cadrage exact.// Le focus courant reste volontairement utilisé pour la frame précédente, comme avant.+ //+ // Sous un plan incliné (angle fixe ou caméra réelle), le remplissage penche la CARTE : la+ // boîte est le slot, la coupe la fenêtre zoomée qu'il montre, et rien ne la rogne. Le slot+ // n'y est pas un conteneur qu'on voit, comme dans un bloc : rogner à son rect droit le plan+ // de l'enregistrement entier y coupait des coins à plat. Sous la caméra réelle, c'est sa+ // visée qui cadre le zoom (`regions::resolve_focus` laisse la boîte zoomer sur son centre).+ let fill_tilt =+ follow && (zoom_camera > 0.0 || !crate::regions::is_identity_rotation(zoom_rotation));+ let focus = if fill_tilt && zoom_camera > 0.0 { zoom_aim } else { p.focus };let cut_ref =- cover(screen_source_rect(u_max, v_max, active_crop, p.zoom, p.focus), follow_at(source_t));+ cover(screen_source_rect(u_max, v_max, active_crop, p.zoom, focus), follow_at(source_t));let cut_ref_prev = cover(- screen_source_rect(u_max, v_max, active_crop, pp.zoom, p.focus),+ screen_source_rect(u_max, v_max, active_crop, pp.zoom, focus),follow_at(source_t_prev),);// Sous le remplissage, la coupe dessinée est le crop ENTIER : la fenêtre bouge, et une// coupe dessinée qui ne la contiendrait plus laisserait un trou dans le slot. Le masque du// slot (`screen_mask`) rogne le reste.let crop_cut = screen_source_rect(u_max, v_max, active_crop, 1.0, p.focus);- let cut = if follow { crop_cut } else { cover(crop_cut, None) };+ // Le remplissage incliné dessine la fenêtre zoomée elle-même : sa boîte est le slot.+ let cut = if fill_tilt {+ cut_ref+ } else if follow {+ crop_cut+ } else {+ cover(crop_cut, None)+ };// Ce que l'écran montre au repos : la fenêtre couverte, suivie ou non. Le curseur, les coins// et l'ombre se mesurent sur elle, pas sur la coupe entière que le remplissage dessine.let window = cover(crop_cut, follow_at(source_t));@@ -3356,24 +3372,38 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {// même report dans la coupe (un cover la rogne). La mise au point suit le pointeur lissé// (l'orbite), pas le point visé : celui-ci reste au centre au zoom 1 et bute sur sa portée// au zoom, là où le spectateur regarde le pointeur.- let camera = (zoom_camera > 0.0).then(|| crate::camera::CameraPose {- weight: zoom_camera,- aim: focus_in_cut(u_max, v_max, active_crop, zoom_aim, cut),- orbit: focus_in_cut(u_max, v_max, active_crop, zoom_orbit, cut),- zoom: p.zoom,- press,- });+ // Sous le remplissage incliné, la coupe est déjà la fenêtre zoomée : la caméra filme la+ // carte au zoom 1, entière et contenue dans son slot depuis toute l'orbite+ // (`camera::View::new`), et l'œil se place sur le pointeur dans l'enregistrement entier,+ // où vit le poids de l'orbite (rapportée à la fenêtre, elle sauterait à l'entrée du zoom).+ let pose = |weight: f32, aim: [f32; 2], orbit: [f32; 2], zoom: f32| {+ if fill_tilt {+ crate::camera::CameraPose {+ weight,+ aim: [0.5; 2],+ orbit: focus_in_cut(u_max, v_max, active_crop, orbit, crop_cut),+ zoom: 1.0,+ press,+ }+ } else {+ crate::camera::CameraPose {+ weight,+ aim: focus_in_cut(u_max, v_max, active_crop, aim, cut),+ orbit: focus_in_cut(u_max, v_max, active_crop, orbit, cut),+ zoom,+ press,+ }+ }+ };+ let camera = (zoom_camera > 0.0).then(|| pose(zoom_camera, zoom_aim, zoom_orbit, p.zoom));// 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,- press,- });+ let camera_prev = (zoom_camera_prev > 0.0)+ .then(|| pose(zoom_camera_prev, zoom_aim_prev, zoom_orbit_prev, pp.zoom));let focus_plane = match camera {+ // Le pointeur sur la carte, là où l'orbite du remplissage n'est pas dans la coupe.+ Some(_) if fill_tilt => focus_in_cut(u_max, v_max, active_crop, zoom_orbit, cut),Some(pose) => pose.orbit,None => focus_in_cut(u_max, v_max, active_crop, p.focus, cut),};@@ -3490,7 +3520,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {// l'app le lève pour ces deux layouts, sur un clip qui a une caméra, et pour le// remplissage du format, qui exclut les cadres (`formatFillAvailability`). Un cadre sous// un slot est donc toujours dans un bloc : il y devient le conteneur, au repos autour.- let screen_mask = scene.is_some_and(|s| s.layout.screen_cover).then(|| {+ // Le remplissage incliné n'a pas de masque : sa boîte est le slot, et la carte penche entière.+ let screen_mask = (scene.is_some_and(|s| s.layout.screen_cover) && !fill_tilt).then(|| {let slot_px = [s_base[2] * rw, s_base[3] * rh];ScreenMask {rect: s_base,@@ -6348,6 +6379,11 @@ mod tests {/// Un clip 16:9 dans une sortie 9:16 remplie (`screenCover` + `screenFollow`) : la boîte écran/// est la zone paddée entière, `follow` décide si la fenêtre suit le pointeur.fn fill_plan(follow: bool, pointer: Option<(f32, f32)>) -> FrameGeometry {+ fill_plan_with(follow, pointer, "[]")+ }++ /// `fill_plan`, avec ces `zoomRegions`.+ fn fill_plan_with(follow: bool, pointer: Option<(f32, f32)>, zoom_regions: &str) -> FrameGeometry {let scene = Scene::from_json(&format!(r##"{{"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],@@ -6356,8 +6392,8 @@ mod tests {"screenCover":true,"screenFollow":{follow}}},"effects":{{"padding":0.5,"blur":false,"shadow":0.5,"roundnessFrac":0.02,"motionBlur":0}},"background":{{"kind":"color","color":"#1e1e2e"}},- "zoomRegions":[],- "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},+ "zoomRegions":{zoom_regions},+ "cursor":{{"show":true,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},"cropByClip":[null],"output":{{"width":1080,"height":1920,"fps":60}}}}"##@@ -6408,6 +6444,69 @@ mod tests {}}+ /// Le remplissage sous un plan incliné, angle fixe ou caméra en orbite : c'est la CARTE qui+ /// penche, entière, ses quatre coins arrondis. Son slot n'est pas un conteneur qu'on voit,+ /// comme celui d'un bloc : y rogner le plan de l'enregistrement entier coupait des coins à plat+ /// (v2.0.0 à v2.1.0).+ ///+ /// * aucun masque ne rogne le plan, et sa boîte est le slot ;+ /// * la carte montre ce qu'un zoom à plat y montre : la même fenêtre zoomée ;+ /// * le plan tient dans la sortie, centré sur le slot ;+ /// * à plat, rien ne change : le slot masque toujours la boîte zoomée.+ #[test]+ fn a_tilted_zoom_tilts_the_whole_filled_card() {+ let render = [1080.0f32, 1920.0];+ let zoom = |rotation: &str| {+ format!(r#"[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.3,"focusY":0.6,"rotation":{rotation}}}]"#)+ };+ let pointer = Some((0.85, 0.8));+ // La fenêtre que la carte montre, en UV : le slot reporté par s_dst → cut.+ let seen = |g: &FrameGeometry| -> [f32; 4] {+ let (s, d, c) = (g.s_ann, g.s_dst, g.cut);+ let x = |f: f32| c[0] + (f - d[0]) / d[2] * (c[2] - c[0]);+ let y = |f: f32| c[1] + (f - d[1]) / d[3] * (c[3] - c[1]);+ [x(s[0]), y(s[1]), x(s[0] + s[2]), y(s[1] + s[3])]+ };+ for (rotation, flat_rotation) in [+ (r#""iso""#, "null"),+ (r#""right""#, "null"),+ (ORBIT, r#"null,"focusMode":"auto""#),+ ] {+ let flat = fill_plan_with(true, pointer, &zoom(flat_rotation));+ assert!(!flat.tilted(), "{rotation} : garde, le zoom à plat est droit");+ assert!(flat.screen_mask.is_some(), "{rotation} : à plat, le slot masque la boîte zoomée");+ assert!(!contains(flat.s_ann, flat.s_dst, 1e-3), "{rotation} : garde, la boîte à plat déborde");++ let g = fill_plan_with(true, pointer, &zoom(rotation));+ assert!(g.tilted(), "{rotation} : garde, l'écran doit pencher");+ assert_eq!(g.screen_mask, None, "{rotation} : un rect droit rogne la carte inclinée");+ for k in 0..4 {+ assert!((g.s_dst[k] - g.s_ann[k]).abs() < 1e-5, "{rotation} : boîte {:?}, slot {:?}", g.s_dst, g.s_ann);+ }+ let (w, wf) = (seen(&g), seen(&flat));+ for k in 0..4 {+ assert!((w[k] - wf[k]).abs() < 1e-4, "{rotation} : fenêtre {w:?}, à plat {wf:?}");+ }++ let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];+ let quad = g.screen_tilt(s_px).expect("incliné");+ let c = g.screen_center_px(render);+ let slot_c = [(g.s_ann[0] + g.s_ann[2] * 0.5) * render[0], (g.s_ann[1] + g.s_ann[3] * 0.5) * render[1]];+ let mut mean = [0.0f32; 2];+ for &(x, y) in &quad.corners {+ let (x, y) = (c[0] + x, c[1] + y);+ assert!((0.0..=render[0]).contains(&x) && (0.0..=render[1]).contains(&y), "{rotation} : coin ({x}, {y}) hors de la sortie");+ mean = [mean[0] + x * 0.25, mean[1] + y * 0.25];+ }+ let off = (mean[0] - slot_c[0]).hypot(mean[1] - slot_c[1]);+ assert!(off < 0.1 * s_px[0].min(s_px[1]), "{rotation} : carte à {off} px du slot");++ let cb = tilted_screen_cb(&quad, s_px, c, g.cut, g.focus_plane, g.s_radius, 0.0, false, render, g.screen_mask, None);+ assert_eq!(cb.color[3], 0.0, "{rotation} : aucun slot ne rogne le plan");+ assert!(cb.radius_px > 1.0, "{rotation} : coins arrondis attendus, rayon {}", cb.radius_px);+ }+ }+/// `slot_scene` à 1,5 s (zoom tenu), pointeur garé en `pointer` (la caméra en orbite le suit).fn slot_plan(scene: &Scene, pointer: Option<(f32, f32)>) -> FrameGeometry {let cfg = crate::config::all().pop().expect("au moins une config");diff --git a/crates/compositor/tests/format_fill_tilt_render.rs b/crates/compositor/tests/format_fill_tilt_render.rsnew file mode 100644index 000000000..2adb8b15d--- /dev/null+++ b/crates/compositor/tests/format_fill_tilt_render.rs@@ -0,0 +1,142 @@+//! Le remplissage du format sous la caméra en orbite, rendu par le vrai compositeur D3D11.+//!+//! Un enregistrement 4:3 remplit une sortie 16:9 (`screenCover` + `screenFollow`), zoom ×2 en+//! orbite, pointeur garé en bas à droite : la caméra tourne à fond. La carte doit pencher ENTIÈRE,+//! ses quatre coins arrondis. De v2.0.0 à v2.1.0, le plan de l'enregistrement entier penchait+//! dans le rect droit du slot, qui le rognait : des coins coupés à plat, par une arête alignée sur+//! les axes, alors que la carte tenait dans la sortie.+//!+//! Frame NV12 synthétique et unie, fond noir, sans ombre : le métrage est clair, tout le reste+//! noir. Sans adaptateur matériel, le test se saute.++// Windows seulement : le readback et le décodage D3D11VA de ce harnais n'existent que là.+#![cfg(windows)]++use openscreen_compositor::compositor::Compositor;+use openscreen_compositor::config::Cfg;+use openscreen_compositor::cursor::CursorTrack;+use openscreen_compositor::frame_geometry::{live_params_from_scene, plan_frame, FrameGeometryInput};+use openscreen_compositor::scene::Scene;++mod common;+use common::{gpu, Nv12Frame};++const SRC: (u32, u32) = (640, 480);+const OUT: (u32, u32) = (1280, 720);+/// En plein palier de la région (0..10 s), le cadreur posé.+const T: f32 = 3.0;++fn scene() -> Scene {+ Scene::from_json(+ r##"{"clips":[{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}],+ "layout":{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false,+ "screenRect":{"x":0.1,"y":0.1,"width":0.8,"height":0.8},"screenCover":true,"screenFollow":true},+ "effects":{"padding":0.2,"blur":false,"shadow":0,"roundnessFrac":0.04,"motionBlur":0,"depthOfField":false},+ "background":{"kind":"color","color":"#000000"},+ "zoomRegions":[{"clipIndex":0,"startSec":0,"endSec":10,"scale":2.0,"focusX":0.5,"focusY":0.5,"focusMode":"auto","rotation":"orbit"}],+ "annotations":[],+ "cursor":{"show":true,"size":0.05,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"none"},+ "cropByClip":[null],+ "output":{"width":1280,"height":720,"fps":30}}"##,+ )+ .expect("scène valide")+}++/// Pointeur garé en (x, y), échantillonné à 60 Hz sur 10 s, écrit dans un sidecar temporaire.+fn parked(x: f32, y: f32) -> CursorTrack {+ let body: Vec<String> =+ (0..=600).map(|i| format!(r#"{{"timeMs":{},"cx":{x},"cy":{y}}}"#, (i as f32 * 1000.0 / 60.0).round())).collect();+ let path = std::env::temp_dir().join(format!("os_fill_tilt_{}.json", std::process::id()));+ std::fs::write(&path, format!(r#"{{"samples":[{}]}}"#, body.join(","))).expect("sidecar");+ let track = CursorTrack::load(path.to_str().unwrap(), 0.0, 10.0).expect("piste curseur");+ let _ = std::fs::remove_file(&path);+ track+}++fn cfg() -> Cfg {+ let mut cfg = Cfg::c8();+ cfg.bg_blur = 0.0;+ cfg.zoom = false;+ cfg.layout_anim = false;+ cfg.cursor = true;+ cfg.mblur_n = 1;+ cfg.shadow = false;+ cfg+}++/// Hors de la sortie, rien n'est dessiné : noir, comme le fond.+fn luma(rgba: &[u8], x: f32, y: f32) -> f32 {+ let (x, y) = (x.round() as i32, y.round() as i32);+ if !(0..OUT.0 as i32).contains(&x) || !(0..OUT.1 as i32).contains(&y) {+ return 0.0;+ }+ let i = ((y * OUT.0 as i32 + x) * 4) as usize;+ 0.2126 * rgba[i] as f32 + 0.7152 * rgba[i + 1] as f32 + 0.0722 * rgba[i + 2] as f32+}++/// Chaque coin de la carte inclinée est arrondi : sur la bissectrice, à 0,15 rayon du sommet+/// projeté, le fond (l'arrondi l'a retiré) ; à 1,3 rayon, le métrage. Un coin coupé par le rect+/// du slot laissait du noir là où la carte devait être, ou la poussait hors de la sortie.+#[test]+fn every_corner_of_a_filled_card_stays_rounded_under_the_orbit() {+ let Some(gpu) = gpu() else { return };+ let comp = Compositor::new_sized(&gpu, OUT.0, OUT.1).expect("compositor");+ let screen = Nv12Frame::new(&gpu, SRC, |_, _| 220, |_, _| [128, 128]);+ let scene = scene();+ let track = parked(0.9, 0.9);++ let mut live = live_params_from_scene(&scene);+ live.has_webcam = false;+ comp.set_live_params(live);+ comp.set_has_webcam(false);+ comp.set_scene(Some(scene.clone()));+ comp.set_cursor(track.clone());+ comp.set_cursor_time(Some(T));+ comp.set_timeline_time(Some(T));+ let cfg = cfg();+ let (w, h, rgba) = unsafe {+ comp.compose_frame(screen.as_ptr(), screen.as_ptr(), 0.0, &cfg).expect("compose_frame");+ comp.readback_direct().expect("readback")+ };+ assert_eq!((w, h), OUT);+ if let Ok(dir) = std::env::var("OPENSCREEN_FILL_TILT_OUT") {+ image::RgbaImage::from_raw(w, h, rgba.clone()).unwrap().save(format!("{dir}/fill-orbit.png")).unwrap();+ }++ let render_px = [w as f32, h as f32];+ let src = [SRC.0 as f32, SRC.1 as f32];+ let g = plan_frame(&FrameGeometryInput {+ render_px,+ screen_tex_px: src,+ screen_visible_px: src,+ webcam_visible_px: src,+ u_max: 1.0,+ v_max: 1.0,+ frame: 0.0,+ cfg: &cfg,+ live,+ scene: Some(&scene),+ cursor: Some(&track),+ timeline_t_override: Some(T),+ programme_time: None,+ });+ let camera = g.camera.expect("la caméra réelle doit être posée");+ assert!(camera.orbit[0] > 0.8, "garde : la caméra doit tourner à fond, orbite {:?}", camera.orbit);+ let s_px = [g.s_dst[2] * render_px[0], g.s_dst[3] * render_px[1]];+ let quad = g.screen_tilt(s_px).expect("quad de la caméra");+ let center = [(g.s_dst[0] + g.s_dst[2] * 0.5) * render_px[0], (g.s_dst[1] + g.s_dst[3] * 0.5) * render_px[1]];+ let r = g.s_radius * quad.scale;+ assert!(r > 20.0, "garde : rayon {r} px, trop petit pour se mesurer");++ let corners = quad.corners.map(|(x, y)| [center[0] + x, center[1] + y]);+ let mid = [corners.iter().map(|c| c[0]).sum::<f32>() / 4.0, corners.iter().map(|c| c[1]).sum::<f32>() / 4.0];+ for (name, c) in ["haut-gauche", "haut-droit", "bas-droit", "bas-gauche"].iter().zip(corners) {+ let (dx, dy) = (mid[0] - c[0], mid[1] - c[1]);+ let n = dx.hypot(dy);+ let at = |k: f32| luma(&rgba, c[0] + dx / n * k * r, c[1] + dy / n * k * r);+ let (rounded, inside) = (at(0.15), at(1.3));+ println!("coin {name} ({:.0}, {:.0}) : arrondi {rounded:.0}, dedans {inside:.0}", c[0], c[1]);+ assert!(rounded < 40.0, "coin {name} : pas arrondi (luma {rounded:.0} au sommet)");+ assert!(inside > 150.0, "coin {name} : la carte est coupée (luma {inside:.0} à 1,3 rayon)");+ }+}