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(annotations): masks and their gimbals follow the footage, arrows get a tight gimbal
EtienneLescot00a4d0049a7c
diff --git a/crates/compositor-view-napi/src/lib.rs b/crates/compositor-view-napi/src/lib.rsindex 8701c8bfe..185f48d43 100644--- a/crates/compositor-view-napi/src/lib.rs+++ b/crates/compositor-view-napi/src/lib.rs@@ -197,6 +197,12 @@ pub struct FramePacket {/// R,G,B,A tightly-packed, `width * height * 4` octets — ce que `putImageData` //// `ImageData` attendent côté JS (canvas 2D, format natif RGBA8).pub data: Buffer,+ /// Le métrage dans cette image : ses coins TL, TR, BR, BL (x, y en fractions de l'image,+ /// huit nombres), là où l'éditeur pose le gimbal d'un flou. Absent avant toute composition.+ pub footage: Option<Vec<f64>>,+ /// Le métrage passe de ses coins à l'image par leur homographie (caméra réelle), pas par+ /// leur interpolation bilinéaire.+ pub footage_projective: bool,}/// Renvoie la dernière frame readback du thread de rendu SI elle est plus récente que@@ -236,13 +242,15 @@ pub fn read_frame(id: i32, since_gen: f64) -> Result<Option<FramePacket>> {v.latest_frame_since(since_gen.max(0.0) as u64)}};- Ok(slot.map(|(gen, w, h, pixels)| {+ Ok(slot.map(|(gen, w, h, pixels, footage)| {debug_assert_eq!(pixels.len(), (w as usize) * (h as usize) * 4);FramePacket {gen: gen as f64,width: w,height: h,data: Buffer::from(pixels),+ footage: footage.map(|q| q.corners.iter().flatten().map(|&v| v as f64).collect()),+ footage_projective: footage.is_some_and(|q| q.projective),}}))}diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex 3b9a97a31..f49974d47 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -327,6 +327,8 @@ pub struct Compositor {scene: RefCell<Option<Scene>>,cursor: RefCell<Option<crate::cursor::CursorTrack>>,cursor_time: RefCell<Option<f32>>,+ /// Le métrage dans la dernière image composée, que l'éditeur lit avec elle (`live.rs`).+ footage: std::cell::Cell<Option<crate::frame_geometry::FootageQuad>>,timeline_time: RefCell<Option<f32>>,/// Temps programme (secondes de sortie) -- cf. `FrameGeometryInput::programme_time`.programme_time: RefCell<Option<f32>>,@@ -711,6 +713,7 @@ impl Compositor {scene: RefCell::new(None),cursor: RefCell::new(None),cursor_time: RefCell::new(None),+ footage: std::cell::Cell::new(None),timeline_time: RefCell::new(None),programme_time: RefCell::new(None),text_raster: crate::text::TextRasterizer::new().ok(),@@ -2055,6 +2058,11 @@ impl Compositor {*self.webcam_mask.borrow_mut() = None;}+ /// Le métrage dans la dernière image composée : ses coins et son warp (`FootageQuad`).+ pub fn footage_quad(&self) -> Option<crate::frame_geometry::FootageQuad> {+ self.footage.get()+ }+/// Rend une frame dans le RT interne. Le screen `screen`/`webcam` sont des/// carriers `linux_frames` ; la geometrie vient de `plan_frame`. Coeur :/// fond uni + ecran cover-fit. `readback_direct` lit ensuite le RT.@@ -2130,6 +2138,7 @@ impl Compositor {timeline_t_override: *self.timeline_time.borrow(),programme_time: *self.programme_time.borrow(),});+ self.footage.set(Some(g.footage_quad([rw, rh])));// (`wtw`/`wth` sont les dims de la TEXTURE webcam, consommees par le// cover-crop du calque PiP plus bas.)diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rsindex ad4bbf28e..64f048365 100644--- a/crates/compositor/src/compositor_macos.rs+++ b/crates/compositor/src/compositor_macos.rs@@ -261,6 +261,8 @@ pub struct Compositor {scene: RefCell<Option<Scene>>,cursor: RefCell<Option<crate::cursor::CursorTrack>>,cursor_time: RefCell<Option<f32>>,+ /// Le métrage dans la dernière image composée, que l'éditeur lit avec elle (`live.rs`).+ footage: std::cell::Cell<Option<crate::frame_geometry::FootageQuad>>,timeline_time: RefCell<Option<f32>>,/// Temps programme (secondes de sortie) — cf. `FrameGeometryInput::programme_time`.programme_time: RefCell<Option<f32>>,@@ -682,6 +684,7 @@ impl Compositor {scene: RefCell::new(None),cursor: RefCell::new(None),cursor_time: RefCell::new(None),+ footage: std::cell::Cell::new(None),timeline_time: RefCell::new(None),programme_time: RefCell::new(None),live_params: RefCell::new(LiveParams::default()),@@ -2154,6 +2157,11 @@ impl Compositor {}}+ /// Le métrage dans la dernière image composée : ses coins et son warp (`FootageQuad`).+ pub fn footage_quad(&self) -> Option<crate::frame_geometry::FootageQuad> {+ self.footage.get()+ }+/// Compose la frame : fond, ombre écran, écran, ombre caméra, caméra — puis miroir/// `Shared` pour la lecture CPU.///@@ -2223,6 +2231,7 @@ impl Compositor {timeline_t_override: *self.timeline_time.borrow(),programme_time: *self.programme_time.borrow(),});+ self.footage.set(Some(g.footage_quad([rw, rh])));let cmd_buf = self.gpu.context.new_command_buffer();// Profondeur de champ : pyramide remplie seulement sur une frame inclinée qui la lit,diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rsindex 72ce180de..cfe335143 100644--- a/crates/compositor/src/compositor_windows.rs+++ b/crates/compositor/src/compositor_windows.rs@@ -142,6 +142,8 @@ pub struct Compositor {/// (`frame / FPS`). L'export multiclip et le live le positionnent au PTS écran courant,/// c'est-à-dire au temps source absolu du clip actif.cursor_t_override: RefCell<Option<f32>>,+ /// Le métrage dans la dernière image composée, que l'éditeur lit avec elle (`live.rs`).+ footage: std::cell::Cell<Option<crate::frame_geometry::FootageQuad>>,/// Override du temps des zoom/full-camera regions (secondes source du clip actif). Le nom/// `timeline_t_override` est conservé pour l'API existante, mais ce temps n'est plus cumulé/// entre clips : les régions projetées par l'app portent elles aussi des temps source.@@ -724,6 +726,7 @@ impl Compositor {trail_srv,cursor: RefCell::new(None),cursor_t_override: RefCell::new(None),+ footage: std::cell::Cell::new(None),timeline_t_override: RefCell::new(None),programme_time: RefCell::new(None),srv_cache: RefCell::new(HashMap::new()),@@ -1912,6 +1915,11 @@ impl Compositor {});}+ /// Le métrage dans la dernière image composée : ses coins et son warp (`FootageQuad`).+ pub fn footage_quad(&self) -> Option<crate::frame_geometry::FootageQuad> {+ self.footage.get()+ }+/// Compose une frame animée (§6/§8) : fond flouté + screen zoomé (padding, coins, ombre)/// + webcam crop carré (coins, ombre), placements interpolés A↔B par la timeline.pub unsafe fn compose_frame(@@ -1955,6 +1963,7 @@ impl Compositor {timeline_t_override: *self.timeline_t_override.borrow(),programme_time: *self.programme_time.borrow(),});+ self.footage.set(Some(g.footage_quad([self.rw(), self.rh()])));let scene_preset = g.scene_preset.clone();let mb_taps = g.mb_taps;let mb_amount = g.mb_amount;diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex 4aee32a9d..bfb8f9391 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -2658,10 +2658,6 @@ 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.@@ -2672,28 +2668,29 @@ impl FrameGeometry {.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)]);+ // 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 garde la+ // perspective du quad courant, élargi de la plus grande avance d'un de ses coins : chaque+ // coin d'avant tombe dedans, donc tout le secret d'avant aussi (un quad convexe contient+ // l'enveloppe de ses coins), et la traînée, qui va de l'un à l'autre. Même warp que le+ // shader sur les coins d'avant (le drapeau projectif est celui du plan). Sans mouvement,+ // la traînée EST le quad (au bit près) : rien de plus à couvrir.+ let trail = self.tilt_trail(render_px).filter(|t| t.corners != quad.corners);+ let pts = match trail {+ Some(trail) => {+ 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 prev = [then(x0, y0), then(x1, y0), then(x1, y1), then(x0, y1)];+ let reach = (0..4)+ .map(|i| (prev[i][0] - pts[i][0]).hypot(prev[i][1] - pts[i][1]))+ .fold(0.0f32, f32::max);+ grow_quad(pts, reach + 0.5)}- 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);- }+ None => pts,+ };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 {@@ -2721,9 +2718,65 @@ impl FrameGeometry {warp: Some(local),projective: quad.projective,strength,- oval_ok: true,+ // Un ovale inscrit dans le quad élargi ne couvrirait plus sûrement l'ovale d'avant.+ oval_ok: trail.is_none(),})}++ /// Où tombe le métrage dans l'image (`FootageQuad`) : là où `privacy_mask` pose un masque,+ /// donc là où l'éditeur doit poser le gimbal d'un flou pour qu'il couvre ce qu'il cache.+ pub fn footage_quad(&self, render_px: [f32; 2]) -> FootageQuad {+ let [rw, rh] = render_px;+ let s_px = [self.s_dst[2] * rw, self.s_dst[3] * rh];+ if let Some(quad) = self.screen_tilt(s_px).filter(|_| self.tilted() && rw > 0.0 && rh > 0.0) {+ let centre = self.screen_center_px(render_px);+ let at = |fx: f32, fy: f32| {+ let (px, py) = quad.point_px(fx, fy);+ [(centre[0] + px) / rw, (centre[1] + py) / rh]+ };+ return FootageQuad {+ corners: [at(0.0, 0.0), at(1.0, 0.0), at(1.0, 1.0), at(0.0, 1.0)],+ projective: quad.projective,+ };+ }+ let [x, y, w, h] = self.s_dst;+ FootageQuad { corners: [[x, y], [x + w, y], [x + w, y + h], [x, y + h]], projective: false }+ }+}++/// Le métrage dans l'image : ses coins TL, TR, BR, BL en fractions de la sortie, et la+/// correspondance d'un point `(u, v)` du métrage à l'image, bilinéaire entre eux ou, sous la+/// caméra réelle, l'homographie qu'ils définissent (`TiltedQuad::point_px`).+#[derive(Debug, Clone, Copy, PartialEq)]+pub struct FootageQuad {+ pub corners: [[f32; 2]; 4],+ pub projective: bool,+}++/// Le quad convexe `pts` (TL, TR, BR, BL) dont chaque côté recule de `d` px vers l'extérieur :+/// ses côtés restent parallèles aux siens, donc sa perspective aussi, et il contient tout point+/// à moins de `d` de lui.+fn grow_quad(pts: [[f32; 2]; 4], d: f32) -> [[f32; 2]; 4] {+ // L'extérieur d'un côté est d'un bord ou de l'autre selon le sens de parcours.+ let area: f32 = (0..4)+ .map(|i| {+ let (a, b) = (pts[i], pts[(i + 1) % 4]);+ a[0] * b[1] - b[0] * a[1]+ })+ .sum();+ let side = area.signum();+ let normal = |i: usize| {+ let (a, b) = (pts[i], pts[(i + 1) % 4]);+ let (ex, ey) = (b[0] - a[0], b[1] - a[1]);+ let len = ex.hypot(ey).max(1e-6);+ [side * ey / len, -side * ex / len]+ };+ std::array::from_fn(|i| {+ // Le coin glisse sur la bissectrice jusqu'à la rencontre des deux côtés reculés.+ let (na, nb) = (normal((i + 3) % 4), normal(i));+ let k = d / (1.0 + na[0] * nb[0] + na[1] * nb[1]).max(0.2);+ [pts[i][0] + (na[0] + nb[0]) * k, pts[i][1] + (na[1] + nb[1]) * k]+ })}/// Marge ajoutée autour d'un masque de confidentialité, en px de la boîte écran AU REPOS : un@@ -6892,6 +6945,87 @@ mod tests {}}+ /// Le point `p` est dans le quad convexe `q` (TL, TR, BR, BL, px de sortie).+ fn in_convex_quad(q: [[f32; 2]; 4], p: [f32; 2]) -> bool {+ let side = |i: usize| {+ let (a, b) = (q[i], q[(i + 1) % 4]);+ (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0])+ };+ (0..4).all(|i| side(i) >= -1e-3) || (0..4).all(|i| side(i) <= 1e-3)+ }++ /// Sous l'orbite, la caméra suit le pointeur et le flou de mouvement étale le contenu vers+ /// sa position de la frame d'avant : le masque garde la perspective du contenu (un quad warpé+ /// aux côtés parallèles aux siens, pas un rect droit) et couvre le secret aux deux frames.+ #[test]+ fn a_moving_tilted_mask_keeps_its_perspective() {+ let cfg = crate::config::all().pop().expect("au moins une config");+ let json = zoomed_golden_scene_json()+ .replace(r#""rotation":"none""#, r#""rotation":"orbit","focusMode":"auto""#);+ let scene = Scene::from_json(&json).expect("scène");+ // Le pointeur file vers la droite : l'orbite le suit, la caméra bouge à chaque frame.+ let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(crate::cursor::CursorTrack::new(+ (0..=90).map(|i| (i as f32 / 30.0, 0.05 + 0.5 * i as f32 / 90.0, 0.3)).collect(),+ vec![],+ vec![],+ )));+ let g = plan_frame(&FrameGeometryInput { cursor: Some(track), ..golden_input(&scene, &cfg) });+ let render = [1170.0, 658.0];+ let quad = g.screen_tilt([g.s_dst[2] * render[0], g.s_dst[3] * render[1]]).expect("orbite");+ let trail = g.tilt_trail(render).expect("garde : flou de mouvement actif sous l'orbite");+ assert_ne!(trail.corners, quad.corners, "garde : la caméra doit bouger d'une frame à l'autre");+ let a = blur_annotation("");+ let m = g.privacy_mask(&a, render).expect("masque");+ let warp = m.warp.expect("le masque d'un écran incliné qui bouge reste un quad warpé");+ let origin = [m.dst[0] * render[0], m.dst[1] * render[1]];+ let mask = warp.map(|[x, y]| [origin[0] + x, origin[1] + y]);+ let centre = [(g.s_dst[0] + g.s_dst[2] * 0.5) * render[0], (g.s_dst[1] + g.s_dst[3] * 0.5) * render[1]];+ let before = crate::regions::TiltedQuad { corners: trail.corners, ..quad };+ for q in [quad, before] {+ for (fx, fy) in [(a.x, a.y), (a.x + a.w, a.y), (a.x + a.w, a.y + a.h), (a.x, a.y + a.h)] {+ let (px, py) = q.point_px(fx, fy);+ let p = [centre[0] + px, centre[1] + py];+ assert!(in_convex_quad(mask, p), "{p:?} hors du masque {mask:?}");+ }+ }+ let (tl, tr) = (quad.point_px(a.x, a.y), quad.point_px(a.x + a.w, a.y));+ let content = (tr.1 - tl.1) / (tr.0 - tl.0);+ assert!(content.abs() > 1e-3, "garde : l'orbite doit incliner le haut du secret ({content})");+ let top = (mask[1][1] - mask[0][1]) / (mask[1][0] - mask[0][0]);+ assert!((top - content).abs() < 1e-3, "le haut du masque ({top}) doit suivre celui du contenu ({content})");+ assert!(!m.oval_ok, "un masque élargi à la trace doit refuser l'ovale");+ }++ /// Le métrage que l'éditeur lit avec l'image : le rect zoomé à plat, le quad incliné du mode 8+ /// sous un préset, l'homographie de ses coins sous la caméra réelle.+ #[test]+ fn the_footage_quad_is_where_masks_land() {+ let cfg = crate::config::all().pop().expect("au moins une config");+ let render = [1170.0, 658.0];+ let flat = plan_frame(&golden_input(&zoomed_golden_scene(), &cfg));+ let [x, y, w, h] = flat.s_dst;+ assert_eq!(+ flat.footage_quad(render),+ FootageQuad { corners: [[x, y], [x + w, y], [x + w, y + h], [x, y + h]], projective: false }+ );+ let tilted = plan_frame(&golden_input(&tilted_golden_scene(), &cfg));+ let q = tilted.footage_quad(render);+ let quad = tilted.screen_tilt([tilted.s_dst[2] * render[0], tilted.s_dst[3] * render[1]]).expect("iso");+ let centre = [+ (tilted.s_dst[0] + tilted.s_dst[2] * 0.5) * render[0],+ (tilted.s_dst[1] + tilted.s_dst[3] * 0.5) * render[1],+ ];+ for (k, (cx, cy)) in quad.corners.iter().enumerate() {+ let want = [(centre[0] + cx) / render[0], (centre[1] + cy) / render[1]];+ assert!((q.corners[k][0] - want[0]).abs() < 1e-5 && (q.corners[k][1] - want[1]).abs() < 1e-5, "coin {k}");+ }+ assert!(!q.projective);+ let json = zoomed_golden_scene_json()+ .replace(r#""rotation":"none""#, r#""rotation":"orbit","focusMode":"auto""#);+ let orbit = plan_frame(&golden_input(&Scene::from_json(&json).expect("scène"), &cfg));+ assert!(orbit.footage_quad(render).projective, "la caméra réelle warpe par homographie");+ }+/// Une entrée mesurée sur le cadre de sortie n'est pas concernée par le zoom.#[test]fn a_privacy_mask_in_frame_space_ignores_the_zoom() {diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rsindex ebcb46388..af586f262 100644--- a/crates/compositor/src/live.rs+++ b/crates/compositor/src/live.rs@@ -764,7 +764,7 @@ fn scene_for_clip(scene: &Scene, clip_index: usize) -> Scene {/// est l'IDENTITÉ de la frame : le consommateur (`read_frame`) ne repaie le clone + l'IPC/// que lorsqu'elle change. `None` = "aucune frame composée pour l'instant" (toutes les/// lectures avant la 1re frame composée retournent `None` côté napi, jamais un buffer vide).-type LatestFrame = (u64, u32, u32, Vec<u8>);+pub type LatestFrame = (u64, u32, u32, Vec<u8>, Option<crate::frame_geometry::FootageQuad>);/// État partagé thread appelant → thread de rendu (commandes sans blocage).struct Shared {@@ -894,7 +894,7 @@ impl LiveView {/// FFI vers le Buffer napi). Le `Vec<u8>` retourné a `len() == w*h*4`./// Préférer `latest_frame_since` sur le chemin chaud : il évite ce clone quand/// le consommateur possède déjà la génération courante.- pub fn latest_frame(&self) -> Option<(u64, u32, u32, Vec<u8>)> {+ pub fn latest_frame(&self) -> Option<LatestFrame> {self.shared.latest_frame.lock()@@ -910,7 +910,7 @@ impl LiveView {/// frame figée — on n'exécute PAS le clone `O(w·h)` : c'est tout l'intérêt du/// compteur. Le consommateur passe la dernière génération qu'il a peinte (`0` au/// départ) ; `None` ⇒ il ne fait rien, `Some` ⇒ il peint et retient `gen`.- pub fn latest_frame_since(&self, since_gen: u64) -> Option<(u64, u32, u32, Vec<u8>)> {+ pub fn latest_frame_since(&self, since_gen: u64) -> Option<LatestFrame> {let mut guard = self.shared.latest_frame.lock().ok()?;match guard.as_ref() {// Le buffer est EMPORTÉ, pas copié. Le thread de rendu le remplace à chaque@@ -1808,7 +1808,7 @@ unsafe fn render_thread(// l'ancienne dérivation tant que le slot n'est pas vidé.let next_gen = shared.frame_gen.fetch_add(1, Ordering::Relaxed) + 1;if let Ok(mut slot) = shared.latest_frame.lock() {- *slot = Some((next_gen, rw, rh, rgba));+ *slot = Some((next_gen, rw, rh, rgba, comp.footage_quad()));}first = false;}@@ -1958,7 +1958,7 @@ pub fn run_standalone(screen: &str, webcam: &str, cursor_json: &str) -> Result<(// standalone n'affiche pas réellement les pixels ici (l'embed Electron est// le consumer réel). On imprime juste une frame de temps en temps pour// confirmer que la chaîne fonctionne.- if let Some((_gen, fw, fh, _pixels)) = view.latest_frame() {+ if let Some((_gen, fw, fh, _pixels, _)) = view.latest_frame() {if (fw, fh) != (w, h) {// garde-fou : la staging de readback suit `set_rect` côté thread// de rendu, donc ce serait une désynchro transitoire — acceptable.diff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rsindex 8910070c3..d14c37773 100644--- a/crates/compositor/src/regions.rs+++ b/crates/compositor/src/regions.rs@@ -2190,6 +2190,32 @@ mod arrow_tests {let (_, half) = arrow_local_geometry("right", -5.0, [100.0, 100.0]);assert_eq!(half, 0.0);}++ /// L'éditeur encadre chaque flèche par l'enveloppe de ses traits (`ARROW_EXTENTS`,+ /// `src/lib/ai-edition/annotations/arrowBounds.ts`) : elle doit être celle que dessine ce+ /// module, sinon le gimbal ne tombe plus sur la flèche.+ #[test]+ fn the_editor_frames_each_arrow_by_its_strokes() {+ let ts = include_str!("../../../src/lib/ai-edition/annotations/arrowBounds.ts");+ let table = &ts[ts.find("ARROW_EXTENTS").expect("la table")..];+ let table = &table[..table.find("};").expect("sa fin")];+ for dir in ["up", "down", "left", "right", "up-right", "up-left", "down-right", "down-left"] {+ let key = if dir.contains('-') { format!("\"{dir}\":") } else { format!("\t{dir}:") };+ let row = &table[table.find(&key).unwrap_or_else(|| panic!("{dir} absente"))..];+ let row = &row[row.find('[').expect("[") + 1..row.find(']').expect("]")];+ let got: Vec<f32> = row.split(',').map(|v| v.trim().parse().expect("nombre")).collect();+ let segs = arrow_segments_viewbox(dir);+ let xs = segs.iter().flat_map(|s| [s[0], s[2]]);+ let ys = segs.iter().flat_map(|s| [s[1], s[3]]);+ let want = [+ xs.clone().fold(f32::MAX, f32::min),+ ys.clone().fold(f32::MAX, f32::min),+ xs.fold(f32::MIN, f32::max),+ ys.fold(f32::MIN, f32::max),+ ];+ assert_eq!(got, want, "{dir}");+ }+ }}#[cfg(test)]diff --git a/electron/native/compositor-view/addon.d.ts b/electron/native/compositor-view/addon.d.tsindex 1365846c7..ee29cd80f 100644--- a/electron/native/compositor-view/addon.d.ts+++ b/electron/native/compositor-view/addon.d.ts@@ -34,6 +34,11 @@ export interface NativeFramePacket {width: number;height: number;data: Buffer;+ /** The footage in this frame: its TL, TR, BR, BL corners (x, y as fractions of the frame,+ * eight numbers), where a privacy blur's gimbal goes. Absent before anything is composed. */+ footage?: number[] | null;+ /** The footage maps from those corners by their homography (real camera), not bilinearly. */+ footageProjective?: boolean;}export interface ExportStats {diff --git a/src/components/ai-edition/AnnotationLayer.test.tsx b/src/components/ai-edition/AnnotationLayer.test.tsxindex 9f2ea890c..aff91ba33 100644--- a/src/components/ai-edition/AnnotationLayer.test.tsx+++ b/src/components/ai-edition/AnnotationLayer.test.tsx@@ -1,7 +1,8 @@// @vitest-environment jsdom-import { render } from "@testing-library/react";-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";+import { act, render } from "@testing-library/react";+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";+import { publishFootageQuad } from "@/native/footageQuadStore";import { AnnotationLayer } from "./AnnotationLayer";// react-rnd reads its offset in the parent off `getBoundingClientRect` on mount, and jsdom lays@@ -18,6 +19,7 @@ beforeAll(() => {});});afterAll(() => vi.restoreAllMocks());+afterEach(() => publishFootageQuad(null));function region(overrides: Partial<AxcutAnnotationRegion>): AxcutAnnotationRegion {return {@@ -46,11 +48,11 @@ function region(overrides: Partial<AxcutAnnotationRegion>): AxcutAnnotationRegio// A 1000×500 frame, the footage padded in to 800×400 at (100, 50).const FOOTAGE = { x: 100, y: 50, width: 800, height: 400 };-function layer(annotations: AxcutAnnotationRegion[]) {+function layer(annotations: AxcutAnnotationRegion[], selectedAnnotationId: string | null = null) {const view = render(<AnnotationLayerannotations={annotations}- selectedAnnotationId={null}+ selectedAnnotationId={selectedAnnotationId}currentTimeSec={0.5}frameWidth={1000}frameHeight={500}@@ -62,7 +64,15 @@ function layer(annotations: AxcutAnnotationRegion[]) {);const frame = view.container.firstElementChild as HTMLElement;const boxes = [...view.container.querySelectorAll<HTMLElement>(".react-draggable")];- return { frame, boxes };+ return { frame, boxes, view };+}++/** The corners of the selected blur's gimbal, frame px. */+function maskCorners(container: HTMLElement): number[][] {+ return [...container.querySelectorAll("[data-testid=mask-gimbal] circle")].map((c) => [+ Math.round(Number(c.getAttribute("cx")) * 1000) / 1000,+ Math.round(Number(c.getAttribute("cy")) * 1000) / 1000,+ ]);}describe("AnnotationLayer", () => {@@ -82,12 +92,47 @@ describe("AnnotationLayer", () => {expect(boxes[0].style.width).toBe("240px");});- it("keeps a blur inside the footage it hides", () => {- const { frame, boxes } = layer([region({ type: "blur", content: "" })]);- const container = boxes[0].parentElement as HTMLElement;- expect(container).not.toBe(frame);- expect(container.style.left).toBe("100px");- expect(container.style.width).toBe("800px");- expect(boxes[0].style.transform).toBe("translate(80px,80px)");+ it("puts a blur's gimbal on the footage it hides, at rest", () => {+ const { view, boxes } = layer([region({ type: "blur", content: "" })], "a");+ expect(boxes).toHaveLength(0);+ // 100 + 10 % of 800 = 180, 50 + 20 % of 400 = 130; 30 % × 40 % of the footage.+ expect(maskCorners(view.container)).toEqual([+ [180, 130],+ [420, 130],+ [420, 290],+ [180, 290],+ ]);+ });++ it("moves a blur's gimbal with the footage the compositor draws: zoomed, then leaning", () => {+ const { view } = layer([region({ type: "blur", content: "" })], "a");+ // The frame on screen shows the footage zoomed ×2 around its middle.+ act(() => publishFootageQuad([-0.3, -0.3, 1.3, -0.3, 1.3, 1.3, -0.3, 1.3], false));+ expect(maskCorners(view.container)).toEqual([+ [-140, 10],+ [340, 10],+ [340, 330],+ [-140, 330],+ ]);+ // Leaning under the real camera: the gimbal is a quad, not a rect.+ act(() => publishFootageQuad([0.1, 0.1, 0.9, 0.2, 0.9, 0.8, 0.1, 0.9], true));+ const [tl, tr] = maskCorners(view.container);+ expect(tr[1]).toBeGreaterThan(tl[1]);+ });++ it("frames an arrow, not the empty box around it", () => {+ const arrow = region({+ type: "figure",+ space: "frame",+ position: { x: 10, y: 20 },+ size: { width: 60, height: 60 },+ figureData: { arrowDirection: "down-right", color: "#fff", strokeWidth: 8 },+ });+ const { boxes } = layer([arrow], "a");+ // Its box is 600 × 300 px: the arrow takes the height (scale 3), centred 150 px in, and+ // its strokes span 21..79 of 100.+ expect(boxes[0].style.transform).toBe(`translate(${100 + 150 + 63}px,${100 + 63}px)`);+ expect(boxes[0].style.width).toBe(`${58 * 3}px`);+ expect(boxes[0].style.height).toBe(`${58 * 3}px`);});});diff --git a/src/components/ai-edition/AnnotationLayer.tsx b/src/components/ai-edition/AnnotationLayer.tsxindex 7020d7967..67ce481cd 100644--- a/src/components/ai-edition/AnnotationLayer.tsx+++ b/src/components/ai-edition/AnnotationLayer.tsx@@ -6,13 +6,17 @@// list and a single selection id instead.//// The layer covers the whole preview frame: text, images and arrows are placed on the frame-// and move anywhere in it, padding included. A privacy blur stays on the footage, so its boxes-// live in a child sized to the footage rect and cannot leave it (see-// `lib/ai-edition/annotations/placement.ts`).+// and move anywhere in it, padding included. A privacy blur stays on the footage and follows+// it: the compositor paints the mask on the zoomed footage, leaning under 3D, so its gimbal goes+// through the footage of the frame on screen (`MaskGimbal`, `FootageQuad`), and cannot leave it+// (see `lib/ai-edition/annotations/placement.ts`).+import { rectQuad } from "@/lib/ai-edition/annotations/footageQuad";import { belongsInFrame, fitTextBox, toFrameSpace } from "@/lib/ai-edition/annotations/placement";import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";+import { useFootageQuad } from "@/native/footageQuadStore";import { AnnotationOverlay, type PxRect } from "./AnnotationOverlay";+import { MaskGimbal } from "./MaskGimbal";interface AnnotationLayerProps {annotations: AxcutAnnotationRegion[];@@ -40,6 +44,8 @@ export function AnnotationLayer({onCommit,}: AnnotationLayerProps) {const currentTimeMs = Math.round(currentTimeSec * 1000);+ // Where the footage lies in the frame on screen; at rest (no frame yet), its layout rect.+ const liveFootage = useFootageQuad();const visible = annotations.filter((annotation) => {@@ -66,7 +72,6 @@ export function AnnotationLayer({}const frameBox: PxRect = { x: 0, y: 0, width: frameWidth, height: frameHeight };- const footageBox: PxRect = { x: 0, y: 0, width: footage.width, height: footage.height };// The footage as fractions of the frame: the form the conversions in `placement.ts` take.const footageInFrame = {x: footage.x / frameWidth,@@ -76,48 +81,51 @@ export function AnnotationLayer({};const fitText = (region: AxcutAnnotationRegion) => fitTextBox(region, frameWidth / frameHeight);- const overlay = (annotation: AxcutAnnotationRegion, inFrame: boolean) => {- const width = inFrame ? frameWidth : footage.width;- const height = inFrame ? frameHeight : footage.height;- return (- <AnnotationOverlay- // La clé ne porte plus les champs de `blurData` : ils forçaient un remontage à- // chaque réglage du flou, pour resynchroniser un canvas de mosaïque qui n'existe- // plus. La taille du conteneur y reste, elle, parce qu'elle change le rect en px.- key={`${annotation.id}-${width}-${height}`}- annotation={annotation}- isSelected={annotation.id === selectedAnnotationId}- containerWidth={width}- containerHeight={height}- // Still on the footage but moving in the frame: its stored rect reads from there- // until its first gesture moves it into the frame.- box={!inFrame ? footageBox : annotation.space === "frame" ? frameBox : footage}- toFrame={inFrame ? toFrameSpace(annotation, footageInFrame) : null}- fitText={annotation.type === "text" ? fitText : undefined}- onChange={onChange}- onCommit={onCommit}- onClick={handleClick}- zIndex={annotation.zIndex}- isSelectedBoost={annotation.id === selectedAnnotationId}- />- );- };+ const overlay = (annotation: AxcutAnnotationRegion) => (+ <AnnotationOverlay+ // La clé ne porte plus les champs de `blurData` : ils forçaient un remontage à chaque+ // réglage du flou, pour resynchroniser un canvas de mosaïque qui n'existe plus. La+ // taille du conteneur y reste, elle, parce qu'elle change le rect en px.+ key={`${annotation.id}-${frameWidth}-${frameHeight}`}+ annotation={annotation}+ isSelected={annotation.id === selectedAnnotationId}+ containerWidth={frameWidth}+ containerHeight={frameHeight}+ // Still on the footage but moving in the frame: its stored rect reads from there+ // until its first gesture moves it into the frame.+ box={annotation.space === "frame" ? frameBox : footage}+ toFrame={toFrameSpace(annotation, footageInFrame)}+ fitText={annotation.type === "text" ? fitText : undefined}+ onChange={onChange}+ onCommit={onCommit}+ onClick={handleClick}+ zIndex={annotation.zIndex}+ isSelectedBoost={annotation.id === selectedAnnotationId}+ />+ );+ const quad =+ liveFootage ??+ rectQuad(footageInFrame.x, footageInFrame.y, footageInFrame.width, footageInFrame.height);return (<div className="absolute inset-0" style={{ pointerEvents: "none" }}>- {visible.filter((a) => belongsInFrame(a.type)).map((a) => overlay(a, true))}- <div- style={{- position: "absolute",- left: footage.x,- top: footage.y,- width: footage.width,- height: footage.height,- pointerEvents: "none",- }}- >- {visible.filter((a) => !belongsInFrame(a.type)).map((a) => overlay(a, false))}- </div>+ {visible.filter((a) => belongsInFrame(a.type)).map(overlay)}+ {/* Only the selected blur has a gimbal: the mask itself is painted by the compositor. */}+ {visible+ .filter((a) => !belongsInFrame(a.type) && a.id === selectedAnnotationId)+ .map((a) => (+ <MaskGimbal+ key={a.id}+ annotation={a}+ quad={quad}+ frameWidth={frameWidth}+ frameHeight={frameHeight}+ onChange={onChange}+ onCommit={onCommit}+ onClick={handleClick}+ zIndex={a.zIndex}+ />+ ))}</div>);}diff --git a/src/components/ai-edition/AnnotationOverlay.tsx b/src/components/ai-edition/AnnotationOverlay.tsxindex 356a740fe..f260847dc 100644--- a/src/components/ai-edition/AnnotationOverlay.tsx+++ b/src/components/ai-edition/AnnotationOverlay.tsx@@ -1,6 +1,8 @@-// Chrome d'édition d'une annotation : cadre de sélection, glissement, poignées de-// redimensionnement. Les PIXELS de l'annotation — texte, image, flèche, flou — sont peints par le-// compositeur natif, aperçu compris.+// Chrome d'édition d'une annotation posée sur le cadre (texte, image, flèche) : cadre de+// sélection, glissement, poignées de redimensionnement. Les PIXELS de l'annotation sont peints par+// le compositeur natif, aperçu compris. Un flou suit le métrage : son gimbal est `MaskGimbal`.+// Une flèche se dessine au milieu de sa boîte, à l'échelle de son plus petit côté : son cadre+// encadre le dessin (`arrowRect`), et ses gestes écrivent la boîte qui le redonne (`arrowBox`).//// Ce fichier était le port du `AnnotationOverlay` de l'éditeur v2 : il rendait les quatre types en// DOM et portait la saisie du tracé libre, soit ~400 lignes qui ne s'exécutaient plus depuis que@@ -11,6 +13,7 @@import { useEffect, useRef, useState } from "react";import { Rnd } from "react-rnd";+import { arrowBox, arrowRect } from "@/lib/ai-edition/annotations/arrowBounds";import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";import { clampToBound } from "@/lib/projectDefaults";import { cn } from "@/lib/utils";@@ -27,15 +30,15 @@ export interface PxRect {interface AnnotationOverlayProps {annotation: Region;isSelected: boolean;- /** Taille, en px, de l'élément où la boîte se déplace : le cadre, ou le footage pour un flou.- * Chaque écriture est un pourcentage de cet élément. */+ /** Taille, en px, de l'élément où la boîte se déplace : le cadre. Chaque écriture est un+ * pourcentage de cet élément. */containerWidth: number;containerHeight: number;/** D'où se lit le rect enregistré, en px dans cet élément : l'élément lui-même, ou le rect du* footage pour une annotation encore rangée sur lui mais qui se déplace dans le cadre. */box: PxRect;/** Le patch qui range l'annotation dans le cadre, appliqué avant son premier geste ; `null`- * quand elle y est déjà (ou qu'elle n'en sort jamais, comme un flou). */+ * quand elle y est déjà. */toFrame: Partial<Region> | null;/** Texte seulement : la boîte taillée sur le texte, centre conservé. */fitText?: (region: Region) => Pick<Region, "position" | "size">;@@ -72,12 +75,27 @@ export function AnnotationOverlay({zIndex,isSelectedBoost,}: AnnotationOverlayProps) {- const committedX = box.x + (annotation.position.x / 100) * box.width;- const committedY = box.y + (annotation.position.y / 100) * box.height;- const committedWidth = (annotation.size.width / 100) * box.width;- const committedHeight = (annotation.size.height / 100) * box.height;- const blurShape = annotation.type === "blur" ? (annotation.blurData?.shape ?? "rectangle") : null;const isText = annotation.type === "text";+ const arrow =+ annotation.type === "figure"+ ? {+ direction: annotation.figureData?.arrowDirection ?? "right",+ stroke: annotation.figureData?.strokeWidth ?? 4,+ }+ : null;+ // Le cadre du geste : la boîte rangée, ou, pour une flèche, la flèche dessinée dedans.+ const stored: PxRect = {+ x: box.x + (annotation.position.x / 100) * box.width,+ y: box.y + (annotation.position.y / 100) * box.height,+ width: (annotation.size.width / 100) * box.width,+ height: (annotation.size.height / 100) * box.height,+ };+ const {+ x: committedX,+ y: committedY,+ width: committedWidth,+ height: committedHeight,+ } = arrow ? arrowRect(stored, arrow.direction, arrow.stroke) : stored;const isDraggingRef = useRef(false);// Le geste en cours a-t-il bougé quelque chose ? Un clic sur une annotation sélectionnée passe// aussi par le début et la fin d'un glissement : sans mouvement, il n'écrit rien.@@ -103,14 +121,22 @@ export function AnnotationOverlay({const { x, y, width, height } = liveRect;- /** Un rect en px de l'élément, en pourcentages de lui : ce que le document range. */- const toPct = (rect: PxRect): Pick<Region, "position" | "size"> => ({- position: { x: (rect.x / containerWidth) * 100, y: (rect.y / containerHeight) * 100 },- size: {- width: (rect.width / containerWidth) * 100,- height: (rect.height / containerHeight) * 100,- },- });+ /** Le cadre du geste en px de l'élément, en pourcentages de lui : ce que le document range.+ * Pour une flèche, la boîte qui la dessine là (carrée : la flèche ne s'étire pas). */+ const toPct = (frame: PxRect): Pick<Region, "position" | "size"> => {+ const rect = arrow ? arrowBox(frame, arrow.direction, arrow.stroke) : frame;+ return {+ position: { x: (rect.x / containerWidth) * 100, y: (rect.y / containerHeight) * 100 },+ size: {+ width: (rect.width / containerWidth) * 100,+ height: (rect.height / containerHeight) * 100,+ },+ };+ };+ /** Ce qu'un glissement écrit : la position ; pour une flèche aussi la taille, parce que sa+ * boîte devient carrée au premier geste. */+ const moved = (frame: PxRect): Partial<Region> =>+ arrow ? toPct(frame) : { position: toPct(frame).position };// Une annotation encore sur le footage passe dans le cadre à son premier mouvement, au pixel// près : les écritures qui suivent sont des pourcentages du cadre.@@ -152,14 +178,12 @@ export function AnnotationOverlay({// Pousse la position PENDANT le geste : c'est le natif qui peint, il doit donc suivre// le curseur. `onChange` ne met à jour qu'en mémoire ; l'écriture disque se fait une// seule fois, au relâchement (`onCommit`).- onChange(annotation.id, {- position: toPct({ x: d.x, y: d.y, width, height }).position,- });+ onChange(annotation.id, moved({ x: d.x, y: d.y, width, height }));}}onDragStop={(_e, d) => {if (movedRef.current) {setLiveRect((prev) => ({ ...prev, x: d.x, y: d.y }));- settle({ position: toPct({ x: d.x, y: d.y, width, height }).position });+ settle(moved({ x: d.x, y: d.y, width, height }));}movedRef.current = false;setTimeout(() => {@@ -202,28 +226,22 @@ export function AnnotationOverlay({onClick(annotation.id);}}bounds="parent"- // Un texte garde sa forme : sa boîte est celle de ses mots, seule la taille change.- lockAspectRatio={isText}+ // Un texte garde sa forme : sa boîte est celle de ses mots, seule la taille change. Une+ // flèche aussi : elle ne s'étire pas, elle grandit.+ lockAspectRatio={isText || arrow !== null}className={cn("cursor-move",- isSelected &&- annotation.type !== "blur" &&- "ring-2 ring-[#34B27B] ring-offset-2 ring-offset-transparent",+ isSelected && "ring-2 ring-[#34B27B] ring-offset-2 ring-offset-transparent",)}style={{zIndex: isSelectedBoost ? zIndex + 1000 : zIndex,pointerEvents: isSelected ? "auto" : "none",- border:- isSelected && annotation.type !== "blur" ? "2px solid rgba(52, 178, 123, 0.8)" : "none",- backgroundColor:- isSelected && annotation.type !== "blur" ? "rgba(52, 178, 123, 0.1)" : "transparent",- boxShadow:- isSelected && annotation.type !== "blur" ? "0 0 0 1px rgba(52, 178, 123, 0.35)" : "none",+ border: isSelected ? "2px solid rgba(52, 178, 123, 0.8)" : "none",+ backgroundColor: isSelected ? "rgba(52, 178, 123, 0.1)" : "transparent",+ boxShadow: isSelected ? "0 0 0 1px rgba(52, 178, 123, 0.35)" : "none",}}- // Un flou en tracé libre se déplace et se redimensionne comme les autres : ce qui le- // bloquait, c'était la zone de saisie du tracé qui capturait le pointeur — et elle est- // partie avec l'outil. Un texte ne se tire que par ses coins, qui agrandissent ses lettres.- enableResizing={isSelected ? (isText ? CORNERS_ONLY : true) : false}+ // Un texte et une flèche ne se tirent que par leurs coins, qui les agrandissent.+ enableResizing={isSelected ? (isText || arrow ? CORNERS_ONLY : true) : false}disableDragging={!isSelected}resizeHandleStyles={{topLeft: {@@ -268,23 +286,7 @@ export function AnnotationOverlay({},}}>- <div- className={cn(- "w-full h-full relative",- annotation.type !== "blur" && "rounded-lg",- isSelected && annotation.type !== "blur" && "shadow-lg",- )}- >- {/* Le cadre d'un flou sélectionné, à la forme du masque. Les autres types portent le- leur sur le `Rnd` lui-même ; un flou n'en a pas, pour ne pas encadrer la zone qu'il- est censé cacher — sans ce liseré il n'aurait AUCUN retour de sélection. */}- {isSelected && annotation.type === "blur" ? (- <div- className="absolute inset-0 pointer-events-none border-2 border-[#34B27B]/80"- style={{ borderRadius: blurShape === "oval" ? "50%" : "8px" }}- />- ) : null}- </div>+ <div className={cn("w-full h-full relative rounded-lg", isSelected && "shadow-lg")} /></Rnd>);}diff --git a/src/components/ai-edition/MaskGimbal.test.tsx b/src/components/ai-edition/MaskGimbal.test.tsxnew file mode 100644index 000000000..45e897de7--- /dev/null+++ b/src/components/ai-edition/MaskGimbal.test.tsx@@ -0,0 +1,88 @@+// @vitest-environment jsdom+import { fireEvent, render } from "@testing-library/react";+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";+import { rectQuad } from "@/lib/ai-edition/annotations/footageQuad";+import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";+import { MaskGimbal } from "./MaskGimbal";++// The gimbal reads the pointer against its own box: the whole 1000 × 500 frame.+beforeAll(() => {+ vi.spyOn(SVGElement.prototype, "getBoundingClientRect").mockReturnValue(+ DOMRect.fromRect({ x: 0, y: 0, width: 1000, height: 500 }),+ );+});+afterAll(() => vi.restoreAllMocks());++const BLUR = {+ id: "b",+ startMs: 0,+ endMs: 1000,+ type: "blur",+ content: "",+ position: { x: 10, y: 20 },+ size: { width: 30, height: 40 },+ style: {},+ zIndex: 1,+ blurData: { type: "mosaic", shape: "rectangle", color: "white", intensity: 12, blockSize: 12 },+} as unknown as AxcutAnnotationRegion;++// The footage zoomed ×2 around its middle: one unit of footage is 1.6 units of frame.+const ZOOMED = rectQuad(-0.3, -0.3, 1.6, 1.6);++function gimbal() {+ const onChange = vi.fn();+ const onCommit = vi.fn();+ const onClick = vi.fn();+ const { container } = render(+ <MaskGimbal+ annotation={BLUR}+ quad={ZOOMED}+ frameWidth={1000}+ frameHeight={500}+ onChange={onChange}+ onCommit={onCommit}+ onClick={onClick}+ zIndex={1}+ />,+ );+ return { container, onChange, onCommit, onClick };+}++const at = (x: number, y: number) => ({ clientX: x, clientY: y, pointerId: 1 });++describe("MaskGimbal", () => {+ it("moves the mask by what the pointer covers of the footage, zoomed", () => {+ const { container, onChange, onCommit } = gimbal();+ const body = container.querySelector("polygon") as SVGPolygonElement;+ fireEvent.pointerDown(body, at(300, 200));+ // 160 px of a 1000 px frame, zoomed ×2 over 1.6: a tenth of the footage.+ fireEvent.pointerMove(body, at(460, 200));+ fireEvent.pointerUp(body, at(460, 200));+ const last = onChange.mock.lastCall?.[1];+ expect(last.position.x).toBeCloseTo(20, 9);+ expect(last.position.y).toBeCloseTo(20, 9);+ expect(onCommit).toHaveBeenCalledTimes(1);+ });++ it("resizes from a corner while the opposite one stays", () => {+ const { container, onChange } = gimbal();+ const bottomRight = container.querySelectorAll("circle")[2];+ fireEvent.pointerDown(bottomRight, at(0, 0));+ // Frame point (0.5, 0.5) is the middle of the footage.+ fireEvent.pointerMove(bottomRight, at(500, 250));+ const last = onChange.mock.lastCall?.[1];+ expect(last.position).toEqual({ x: 10, y: 20 });+ expect(last.size.width).toBeCloseTo(40, 9);+ expect(last.size.height).toBeCloseTo(30, 9);+ });++ it("selects through on a click that moves nothing", () => {+ const { container, onChange, onCommit, onClick } = gimbal();+ const body = container.querySelector("polygon") as SVGPolygonElement;+ fireEvent.pointerDown(body, at(300, 200));+ fireEvent.pointerUp(body, at(300, 200));+ expect(onChange).not.toHaveBeenCalled();+ expect(onCommit).not.toHaveBeenCalled();+ expect(onClick).toHaveBeenCalledWith("b");+ });+});diff --git a/src/components/ai-edition/MaskGimbal.tsx b/src/components/ai-edition/MaskGimbal.tsxnew file mode 100644index 000000000..35645f154--- /dev/null+++ b/src/components/ai-edition/MaskGimbal.tsx@@ -0,0 +1,189 @@+// Le gimbal d'un flou de confidentialité. Le masque suit le contenu : le compositeur le pose sur+// le métrage zoomé, et incliné sous la 3D (`privacy_mask`). Le gimbal passe donc par le métrage+// de l'image (`FootageQuad`) : contour, poignées et gestes vivent dans le repère du métrage, et+// chaque point est projeté comme le compositeur le peint. Un `Rnd` droit, posé sur le métrage au+// repos, s'écartait du masque dès le premier zoom.++import type { PointerEvent as ReactPointerEvent } from "react";+import { useRef } from "react";+import {+ type FootageQuad,+ footageAt,+ footagePoint,+} from "@/lib/ai-edition/annotations/footageQuad";+import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";++type Region = AxcutAnnotationRegion;++interface MaskGimbalProps {+ annotation: Region;+ /** Le métrage dans l'image, en fractions de l'image. */+ quad: FootageQuad;+ /** L'image de l'aperçu, px. */+ frameWidth: number;+ frameHeight: number;+ onChange: (id: string, patch: Partial<Region>) => void;+ /** Écriture disque, une fois en fin de geste. */+ onCommit?: () => void;+ onClick: (id: string) => void;+ zIndex: number;+}++const GREEN = "#34B27B";+/** Le plus petit masque que laissent les poignées, en % du métrage. */+const MIN_PCT = 1;+/** Les poignées dans l'ordre des coins : TL, TR, BR, BL. */+const CORNER_CURSORS = ["nwse-resize", "nesw-resize", "nwse-resize", "nesw-resize"] as const;++type Gesture =+ | {+ kind: "move";+ start: readonly [number, number];+ origin: { x: number; y: number };+ moved: boolean;+ }+ | { kind: "corner"; fixed: readonly [number, number]; moved: boolean };++const clamp = (value: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, value));++export function MaskGimbal({+ annotation,+ quad,+ frameWidth,+ frameHeight,+ onChange,+ onCommit,+ onClick,+ zIndex,+}: MaskGimbalProps) {+ const svgRef = useRef<SVGSVGElement>(null);+ const gesture = useRef<Gesture | null>(null);+ const { position, size } = annotation;+ // Le masque en fractions du métrage.+ const [u0, v0] = [position.x / 100, position.y / 100];+ const [u1, v1] = [u0 + size.width / 100, v0 + size.height / 100];+ const onFrame = (u: number, v: number) => {+ const [x, y] = footagePoint(quad, u, v);+ return [x * frameWidth, y * frameHeight] as const;+ };+ const corners = [+ [u0, v0],+ [u1, v0],+ [u1, v1],+ [u0, v1],+ ] as const;+ // Un ovale se dessine en ovale, projeté ; le tracé libre, comme le masque, par sa boîte.+ const outline =+ annotation.blurData?.shape === "oval"+ ? Array.from({ length: 48 }, (_, k) => {+ const t = (k / 48) * 2 * Math.PI;+ return onFrame(+ u0 + (u1 - u0) * (0.5 + 0.5 * Math.cos(t)),+ v0 + (v1 - v0) * (0.5 + 0.5 * Math.sin(t)),+ );+ })+ : corners.map(([u, v]) => onFrame(u, v));++ /** Le point du métrage sous le pointeur, en fractions du métrage. */+ const under = (event: ReactPointerEvent): readonly [number, number] => {+ const r = svgRef.current?.getBoundingClientRect();+ if (!r || r.width <= 0 || r.height <= 0) return [0, 0];+ return footageAt(quad, (event.clientX - r.left) / r.width, (event.clientY - r.top) / r.height);+ };++ const begin = (event: ReactPointerEvent<Element>, next: Gesture) => {+ event.stopPropagation();+ event.currentTarget.setPointerCapture?.(event.pointerId);+ gesture.current = next;+ };++ const onPointerMove = (event: ReactPointerEvent) => {+ const g = gesture.current;+ if (!g) return;+ const [u, v] = under(event);+ if (g.kind === "move") {+ const x = clamp(g.origin.x + (u - g.start[0]) * 100, 0, 100 - size.width);+ const y = clamp(g.origin.y + (v - g.start[1]) * 100, 0, 100 - size.height);+ g.moved ||= x !== g.origin.x || y !== g.origin.y;+ // En direct : c'est le natif qui peint, il suit le geste. L'écriture disque attend+ // le relâchement (`onCommit`).+ onChange(annotation.id, { position: { x, y } });+ return;+ }+ // Le coin opposé reste en place ; la poignée peut passer de l'autre côté, sans que le+ // masque descende sous le minimum ni sorte du métrage.+ const span = (c: number, fixed: number): [number, number] => {+ const [lo, hi] =+ c < fixed ? [Math.min(c, fixed - MIN_PCT), fixed] : [fixed, Math.max(c, fixed + MIN_PCT)];+ const top = Math.min(hi, 100);+ return [Math.max(0, Math.min(lo, top - MIN_PCT)), top];+ };+ const [x0, x1] = span(clamp(u * 100, 0, 100), g.fixed[0]);+ const [y0, y1] = span(clamp(v * 100, 0, 100), g.fixed[1]);+ g.moved = true;+ onChange(annotation.id, {+ position: { x: x0, y: y0 },+ size: { width: x1 - x0, height: y1 - y0 },+ });+ };++ const onPointerUp = (event: ReactPointerEvent) => {+ const g = gesture.current;+ gesture.current = null;+ if (!g) return;+ (event.target as Element).releasePointerCapture?.(event.pointerId);+ if (g.moved) onCommit?.();+ else if (g.kind === "move") onClick(annotation.id);+ };++ const points = (list: readonly (readonly [number, number])[]) =>+ list.map(([x, y]) => `${x},${y}`).join(" ");++ return (+ <svg+ ref={svgRef}+ className="absolute inset-0"+ width="100%"+ height="100%"+ viewBox={`0 0 ${frameWidth} ${frameHeight}`}+ preserveAspectRatio="none"+ style={{ zIndex: zIndex + 1000, pointerEvents: "none", overflow: "visible" }}+ onPointerMove={onPointerMove}+ onPointerUp={onPointerUp}+ onPointerCancel={onPointerUp}+ data-testid="mask-gimbal"+ >+ <polygon+ points={points(outline)}+ fill="transparent"+ stroke={GREEN}+ strokeOpacity={0.8}+ strokeWidth={2}+ strokeLinejoin="round"+ style={{ pointerEvents: "all", cursor: "move" }}+ onPointerDown={(event) =>+ begin(event, { kind: "move", start: under(event), origin: { ...position }, moved: false })+ }+ />+ {corners.map(([u, v], k) => {+ const [cx, cy] = onFrame(u, v);+ const [ou, ov] = corners[(k + 2) % 4];+ return (+ <circle+ key={k}+ cx={cx}+ cy={cy}+ r={6}+ fill="white"+ stroke={GREEN}+ strokeWidth={2}+ style={{ pointerEvents: "all", cursor: CORNER_CURSORS[k] }}+ onPointerDown={(event) =>+ begin(event, { kind: "corner", fixed: [ou * 100, ov * 100], moved: false })+ }+ />+ );+ })}+ </svg>+ );+}diff --git a/src/components/ai-edition/NewEditorShell.module.css b/src/components/ai-edition/NewEditorShell.module.cssindex 667d0c5db..35498978a 100644--- a/src/components/ai-edition/NewEditorShell.module.css+++ b/src/components/ai-edition/NewEditorShell.module.css@@ -361,6 +361,10 @@overflow: hidden;display: grid;place-items: center;+ /* Its own stacking context: the layers inside it (gimbals, zoom focus, webcam drag) order+ themselves with z-indexes up to 1000 and more, which must not reach past the preview. A+ selected annotation's gimbal painted over the export dialog (z-index 100). */+ isolation: isolate;}/* Once the native canvas has painted, it covers the whole card, and anything painted UNDER thesame rounded clip leaks through its anti-aliased edge: the wallpaper placeholder and the insetdiff --git a/src/lib/ai-edition/annotations/arrowBounds.test.ts b/src/lib/ai-edition/annotations/arrowBounds.test.tsnew file mode 100644index 000000000..3c39ca9a8--- /dev/null+++ b/src/lib/ai-edition/annotations/arrowBounds.test.ts@@ -0,0 +1,33 @@+import { describe, expect, it } from "vitest";+import { arrowBox, arrowRect } from "./arrowBounds";++describe("arrowBounds", () => {+ it("frames the arrow, not its box", () => {+ // A wide box: the arrow takes the height, centred; a diagonal fills half of it.+ const drawn = arrowRect({ x: 100, y: 50, width: 600, height: 300 }, "down-right", 8);+ // Scale 3, offset 150 on x; the strokes go from 25 - 4 to 75 + 4.+ expect(drawn).toEqual({ x: 100 + 150 + 21 * 3, y: 50 + 21 * 3, width: 58 * 3, height: 58 * 3 });+ });++ it("writes back a square box that draws the arrow where the gimbal left it", () => {+ for (const direction of ["right", "up", "down-left"] as const) {+ const drawn = { x: 40, y: 30, width: 120, height: 0 };+ const box = arrowBox({ ...drawn, height: 1 }, direction, 6);+ expect(box.width).toBe(box.height);+ const back = arrowRect(box, direction, 6);+ expect(back.x).toBeCloseTo(40, 9);+ expect(back.y).toBeCloseTo(30, 9);+ expect(back.width).toBeCloseTo(120, 9);+ }+ });++ it("keeps an arrow drawn where it was when its box becomes square", () => {+ const box = { x: 10, y: 20, width: 500, height: 200 };+ const drawn = arrowRect(box, "up", 7);+ const again = arrowRect(arrowBox(drawn, "up", 7), "up", 7);+ expect(again.x).toBeCloseTo(drawn.x, 9);+ expect(again.y).toBeCloseTo(drawn.y, 9);+ expect(again.width).toBeCloseTo(drawn.width, 9);+ expect(again.height).toBeCloseTo(drawn.height, 9);+ });+});diff --git a/src/lib/ai-edition/annotations/arrowBounds.ts b/src/lib/ai-edition/annotations/arrowBounds.tsnew file mode 100644index 000000000..31174c4fe--- /dev/null+++ b/src/lib/ai-edition/annotations/arrowBounds.ts@@ -0,0 +1,62 @@+// Où une flèche d'annotation se dessine dans sa boîte. Le compositeur la met à l'échelle du plus+// petit côté de la boîte, centrée, dans un repère 100 × 100 où elle n'occupe que la moitié du+// carré : encadrer la boîte laisserait un grand vide autour d'elle. Son gimbal encadre donc le+// dessin, et écrit la boîte qui le redonne.++import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";++type Direction = NonNullable<AxcutAnnotationRegion["figureData"]>["arrowDirection"];++export interface Rect {+ x: number;+ y: number;+ width: number;+ height: number;+}++/** L'enveloppe des trois traits de chaque flèche (x0, y0, x1, y1), en unités du repère 100 ×+ * 100 : celle de `arrow_segments_viewbox` (`crates/compositor/src/regions.rs`), qu'un test Rust+ * tient à cette table. */+export const ARROW_EXTENTS: Record<Direction, readonly [number, number, number, number]> = {+ up: [35, 20, 65, 80],+ down: [35, 20, 65, 80],+ left: [20, 35, 80, 65],+ right: [20, 35, 80, 65],+ "up-right": [25, 25, 75, 75],+ "up-left": [25, 25, 75, 75],+ "down-right": [25, 25, 75, 75],+ "down-left": [25, 25, 75, 75],+};++/** L'enveloppe, bouts ronds du trait compris (la moitié de son épaisseur, dans le même repère). */+function extent(direction: Direction, strokeWidth: number): [number, number, number, number] {+ const [x0, y0, x1, y1] = ARROW_EXTENTS[direction] ?? ARROW_EXTENTS.right;+ const half = Math.max(0, strokeWidth) / 2;+ return [x0 - half, y0 - half, x1 + half, y1 + half];+}++/** La flèche telle que le compositeur la dessine dans `box` : ce que son gimbal encadre. */+export function arrowRect(box: Rect, direction: Direction, strokeWidth: number): Rect {+ const scale = Math.min(box.width, box.height) / 100;+ const offX = (box.width - 100 * scale) / 2;+ const offY = (box.height - 100 * scale) / 2;+ const [x0, y0, x1, y1] = extent(direction, strokeWidth);+ return {+ x: box.x + offX + x0 * scale,+ y: box.y + offY + y0 * scale,+ width: (x1 - x0) * scale,+ height: (y1 - y0) * scale,+ };+}++/** La boîte, carrée, qui dessine la flèche exactement sur `drawn` : l'inverse d'`arrowRect`. */+export function arrowBox(drawn: Rect, direction: Direction, strokeWidth: number): Rect {+ const [x0, y0, x1] = extent(direction, strokeWidth);+ const scale = drawn.width / (x1 - x0);+ return {+ x: drawn.x - x0 * scale,+ y: drawn.y - y0 * scale,+ width: 100 * scale,+ height: 100 * scale,+ };+}diff --git a/src/lib/ai-edition/annotations/footageQuad.test.ts b/src/lib/ai-edition/annotations/footageQuad.test.tsnew file mode 100644index 000000000..3c6b095fb--- /dev/null+++ b/src/lib/ai-edition/annotations/footageQuad.test.ts@@ -0,0 +1,78 @@+import { describe, expect, it } from "vitest";+import { type FootageQuad, footageAt, footagePoint, quadFromPacket, rectQuad } from "./footageQuad";++// A plane leaning away on its right, as the fixed angles draw it, and the same corners under+// the real camera (their homography).+const LEANING: FootageQuad["corners"] = [+ [0.12, 0.08],+ [0.86, 0.16],+ [0.84, 0.82],+ [0.1, 0.9],+];++describe("footageQuad", () => {+ it("maps the footage onto a rect at rest", () => {+ const q = rectQuad(0.1, 0.2, 0.8, 0.5);+ const [x, y] = footagePoint(q, 0.25, 0.5);+ expect(x).toBeCloseTo(0.3, 12);+ expect(y).toBeCloseTo(0.45, 12);+ const [u, v] = footageAt(q, 0.3, 0.45);+ expect(u).toBeCloseTo(0.25, 9);+ expect(v).toBeCloseTo(0.5, 9);+ });++ it("lands on the corners and goes back, bilinear or projective", () => {+ for (const projective of [false, true]) {+ const q = { corners: LEANING, projective };+ const corners = [+ [0, 0],+ [1, 0],+ [1, 1],+ [0, 1],+ ];+ corners.forEach(([u, v], k) => {+ const [x, y] = footagePoint(q, u, v);+ expect(x).toBeCloseTo(LEANING[k][0], 9);+ expect(y).toBeCloseTo(LEANING[k][1], 9);+ });+ for (const [u, v] of [+ [0.3, 0.7],+ [0.62, 0.18],+ [1.1, -0.05],+ ]) {+ const [x, y] = footagePoint(q, u, v);+ const [bu, bv] = footageAt(q, x, y);+ expect(bu).toBeCloseTo(u, 6);+ expect(bv).toBeCloseTo(v, 6);+ }+ }+ });++ it("follows the homography of `square_to_quad`, not the bilinear blend, under the camera", () => {+ // The middle of the square: where the diagonals cross under a homography, and the mean+ // of the corners under the bilinear warp. Leaning, the two differ.+ const [px, py] = footagePoint({ corners: LEANING, projective: true }, 0.5, 0.5);+ const [bx, by] = footagePoint({ corners: LEANING, projective: false }, 0.5, 0.5);+ expect(Math.hypot(px - bx, py - by)).toBeGreaterThan(1e-3);+ // The diagonals TL-BR and TR-BL cross at (px, py).+ const [tl, tr, br, bl] = LEANING;+ const cross = (a: readonly number[], b: readonly number[], p: readonly number[]) =>+ (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);+ expect(cross(tl, br, [px, py])).toBeCloseTo(0, 9);+ expect(cross(tr, bl, [px, py])).toBeCloseTo(0, 9);+ });++ it("reads the eight numbers of a frame packet", () => {+ expect(quadFromPacket([0, 0, 1, 0, 1, 1, 0, 1], true)).toEqual({+ corners: [+ [0, 0],+ [1, 0],+ [1, 1],+ [0, 1],+ ],+ projective: true,+ });+ expect(quadFromPacket(undefined)).toBeNull();+ expect(quadFromPacket([0, 0, 1])).toBeNull();+ });+});diff --git a/src/lib/ai-edition/annotations/footageQuad.ts b/src/lib/ai-edition/annotations/footageQuad.tsnew file mode 100644index 000000000..433bbb03f--- /dev/null+++ b/src/lib/ai-edition/annotations/footageQuad.ts@@ -0,0 +1,107 @@+// Le métrage dans l'image de l'aperçu : ses coins et son warp, tels que le compositeur les publie+// avec chaque image (`FootageQuad`, `crates/compositor/src/frame_geometry.rs`). Un flou de+// confidentialité suit le contenu, zoom et perspective compris : son gimbal passe par ici pour+// tomber sur le masque que le compositeur peint.++export type Point = readonly [number, number];++export interface FootageQuad {+ /** TL, TR, BR, BL, en fractions de l'image. */+ corners: readonly [Point, Point, Point, Point];+ /** Le métrage suit l'homographie de ses coins (caméra réelle), pas leur interpolation+ * bilinéaire. */+ projective: boolean;+}++/** Le quad d'un rect droit, en fractions de l'image : le métrage au repos. */+export function rectQuad(x: number, y: number, width: number, height: number): FootageQuad {+ return {+ corners: [+ [x, y],+ [x + width, y],+ [x + width, y + height],+ [x, y + height],+ ],+ projective: false,+ };+}++/** Les huit nombres qu'une image du compositeur porte (TL, TR, BR, BL), en quad. */+export function quadFromPacket(+ footage: readonly number[] | null | undefined,+ projective = false,+): FootageQuad | null {+ if (!footage || footage.length !== 8 || !footage.every(Number.isFinite)) return null;+ const at = (i: number): Point => [footage[2 * i], footage[2 * i + 1]];+ return { corners: [at(0), at(1), at(2), at(3)], projective };+}++/** L'homographie qui envoie le carré unité sur les coins : la forme de Heckbert de+ * `square_to_quad` (`regions.rs`), en matrice 3 × 3 ligne par ligne. */+function homography(q: FootageQuad): number[] {+ const [c0, c1, c2, c3] = q.corners;+ const p = (c: Point) => [c[0] - c0[0], c[1] - c0[1]];+ const [p1, p2, p3] = [p(c1), p(c2), p(c3)];+ const d1 = [p1[0] - p2[0], p1[1] - p2[1]];+ const d2 = [p3[0] - p2[0], p3[1] - p2[1]];+ const d3 = [p2[0] - p1[0] - p3[0], p2[1] - p1[1] - p3[1]];+ const den = d1[0] * d2[1] - d2[0] * d1[1];+ const g = (d3[0] * d2[1] - d2[0] * d3[1]) / den;+ const h = (d1[0] * d3[1] - d3[0] * d1[1]) / den;+ return [+ p1[0] * (1 + g) + c0[0] * g,+ p3[0] * (1 + h) + c0[0] * h,+ c0[0],+ p1[1] * (1 + g) + c0[1] * g,+ p3[1] * (1 + h) + c0[1] * h,+ c0[1],+ g,+ h,+ 1,+ ];+}++function bilinear(q: FootageQuad, u: number, v: number): Point {+ const [tl, tr, br, bl] = q.corners;+ const top = [tl[0] + (tr[0] - tl[0]) * u, tl[1] + (tr[1] - tl[1]) * u];+ const bottom = [bl[0] + (br[0] - bl[0]) * u, bl[1] + (br[1] - bl[1]) * u];+ return [top[0] + (bottom[0] - top[0]) * v, top[1] + (bottom[1] - top[1]) * v];+}++/** Où tombe le point `(u, v)` du métrage (0..1 depuis son coin haut-gauche) dans l'image :+ * miroir de `TiltedQuad::point_px`. */+export function footagePoint(q: FootageQuad, u: number, v: number): Point {+ if (!q.projective) return bilinear(q, u, v);+ const m = homography(q);+ const w = m[6] * u + m[7] * v + 1;+ return [(m[0] * u + m[1] * v + m[2]) / w, (m[3] * u + m[4] * v + m[5]) / w];+}++/** Le point du métrage sous le point `(x, y)` de l'image : l'inverse de `footagePoint`. */+export function footageAt(q: FootageQuad, x: number, y: number): Point {+ if (q.projective) {+ const [a, b, c, d, e, f, g, h, i] = homography(q);+ // L'adjugée suffit : le facteur commun du déterminant s'en va à la division par `w`.+ const u = (e * i - f * h) * x + (c * h - b * i) * y + (b * f - c * e);+ const v = (f * g - d * i) * x + (a * i - c * g) * y + (c * d - a * f);+ const w = (d * h - e * g) * x + (b * g - a * h) * y + (a * e - b * d);+ return [u / w, v / w];+ }+ // Bilinéaire : pas de forme close commode, Newton converge en quelques pas sur un quad+ // convexe, prolongements hors de 0..1 compris.+ const [tl, tr, br, bl] = q.corners;+ let [u, v] = [0.5, 0.5];+ for (let step = 0; step < 16; step++) {+ const [px, py] = bilinear(q, u, v);+ const dxu = (tr[0] - tl[0]) * (1 - v) + (br[0] - bl[0]) * v;+ const dyu = (tr[1] - tl[1]) * (1 - v) + (br[1] - bl[1]) * v;+ const dxv = (bl[0] - tl[0]) * (1 - u) + (br[0] - tr[0]) * u;+ const dyv = (bl[1] - tl[1]) * (1 - u) + (br[1] - tr[1]) * u;+ const det = dxu * dyv - dxv * dyu;+ if (Math.abs(det) < 1e-12) break;+ const [ex, ey] = [px - x, py - y];+ u -= (ex * dyv - ey * dxv) / det;+ v -= (ey * dxu - ex * dyu) / det;+ }+ return [u, v];+}diff --git a/src/native/contracts.ts b/src/native/contracts.tsindex 10164ad18..ee69d0cb2 100644--- a/src/native/contracts.ts+++ b/src/native/contracts.ts@@ -160,6 +160,11 @@ export interface CompositorFramePacket {width: number;height: number;data: Buffer;+ /** The footage in this frame: its TL, TR, BR, BL corners (x, y as fractions of the frame,+ * eight numbers), where a privacy blur's gimbal goes. Absent before anything is composed. */+ footage?: number[] | null;+ /** The footage maps from those corners by their homography (real camera), not bilinearly. */+ footageProjective?: boolean;}/** Un clip de la timeline pour l'export multiclip natif (fichiers screen+webcam + trim). */diff --git a/src/native/footageQuadStore.ts b/src/native/footageQuadStore.tsnew file mode 100644index 000000000..76d24e10f--- /dev/null+++ b/src/native/footageQuadStore.ts@@ -0,0 +1,38 @@+// Le métrage dans la dernière image de l'aperçu natif (`FootageQuad`), que chaque image du+// compositeur porte avec ses pixels. Le gimbal d'un flou de confidentialité s'y pose : là où le+// compositeur peint le masque, sous un zoom comme sous la 3D.++import { useSyncExternalStore } from "react";+import { type FootageQuad, quadFromPacket } from "@/lib/ai-edition/annotations/footageQuad";++let current: FootageQuad | null = null;+let currentKey = "";+const listeners = new Set<() => void>();++/** Retient le métrage d'une image livrée. Ne réveille ses lecteurs que s'il a bougé : en pause,+ * les images se suivent à l'identique. `null` l'oublie (vue détruite). */+export function publishFootageQuad(+ footage: readonly number[] | null | undefined,+ projective?: boolean,+): void {+ const next = quadFromPacket(footage, projective);+ const key = next ? `${next.projective}:${next.corners.flat().join(",")}` : "";+ if (key === currentKey) return;+ currentKey = key;+ current = next;+ for (const listener of listeners) listener();+}++function subscribe(listener: () => void): () => void {+ listeners.add(listener);+ return () => listeners.delete(listener);+}++/** Le métrage de la dernière image livrée ; `null` avant la première. */+export function useFootageQuad(): FootageQuad | null {+ return useSyncExternalStore(+ subscribe,+ () => current,+ () => null,+ );+}diff --git a/src/native/hooks/useNativeCompositorView.ts b/src/native/hooks/useNativeCompositorView.tsindex 222ffd754..e07953268 100644--- a/src/native/hooks/useNativeCompositorView.ts+++ b/src/native/hooks/useNativeCompositorView.ts@@ -30,6 +30,7 @@ import {setCompositorRect,} from "../compositorViewClient";import type { CompositorParamValue, CompositorViewRect } from "../contracts";+import { publishFootageQuad } from "../footageQuadStore";import { computeDeviceRect, rectsEqual } from "../nativeViewRect";export interface UseNativeCompositorViewOptions {@@ -218,6 +219,8 @@ export function useNativeCompositorView(if (data.byteLength !== width * height * 4 || width === 0 || height === 0) {return;}+ // Where the footage lies in this frame: a privacy blur's gimbal follows it.+ publishFootageQuad(frame.footage, frame.footageProjective);// Wrap the received buffer DIRECTLY — no intermediate copy. `data` is a// fresh per-frame Buffer from IPC (never pooled or reused across frames),// so a view over it is valid for the lifetime of this paint, and nothing@@ -316,6 +319,7 @@ export function useNativeCompositorView(return () => {disposed = true;+ publishFootageQuad(null);if (rectRafHandle !== 0) {cancelAnimationFrame(rectRafHandle);}