feat(editor): add waveform, audio mastering, and webcam crop

crates/compositor/src/audio.rs

@@ -4,6 +4,7 @@
 
 use crate::ffi::*;
 use crate::regions::SpeedSegment;
+use crate::scene::SceneAudio;
 use anyhow::{bail, Result};
 use std::f32::consts::PI;
 use std::ffi::CString;
@@ -26,6 +27,60 @@ const PASSTHROUGH_EPSILON: f64 = 1e-3;
 
 pub type PlanarPcm = Vec<Vec<f32>>;
 
+/// Apply the editor's output trim and signed sync offset to the assembled timeline.
+///
+/// Both stages are stateless on purpose. The editor preview plays the untouched source file
+/// (seeked), while this runs on the assembled timeline — trimmed, speed-adjusted, concatenated
+/// — so the two see different signals. A linear gain and a whole-sample delay are the only
+/// operations that land identically on both, which is what lets the editor claim that what you
+/// hear is what you export.
+///
+/// That rules out the obvious next feature. A filter or a compressor carries state across
+/// cuts here and not in the preview; a loudness normaliser is worse still, because its makeup
+/// is a single scalar measured over the whole assembled programme, which the preview never
+/// holds and which changes with every trim. Adding either back means either an offline preview
+/// render or an accepted, documented divergence — not a quiet extra stage in this function.
+///
+/// Bounds mirror `AUDIO_GAIN_DB_LIMIT` / `AUDIO_OFFSET_MS_LIMIT` in editorSettings.ts. The
+/// result stays the same length so video and following clips cannot drift.
+pub fn finish_audio(mut pcm: PlanarPcm, settings: SceneAudio) -> PlanarPcm {
+    let samples = pcm.first().map(Vec::len).unwrap_or(0);
+    if samples == 0 {
+        return pcm;
+    }
+    for channel in pcm.iter_mut() {
+        channel.resize(samples, 0.0);
+    }
+
+    let trim = 10.0f32.powf(settings.gain_db.clamp(-12.0, 12.0) / 20.0);
+    for sample in pcm.iter_mut().flatten() {
+        *sample = (*sample * trim).clamp(-1.0, 1.0);
+    }
+
+    let shift = ((settings.offset_ms.clamp(-500.0, 500.0) / 1_000.0)
+        * AUDIO_OUTPUT_SAMPLE_RATE as f64)
+        .round() as i64;
+    if shift == 0 {
+        return pcm;
+    }
+    if shift > 0 {
+        let destination = (shift as usize).min(samples);
+        let count = samples - destination;
+        for channel in pcm.iter_mut() {
+            channel.copy_within(..count, destination);
+            channel[..destination].fill(0.0);
+        }
+    } else {
+        let source = ((-shift) as usize).min(samples);
+        let count = samples - source;
+        for channel in pcm.iter_mut() {
+            channel.copy_within(source.., 0);
+            channel[count..].fill(0.0);
+        }
+    }
+    pcm
+}
+
 extern "C" {
     fn sn_fmt_stream(s: *mut AVFormatContext, i: i32) -> *mut AVStream;
     // bindgen rend `AVFormatContext` opaque (atteinte seulement par pointeur), d'où l'accesseur
@@ -1063,4 +1118,71 @@ mod tests {
         let mixed = mix_aligned_tracks(&[(-0.001, &early)], 0.0, 8);
         assert_eq!(mixed[0], vec![0.5; 8]);
     }
+
+    #[test]
+    fn signed_audio_offset_is_length_preserving() {
+        let settings = SceneAudio {
+            offset_ms: 1000.0 / AUDIO_OUTPUT_SAMPLE_RATE as f64,
+            gain_db: 0.0,
+        };
+        // Values stay inside [-1, 1] so this asserts the shift, not the output clamp.
+        let delayed = finish_audio(planar(&[0.1, 0.2, 0.3]), settings);
+        assert_eq!(delayed[0], vec![0.0, 0.1, 0.2]);
+
+        let advanced = finish_audio(
+            planar(&[0.1, 0.2, 0.3]),
+            SceneAudio {
+                offset_ms: -1000.0 / AUDIO_OUTPUT_SAMPLE_RATE as f64,
+                ..settings
+            },
+        );
+        assert_eq!(advanced[0], vec![0.2, 0.3, 0.0]);
+    }
+
+    /// The gain must be the SAME scalar the editor preview feeds its GainNode
+    /// (`10 ** (dB / 20)`), because that identity is the whole parity guarantee: nothing
+    /// else stands between what the editor plays and what this writes.
+    #[test]
+    fn output_trim_is_the_same_scalar_the_preview_applies() {
+        for gain_db in [-12.0f32, -6.0206, 0.0, 6.0206, 12.0] {
+            let result = finish_audio(
+                planar(&[0.25, -0.25]),
+                SceneAudio {
+                    offset_ms: 0.0,
+                    gain_db,
+                },
+            );
+            let expected = (0.25 * 10.0f32.powf(gain_db / 20.0)).clamp(-1.0, 1.0);
+            assert!(
+                (result[0][0] - expected).abs() < 1e-6,
+                "gain {gain_db} dB: got {}, want {expected}",
+                result[0][0]
+            );
+            assert!((result[0][1] + expected).abs() < 1e-6);
+        }
+    }
+
+    #[test]
+    fn out_of_range_settings_are_clamped_to_the_editor_bounds() {
+        // A hand-edited project (or a future UI change) must not be able to ask for an
+        // offset or a gain the sliders cannot display.
+        let result = finish_audio(
+            planar(&[0.5, 0.5]),
+            SceneAudio {
+                offset_ms: 9_999.0,
+                gain_db: 99.0,
+            },
+        );
+        assert_eq!(result[0], vec![0.0, 0.0], "offset clamps to 500 ms, not 10 s");
+
+        let quiet = finish_audio(
+            planar(&[0.5]),
+            SceneAudio {
+                offset_ms: 0.0,
+                gain_db: -99.0,
+            },
+        );
+        let floor = 0.5 * 10.0f32.powf(-12.0 / 20.0);
+        assert!((quiet[0][0] - floor).abs() < 1e-6);
+    }
 }

