fix: preserve layout zoom framing and camera roundness

Author: EtienneLescot

crates/compositor/src/frame_geometry.rs

@@ -3366,7 +3366,16 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         // ratio de boîte se lit sur `s_base` : `remap_box` met les deux axes à la même
         // échelle, donc la boîte finale a le même ratio et le cover ne dépend pas d'elle
         // (ce qui casserait la circularité coupe → boîte → coupe).
-        let screen_cover = sampled_layout.as_ref().map(|s| s.layout.screen_cover)
+        // A zoom already running inside a block keeps that viewport until it settles.
+        // Releasing its clip halfway into PiP would inflate the frame and then shrink it
+        // during the same zoom-out. This is derived from time, so seeks and exports agree.
+        let keep_screen_clip = zoom_strength > 0.0 && sampled_layout.as_ref()
+            .and_then(|s| s.keep_screen_clip_from_sec)
+            .is_some_and(|from| crate::regions::zoom_continues_since(zoom_regions, from, source_t, &clock));
+        let keep_screen_clip_prev = zoom_strength_prev > 0.0 && previous_layout.as_ref()
+            .and_then(|s| s.keep_screen_clip_from_sec)
+            .is_some_and(|from| crate::regions::zoom_continues_since(zoom_regions, from, source_t_prev, &clock));
+        let screen_cover = keep_screen_clip || sampled_layout.as_ref().map(|s| s.layout.screen_cover)
             .unwrap_or_else(|| scene.map(|s| s.layout.screen_cover).unwrap_or(false));
         let cover_box_ar = screen_cover.then_some((s_base[2] * rw) / (s_base[3] * rh).max(0.0001));
         // Remplissage du format (`screen_follow`) : la fenêtre du cover suit le curseur lissé,
@@ -3376,8 +3385,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
             let (x, y) = cursor.filter(|_| follow)?.follow_at(t)?;
             Some([x * u_max, y * v_max])
         };