crates/compositor/src/compositor_linux.rs

@@ -1230,9 +1230,12 @@ impl Compositor {
             // `cover_crop_uv` est la primitive partagee que macOS et Windows
             // utilisent ; elle rend le rect inchange quand il a deja le bon
             // ratio, donc aucun placement correct ne bouge.
-            let (cu0, cv0, cu1, cv1) = crate::frame_geometry::cover_crop_uv(
+            let [cu0, cv0, cu1, cv1] = crate::frame_geometry::webcam_source_rect(
                 [wcw, wch],
                 [wtw as f32, wth as f32],
+                scene_ref
+                    .as_ref()
+                    .and_then(|scene| scene.layout.webcam_crop),
                 g.w_px[0] / g.w_px[1].max(0.0001),
             );
             // MIROIR : on inverse l'intervalle u. Le VS interpole `src`

crates/compositor/src/compositor_macos.rs

@@ -1601,9 +1601,10 @@ impl Compositor {
         // --- caméra : ombre PiP puis vidéo ---
         let enc = self.begin_pass(cmd_buf, &self.rt, None, &self.pipeline_main)?;
         if let (true, Some((wy, wuv))) = (lp.has_webcam, webcam_tex.as_ref()) {
-            let (cu0, cv0, cu1, cv1) = crate::frame_geometry::cover_crop_uv(
+            let [cu0, cv0, cu1, cv1] = crate::frame_geometry::webcam_source_rect(
                 [wcw, wch],
                 [wtw as f32, wth as f32],
+                scene_ref.as_ref().and_then(|scene| scene.layout.webcam_crop),
                 g.w_px[0] / g.w_px[1].max(0.0001),
             );
             let (u0, u1) = if lp.webcam_mirror { (cu1, cu0) } else { (cu0, cu1) };

crates/compositor/src/compositor_windows.rs

@@ -1517,9 +1517,12 @@ impl Compositor {
         //
         // Le center-crop carré de square/circle en est un cas particulier (boîte 1:1) — il n'a
         // plus besoin d'être traité à part.
-        let (su0, sv0, su1, sv1) = cover_crop_uv(
+        let [su0, sv0, su1, sv1] = crate::frame_geometry::webcam_source_rect(
             [wcw, wch],
             [wtw as f32, wth as f32],
+            scene_ref
+                .as_ref()
+                .and_then(|scene| scene.layout.webcam_crop),
             w_px[0] / w_px[1].max(0.0001),
         );
         // miroir = échanger les bornes u du rect source (flip horizontal).

crates/compositor/src/frame_geometry.rs

@@ -284,6 +284,23 @@ pub(crate) fn cover_crop_uv(visible: [f32; 2], tex: [f32; 2], box_ar: f32) -> (f
     let [u0, v0, u1, v1] = cover_uv_rect(full, tex, box_ar);
     (u0, v0, u1, v1)
 }
+
+/// Camera equivalent of the screen crop pipeline: apply the user crop first, then a centred
+/// cover-crop inside that authored window so arbitrary layout slots never stretch the image.
+pub(crate) fn webcam_source_rect(
+    visible: [f32; 2],
+    tex: [f32; 2],
+    crop: Option<SceneCrop>,
+    box_ar: f32,
+) -> [f32; 4] {
+    let u_max = visible[0].max(1.0) / tex[0].max(1.0);
+    let v_max = visible[1].max(1.0) / tex[1].max(1.0);
+    cover_uv_rect(
+        screen_source_rect(u_max, v_max, crop, 1.0, [0.5, 0.5]),
+        tex,
+        box_ar,
+    )
+}
 /// Rétrécit un rect SOURCE déjà exprimé en UV (`[u0, v0, u1, v1]`) autour de son
 /// centre pour qu'il porte le ratio `box_ar` une fois rapporté aux pixels de la
 /// texture. C'est la forme générale de `object-fit: cover`, et LA primitive qui
@@ -1750,4 +1767,22 @@ mod tests {
         assert!((su0 - (960.0 - 720.0) * 0.5 / tex[0]).abs() < 1e-6);
         assert!((su1 - (960.0 + 720.0) * 0.5 / tex[0]).abs() < 1e-6);
     }
+
+    #[test]
+    fn webcam_crop_identity_keeps_the_full_visible_frame() {
+        let uv = webcam_source_rect([1280.0, 720.0], [2048.0, 1024.0], None, 16.0 / 9.0);
+        assert_rect(uv, [0.0, 0.0, 1280.0 / 2048.0, 720.0 / 1024.0]);
+    }
+
+    #[test]
+    fn webcam_crop_applies_authored_zoom_and_pan_before_layout_cover() {
+        let crop = SceneCrop {
+            x: 0.25,
+            y: 0.20,
+            width: 0.50,
+            height: 0.60,
+        };
+        let uv = webcam_source_rect([100.0, 100.0], [100.0, 100.0], Some(crop), 0.50 / 0.60);
+        assert_rect(uv, [0.25, 0.20, 0.75, 0.80]);
+    }
 }

crates/compositor/src/pipeline_linux.rs

@@ -21,7 +21,7 @@ use std::ffi::CString;
 use std::ptr;
 
 use crate::audio::{
-    assemble_concatenated_pcm, build_audio_concat_plan, decode_clip_audio,
+    assemble_concatenated_pcm, build_audio_concat_plan, decode_clip_audio, finish_audio,
     stretch_clip_pcm_by_speed, AacEncoder, PlanarPcm,
 };
 use crate::config::Cfg;
@@ -457,6 +457,7 @@ pub fn run_composited_multi(
     let mut clip_frame_counts: Vec<u64> = vec![0; clips.len()];
 
     let scene = comp.scene_snapshot();
+    let audio_settings = scene.as_ref().map(|scene| scene.audio).unwrap_or_default();
     // Ring de staging a 2 : l'export ne veut que du debit, une frame de latence
     // ne se voit pas dans un fichier. Voir `Compositor::set_readback_depth` pour
     // la raison pour laquelle la preview, elle, reste a 1.
@@ -533,7 +534,10 @@ pub fn run_composited_multi(
         // raccourci voit son audio raccourci d'autant), puis un seul encode AAC.
         let declared_audio: Vec<bool> = clips.iter().map(|c| c.has_audio).collect();
         let plan = build_audio_concat_plan(&clip_frame_counts, &declared_audio, out_fps as f64);
-        audio_encoder.encode(&assemble_concatenated_pcm(&clip_pcm, &plan), octx)?;
+        audio_encoder.encode(
+            &finish_audio(assemble_concatenated_pcm(&clip_pcm, &plan), audio_settings),
+            octx,
+        )?;
         crate::ffi::averr(crate::ffi::av_write_trailer(octx), "write_trailer")?;
         crate::ffi::avio_closep(&mut pb);
         crate::ffi::avformat_free_context(octx);

crates/compositor/src/pipeline_macos.rs

@@ -30,7 +30,7 @@
 //! décodeurs, symétrique.
 
 use crate::audio::{
-    assemble_concatenated_pcm, build_audio_concat_plan, decode_clip_audio,
+    assemble_concatenated_pcm, build_audio_concat_plan, decode_clip_audio, finish_audio,
     stretch_clip_pcm_by_speed, AacEncoder, PlanarPcm,
 };
 use crate::compositor::Compositor;
@@ -1076,6 +1076,7 @@ pub fn run_composited_multi(
     // exactement le bug de troncature en slow-motion que la doc de `walk_composited_timeline`
     // raconte avoir déjà coûté une fois.
     let scene = comp.scene_snapshot();
+    let audio_settings = scene.as_ref().map(|scene| scene.audio).unwrap_or_default();
     frames = unsafe {
         crate::timeline_walk::walk_composited_timeline(
             clips,
@@ -1130,7 +1131,10 @@ pub fn run_composited_multi(
         // d'autant, sinon la piste dérive pour tous les suivants.
         let declared_audio: Vec<bool> = clips.iter().map(|clip| clip.has_audio).collect();
         let plan = build_audio_concat_plan(&clip_frame_counts, &declared_audio, out_fps as f64);
-        audio_encoder.encode(&assemble_concatenated_pcm(&clip_pcm, &plan), octx)?;
+        audio_encoder.encode(
+            &finish_audio(assemble_concatenated_pcm(&clip_pcm, &plan), audio_settings),
+            octx,
+        )?;
 
         crate::ffi::averr(
             crate::ffi::av_write_trailer(octx),
@@ -1188,4 +1192,4 @@ pub fn probe_frame_count(_path: &str) -> Result<u64> {
 // cfg-re-export `crate::compositor::Compositor`, et cette fonction helper garantit
 // que le type reste référencé.
 #[allow(dead_code)]
-fn _typecheck_compositor(_c: &Compositor, _g: &Gpu) {}
+fn _typecheck_compositor(_c: &Compositor, _g: &Gpu) {}

crates/compositor/src/pipeline_windows.rs

@@ -3,7 +3,7 @@
 //! tout le run, deux lectures seulement. Rien dans la boucle ne peut fausser le fps.
 
 use crate::audio::{
-    assemble_concatenated_pcm, build_audio_concat_plan, decode_clip_audio,
+    assemble_concatenated_pcm, build_audio_concat_plan, decode_clip_audio, finish_audio,
     stretch_clip_pcm_by_speed, AacEncoder, PlanarPcm,
 };
 use crate::compositor::{Compositor, OUT_H, OUT_W};
@@ -1342,6 +1342,7 @@ unsafe fn run_multi_inner(
     // La scène (déjà posée par l'appelant via comp.set_scene) pilote le curseur et le
     // fenêtrage par clip ; `walk_composited_timeline` s'en charge.
     let scene = comp.scene_snapshot();
+    let audio_settings = scene.as_ref().map(|scene| scene.audio).unwrap_or_default();
 
     // ---- encodeur (choisi à l'exécution, cf. ExportCodec::candidates) + mux ----
     // Backend CPU : pas de pool D3D11 du tout. `av_hwdevice_ctx_init(D3D11VA)` échoue sur
@@ -1465,7 +1466,10 @@ unsafe fn run_multi_inner(
         &declared_audio,
         out_fps as f64,
     );
-    let assembled_audio = assemble_concatenated_pcm(&clip_pcm, &audio_plan);
+    let assembled_audio = finish_audio(
+        assemble_concatenated_pcm(&clip_pcm, &audio_plan),
+        audio_settings,
+    );
     audio_encoder.encode(&assembled_audio, octx)?;
 
     averr(av_write_trailer(octx), "write_trailer")?;

crates/compositor/src/scene.rs

@@ -45,6 +45,9 @@ pub struct SceneLayout {
     pub webcam_position: Option<WebcamPosition>,
     /// la webcam rétrécit pendant un zoom actif.
     pub webcam_reactive_zoom: bool,
+    /// User-authored source crop for the camera. Absent keeps the full frame.
+    #[serde(default)]
+    pub webcam_crop: Option<SceneCrop>,
     /// Rect webcam résolu côté app (0..1 fractions du cadre de sortie), en PARITÉ EXACTE avec
     /// `computeCompositeLayout` (TS). Permet à TS et Rust de partager la même source de vérité :
     /// le natif ne dérive PLUS ses propres placements pour PiP/dual-frame/vertical-stack — il
@@ -361,6 +364,21 @@ pub struct SceneCrop {
     pub height: f32,
 }
 
+/// Audio finishing. Deliberately limited to a linear gain and a signed delay — the two
+/// operations the editor preview can apply identically to the source file it plays. See
+/// `audio::finish_audio` before adding a field here.
+///
+/// Every field carries `#[serde(default)]`: a payload from a build that predates one of them
+/// must degrade to "that stage is neutral", not fail the whole scene.
+#[derive(Debug, Clone, Copy, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SceneAudio {
+    #[serde(default)]
+    pub offset_ms: f64,
+    #[serde(default)]
+    pub gain_db: f32,
+}
+
 #[derive(Debug, Clone, Copy, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SceneOutput {
@@ -389,6 +407,9 @@ pub struct Scene {
     #[serde(default)]
     pub camera_fullscreen_regions: Vec<SceneCameraFullscreenRegion>,
     pub cursor: SceneCursor,
+    /// Global audio finishing. Default keeps old scene payloads bit-for-bit compatible.
+    #[serde(default)]
+    pub audio: SceneAudio,
     /// Crop écran par clip, dans le même ordre que `clips` (`cropByClip` côté TS).
     #[serde(default)]
     pub crop_by_clip: Vec<Option<SceneCrop>>,

src/components/ai-edition/NewEditorShell.module.css

@@ -2026,6 +2026,20 @@
   color: var(--danger);
 }
 
+.secondaryBtn {
+	margin: 4px var(--sp-4) 12px;
+	min-height: 32px;
+	padding: 0 12px;
+	border: 1px solid var(--border);
+	border-radius: var(--r-sm);
+	background: var(--surface-2);
+	color: var(--fg-2);
+	font: 500 12px/1 var(--font-body);
+	cursor: pointer;
+}
+.secondaryBtn:hover { background: var(--surface-3); color: var(--fg); }
+.secondaryBtn:disabled { opacity: 0.45; cursor: not-allowed; }
+
 .authPanel {
   padding: 14px 16px;
   border: 1px solid var(--brand);