-        let previous_cover_box_ar = previous_layout.as_ref()
-            .map(|sample| sample.layout.screen_cover).unwrap_or(screen_cover)
+        let previous_cover_box_ar = (keep_screen_clip_prev || previous_layout.as_ref()
+            .map(|sample| sample.layout.screen_cover).unwrap_or(screen_cover))
             .then_some((s_base_prev[2] * rw) / (s_base_prev[3] * rh).max(0.0001));
         let cover_for = |uv: [f32; 4], at: Option<[f32; 2]>, box_ar: Option<f32>| -> [f32; 4] {
             match (box_ar, at) {
@@ -3602,7 +3611,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         // Le remplissage incliné n'a pas de masque : sa boîte est le slot, et la carte penche entière.
         let screen_mask = (screen_cover && !fill_tilt).then(|| {
             let slot_px = [s_base[2] * rw, s_base[3] * rh];
-            let cover_mix = sampled_layout.as_ref().map(|s| s.screen_cover_mix).unwrap_or(1.0);
+            let cover_mix = if keep_screen_clip { 1.0 }
+                else { sampled_layout.as_ref().map(|s| s.screen_cover_mix).unwrap_or(1.0) };
             let slot_radius = screen_corner_radius_px(outer_radius_of(slot_px), slot_px);
             ScreenMask {
                 // A free PiP has no clipping; its equivalent mask is the zoomed box.
@@ -4854,7 +4864,8 @@ mod tests {
                 webcam_rect: camera, screen_radius_frac: None, webcam_radius_frac: Some(0.0),
                 webcam_shape: Some("rectangle".to_owned()), screen_cover: false,
             },
-            webcam_reactive_zoom: false, from_layout: None, from_preset: None, from_webcam_reactive_zoom: None, transition_start_sec: start, transition_sec: 0.0,
+            webcam_reactive_zoom: false, from_layout: None, from_preset: None, from_webcam_reactive_zoom: None,
+            keep_screen_clip_from_sec: None, transition_start_sec: start, transition_sec: 0.0,
         }
     }
 
@@ -4977,6 +4988,90 @@ mod tests {
         assert_ne!(g.w_dst, g.w_dst_prev, "an animated camera keeps its motion trail");
     }
 
+    #[test]
+    fn layout_animation_does_not_puff_the_footage_during_an_existing_zoom() {
+        use crate::scene::SceneRect;
+        let mut scene = golden_scene();
+        scene.effects.frame = crate::scene::SceneFrame::Phone;
+        scene.crop_by_clip = vec![None];
+        let mut zoom = zoomed_golden_scene().zoom_regions.remove(0);
+        zoom.start_sec = 0.963;
+        zoom.end_sec = 1.301;
+        zoom.scale = 1.8;
+        let mut later_zoom = zoom.clone();
+        later_zoom.start_sec = 5.0;
+        later_zoom.end_sec = 6.0;
+        scene.zoom_regions = vec![zoom, later_zoom];
+        let screen = SceneRect { x: 0.114792, y: 0.077604, width: 0.770416, height: 0.292708 };
+        let mut block = layout_region("vertical-stack", 0.0, 1.129, None);
+        block.layout.screen_rect = screen;
+        block.layout.screen_cover = true;
+        let mut pip = layout_region("picture-in-picture", 1.129, 2.163, None);
+        pip.layout.screen_rect = SceneRect { y: 0.353646, ..screen };
+        pip.from_layout = Some(block.layout.clone());
+        pip.transition_sec = 0.2;
+        pip.keep_screen_clip_from_sec = Some(1.129);
+        let mut no_camera = layout_region("no-webcam", 2.163, 10.0, None);
+        no_camera.layout.screen_rect = pip.layout.screen_rect;
+        no_camera.from_layout = Some(pip.layout.clone());
+        no_camera.transition_sec = 0.1345;
+        no_camera.keep_screen_clip_from_sec = Some(1.129);
+        scene.layout_regions = vec![block, pip, no_camera];
+        let cfg = crate::config::all().pop().expect("compositor config");
+        let sample = |t| {
+            let mut input = golden_input(&scene, &cfg);
+            input.render_px = [1298.0, 1920.0];
+            input.timeline_t_override = Some(t);
+            plan_frame(&input)
+        };
+        // Same footage size at both endpoints: moving from top to centre must not inflate it.
+        for frame in 0..=180 {
+            let t = 1.129 + frame as f32 / 120.0;
+            let g = sample(t);
+            assert!((g.frame_box()[2] - screen.width).abs() < 0.0001,
+                "at {t}: the footage grew to {} instead of {}", g.frame_box()[2], screen.width);
+            assert!((g.frame_box()[3] - screen.height).abs() < 0.0001,
+                "at {t}: the footage height pulsed");
+        }
+        assert!(sample(1.25).s_dst[2] > screen.width + 0.1, "the existing zoom still runs inside");
+        let next = sample(5.5);
+        assert!(next.screen_mask.is_none(), "a later independent PiP zoom must stay free");
+        assert!(next.s_dst[2] > screen.width + 0.1);
+    }
+
+    #[test]
+    fn layout_animation_preserves_camera_roundness_while_it_disappears() {
+        use crate::scene::SceneRect;
+        let cfg = crate::config::all().pop().expect("compositor config");
+        for radius in [0.0, 0.06, 0.3, 0.5] {
+            for appearing in [false, true] {
+                let mut scene = golden_scene();
+                let mut camera = layout_region("picture-in-picture", 0.0, 3.0,
+                    Some(SceneRect { x: 0.7, y: 0.6, width: 0.2, height: 0.2 * 16.0 / 9.0 }));
+                camera.layout.webcam_radius_frac = Some(radius);
+                let mut hidden = layout_region("no-webcam", 0.0, 3.0, None);
+                hidden.layout.webcam_radius_frac = None;
+                let (source, mut target) = if appearing { (hidden, camera) } else { (camera, hidden) };
+                target.start_sec = 3.0;
+                target.end_sec = 10.0;
+                target.transition_start_sec = 3.0;
+                target.transition_sec = 0.2;
+                target.from_layout = Some(source.layout.clone());
+                scene.layout_regions = vec![source, target];
+                for progress in [0.05, 0.25, 0.5, 0.75, 0.95] {
+                    let mut input = golden_input(&scene, &cfg);
+                    input.render_px = [1920.0, 1080.0];
+                    input.timeline_t_override = Some(3.0 + 0.2 * progress);
+                    let g = plan_frame(&input);
+                    let side = (g.w_dst[2] * 1920.0).min(g.w_dst[3] * 1080.0);
+                    assert!(side > 0.0);
+                    assert!((g.w_radius / side - radius).abs() < 0.0001,
+                        "roundness {radius}, appearing {appearing}, progress {progress}: got {}", g.w_radius / side);
+                }
+            }
+        }
+    }
+
     #[test]
     fn every_layout_pair_has_continuous_footage_at_both_transition_edges() {
         use crate::scene::{SceneFrame, SceneRect};

crates/compositor/src/regions.rs

@@ -835,6 +835,37 @@ fn connected_pairs(
     pairs
 }
 
+/// Whether the same uninterrupted zoom is still running after `since` (source time).
+/// Uses the zoom sampler's envelope duration, screen clock and connected-pan graph.
+/// Once the image settles, a later independent zoom must not inherit a former layout's clip.
+pub fn zoom_continues_since(
+    regions: &[SceneZoomRegion],
+    since: f32,
+    t: f32,
+    clock: &ScreenClock,
+) -> bool {
+    if regions.is_empty() || t < since { return false; }
+    let (since, t) = (clock.at(since), clock.at(t));
+    let mut spans: Vec<(f32, f32)> = regions.iter().map(|r| {
+        let window = if r.under_trim { 0.0 } else { zoom_transition_s(r.scale) };
+        (clock.at(r.start_sec as f32) - window, clock.at(r.end_sec as f32) + window)
+    }).collect();
+    spans.extend(connected_pairs(regions, clock).into_iter().map(|(_, ni, start, end)|
+        (start, end.max(clock.at(regions[ni].start_sec as f32)))));
+    spans.sort_by(|a, b| a.0.total_cmp(&b.0));
+    let mut covered_to: Option<f32> = None;
+    for (start, end) in spans {
+        match covered_to {
+            Some(until) if start > until => return false,
+            Some(until) => covered_to = Some(until.max(end)),
+            None if start < since && since < end => covered_to = Some(end),
+            None => continue,
+        }
+        if covered_to.is_some_and(|until| t < until) { return true; }
+    }
+    false
+}
+
 /// `zoom_state_in` sans speed region ni piste pour l'orbite : ce que les tests comparent.
 #[cfg(test)]
 pub fn zoom_state_at(
@@ -1703,6 +1734,53 @@ mod zoom_focus_tests {
         }
     }
 
+    #[test]
+    fn layout_zoom_continuity_stops_before_a_later_independent_zoom() {
+        let first = region(1.8, 0.5);
+        let mut later = region(1.8, 0.5);
+        later.start_sec = 14.0;
+        later.end_sec = 16.0;
+        let window = zoom_transition_s(first.scale);
+        let regions = [first, later];
+        let clock = ScreenClock::default();
+        assert!(zoom_continues_since(&regions, 4.0, 8.0 + window * 0.9, &clock));
+        assert!(!zoom_continues_since(&regions, 4.0, 8.0 + window, &clock));
+        assert!(!zoom_continues_since(&regions, 4.0, 15.0, &clock));
+        assert!(!zoom_continues_since(&regions, 4.0, 3.0, &clock));
+        assert!(!zoom_continues_since(&regions, 0.0, 4.0, &clock));
+    }
+
+    #[test]
+    fn layout_zoom_continuity_includes_the_connected_pan_and_hold() {
+        let mut first = region(1.25, 0.5);
+        first.end_sec = 3.0;
+        let mut next = region(1.25, 0.7);
+        next.start_sec = 4.49;
+        next.end_sec = 6.0;
+        let regions = [first, next];
+        let clock = ScreenClock::default();
+        // The independent envelopes leave a hole; the connected pan fills it.
+        let middle = 3.745;
+        assert_eq!(zoom_region_strength(&regions[0], middle, &clock), 0.0);
+        assert_eq!(zoom_region_strength(&regions[1], middle, &clock), 0.0);
+        assert!(zoom_state_at(&regions, middle, None).strength > 0.0);
+        assert!(zoom_continues_since(&regions, 2.5, middle, &clock));
+        assert!(zoom_continues_since(&regions, 2.5, 6.2, &clock));
+    }
+
+    #[test]
+    fn layout_zoom_continuity_uses_the_same_speed_clock_and_trim_gate() {
+        let zoom = region(1.8, 0.5);
+        let window = zoom_transition_s(zoom.scale);
+        let speeds = [SceneSpeedRegion { start_sec: 0.0, end_sec: 30.0, speed: 2.0, clip_index: Some(0) }];
+        let clock = ScreenClock::new(&speeds, 0);
+        assert!(zoom_continues_since(&[zoom.clone()], 4.0, 8.0 + window * 1.5, &clock));
+        assert!(!zoom_continues_since(&[zoom.clone()], 4.0, 8.0 + window * 2.0 + 0.001, &clock));
+        let trimmed = SceneZoomRegion { under_trim: true, ..zoom };
+        assert!(zoom_continues_since(&[trimmed.clone()], 4.0, 7.99, &clock));
+        assert!(!zoom_continues_since(&[trimmed], 4.0, 8.01, &clock));
+    }
+
     /// Le focus automatique ne « perd » jamais la piste : hors de ses bornes, il tient la
     /// dernière (ou la première) position suivie au lieu de retomber sur le point statique de la
     /// région. Sans ça, le plan net sauterait d'un bout de l'écran à l'autre à la fin de la

crates/compositor/src/scene.rs

@@ -175,6 +175,9 @@ pub struct SceneLayoutRegion {
     pub from_preset: Option<String>,
     #[serde(default)]
     pub from_webcam_reactive_zoom: Option<bool>,
+    /// Last contained-layout exit in source time. A zoom crossing it keeps its viewport.
+    #[serde(default)]
+    pub keep_screen_clip_from_sec: Option<f32>,
     pub transition_start_sec: f32,
     pub transition_sec: f32,
 }
@@ -188,6 +191,7 @@ pub struct SampledLayout<'a> {
     pub screen_cover_mix: f32,
     pub webcam_reactive_zoom: f32,
     pub webcam_shadow: f32,
+    pub keep_screen_clip_from_sec: Option<f32>,
 }
 
 impl SceneLayoutRegion {
@@ -225,13 +229,20 @@ impl SceneLayoutRegion {
                 // Keep the crop policy through the morph. Its mask is blended separately;
                 // switching the flag at the boundary exposes the entire zoomed footage.
                 layout.screen_cover = from.screen_cover || layout.screen_cover;
-                layout.webcam_radius_frac = Some(mix(from.webcam_radius_frac.unwrap_or(0.0),
-                    layout.webcam_radius_frac.unwrap_or(0.0)));
+                // A missing camera is a scaled-down endpoint of the visible one, not a
+                // square mask. Keep its relative roundness while its rectangle collapses.
+                layout.webcam_radius_frac = match (from.webcam_rect, self.layout.webcam_rect) {
+                    (Some(_), None) => from.webcam_radius_frac,
+                    (None, Some(_)) => self.layout.webcam_radius_frac,
+                    _ => Some(mix(from.webcam_radius_frac.unwrap_or(0.0),
+                        layout.webcam_radius_frac.unwrap_or(0.0))),
+                };
                 layout.webcam_shape = Some("rectangle".to_owned());
             }
         }
         SampledLayout { preset: &self.preset, layout, from_layout: self.from_layout.as_ref(),
             hard_cut: self.from_layout.is_none() || self.transition_sec <= 0.0,
+            keep_screen_clip_from_sec: self.keep_screen_clip_from_sec,
             progress, screen_cover_mix, webcam_reactive_zoom: reactive, webcam_shadow }
     }
 }

src/lib/compositeLayout.test.ts

@@ -791,6 +791,20 @@ describe("interpolateCompositeLayout", () => {
 		expect(interpolateCompositeLayout(pip, screenOnly, 0.999).webcamRect?.width).toBeGreaterThan(0);
 		expect(interpolateCompositeLayout(screenOnly, screenOnly, 0.5).webcamRect).toBeNull();
 	});
+
+	it("preserves the camera's relative corner radius throughout appearance and disappearance", () => {
+		for (const progress of [0.05, 0.25, 0.5, 0.75, 0.95]) {
+			for (const [from, to] of [
+				[pip, screenOnly],
+				[screenOnly, pip],
+			]) {
+				const camera = interpolateCompositeLayout(from, to, progress).webcamRect;
+				expect(camera).not.toBeNull();
+				if (camera)
+					expect(camera.borderRadius / Math.min(camera.width, camera.height)).toBeCloseTo(0.5);
+			}
+		}
+	});
 });
 
 describe("computeCameraFullscreenRect", () => {

src/native/layoutScene.test.ts

@@ -43,6 +43,54 @@ function footage() {
 }
 
 describe("layout scene consumed by preview, MP4 and GIF", () => {
+	it("carries the last contained exit across free passages even when a trim hides it", () => {
+		const base = footage();
+		base.legacyEditor = { webcamLayoutPreset: "vertical-stack" };
+		const doc = addLayoutChange(addLayoutChange(base, 2, "picture-in-picture"), 4, "no-webcam");
+		const regions = buildSceneDescription(doc).layoutRegions;
+		expect(regions?.map((r) => r.keepScreenClipFromSec)).toEqual([undefined, 22, 22]);
+		doc.timeline.trimRanges = [
+			{
+				id: "before",
+				clipId: "clip",
+				assetId: "asset",
+				startSec: 20,
+				endSec: 24.5,
+				origin: "user",
+				reason: "test",
+			},
+		];
+		const visible = buildSceneDescription(doc).layoutRegions?.find((r) => r.preset === "no-webcam");
+		expect(visible?.startSec).toBe(24.5);
+		expect(visible?.keepScreenClipFromSec).toBe(22);
+	});
+
+	it("does not inherit another clip's contained-layout history", () => {
+		const base = footage();
+		base.timeline.clips.push({
+			...base.timeline.clips[0],
+			id: "second",
+			timelineStartSec: 10,
+			timelineEndSec: 20,
+		});
+		const doc = addLayoutChange(
+			addLayoutChange(base, 2, "vertical-stack"),
+			6,
+			"picture-in-picture",
+		);
+		const scene = buildSceneDescription(doc);
+		expect(scene.layoutRegions?.filter((r) => r.clipIndex === 1)).toHaveLength(1);
+		expect(
+			scene.layoutRegions
+				?.filter((r) => r.clipIndex === 1)
+				.every((r) => r.keepScreenClipFromSec === undefined),
+		).toBe(true);
+		expect(
+			scene.layoutRegions?.find((r) => r.clipIndex === 0 && r.startSec === 26)
+				?.keepScreenClipFromSec,
+		).toBe(26);
+	});
+
 	it("projects passages into source time with full camera and no-webcam geometry", () => {
 		const doc = addLayoutChange(addLayoutChange(footage(), 2, "camera-only"), 4, "no-webcam");
 		const scene = buildSceneDescription(doc);

src/native/sceneDescription.ts

@@ -57,6 +57,7 @@ import {
 } from "@/lib/ai-edition/timeline/zoom-scale";
 import {
 	computeCompositeLayout,
+	isWebcamBlockLayout,
 	paddedContentSize,
 	type RenderRect,
 	resolveWebcamLayoutPreset,
@@ -418,6 +419,8 @@ export interface SceneLayoutRegion {
 	fromLayout?: ResolvedClipLayout;
 	fromPreset?: LayoutPreset;
 	fromWebcamReactiveZoom?: boolean;
+	/** Last contained-layout exit in source seconds. An ongoing zoom keeps that viewport until it settles. */
+	keepScreenClipFromSec?: number;
 	/** Original passage start in source seconds; trimming must not restart its animation. */
 	transitionStartSec: number;
 	/** Duration in source seconds, or 0 without fromLayout (including legacy-camera neighbours). */
@@ -1372,6 +1375,22 @@ export function buildSceneDescription(
 		);
 		const fromLayout =
 			!region.legacyCamera && previous && !previous.legacyCamera ? resolve(previous.preset) : null;
+		// Carry this history through later free passages and trim projections. Native can
+		// then keep a zoom already in flight inside its viewport, without constraining a new one.
+		const keepScreenClipFromSec = storedLayouts.reduce<number | undefined>((last, candidate) => {
+			if (
+				candidate.clipId !== region.clipId ||
+				candidate.sourceEndSec === undefined ||
+				region.sourceStartSec === undefined ||
+				candidate.sourceEndSec > region.sourceStartSec + 0.0001 ||
+				!(
+					formatFill ||
+					(hasCamera && isWebcamBlockLayout(candidate.legacyCamera?.basePreset ?? candidate.preset))
+				)
+			)
+				return last;
+			return Math.max(last ?? -Infinity, candidate.sourceEndSec);
+		}, undefined);
 		return [
 			{
 				clipIndex: region.clipIndex,
@@ -1380,6 +1399,7 @@ export function buildSceneDescription(
 				preset,
 				layout,
 				webcamReactiveZoom: resolveWebcamReactiveZoom(preset, settings.webcamReactiveZoom),
+				...(keepScreenClipFromSec === undefined ? {} : { keepScreenClipFromSec }),
 				...(fromLayout && previous
 					? {
 							fromLayout,