Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

82.6 KB
Raw Blame
//! Verifie que le port Linux reconciliie sur v1.8.0 REND une frame :
//! `d3d::Gpu` -> `compositor::Compositor` -> `pipeline::Decoder` (les modules
//! Linux, via les alias cfg) -> `compose_frame` (geometrie partagee
//! `plan_frame`) -> `readback_direct`. Bypass le render-thread de `live.rs`
//! pour isoler la chaine de rendu elle-meme.
//!
//! Opt-in (rend sur GPU) : `OPENSCREEN_LINUX_COMPOSE=1` + la fixture
//! `crates/fixture/screen.mp4`. Sinon skip (le teardown Vulkan/Mesa segfault a
//! l'exit apres le rendu -- verifier via la sortie, pas l'exit code).

// Linux UNIQUEMENT, comme `warp_device_cannot_decode.rs` l'est a Windows. Les
// fichiers de `tests/` sont compiles quelle que soit la plateforme : sans cette
// porte, `cargo check` sous Windows resout `pipeline::Decoder` vers
// `pipeline_windows::Decoder`, qui est `pub(crate)` -- et le check Windows casse
// sur un test qui ne s'y executera jamais.
#![cfg(target_os = "linux")]

use std::path::Path;

use openscreen_compositor::compositor::Compositor;
use openscreen_compositor::config::Cfg;
use openscreen_compositor::cursor::CursorTrack;
use openscreen_compositor::d3d::Gpu;
use openscreen_compositor::pipeline::{
    run_composited_multi, ClipSource, Decoder, ExportCodec, ExportParams,
};
use openscreen_compositor::scene::Scene;

const FIXTURE: &str = "../fixture/screen.mp4";
const W: u32 = 960;
const H: u32 = 540;

/// Ecrit un PPM P6 dans `OPENSCREEN_VK_OUT` (defaut `target`) pour inspection.
fn write_ppm(name: &str, w: u32, h: u32, rgba: &[u8]) {
    use std::io::Write;
    let out = std::env::var("OPENSCREEN_VK_OUT").unwrap_or_else(|_| "target".into());
    let _ = std::fs::create_dir_all(&out);
    let path = format!("{out}/{name}.ppm");
    let mut f = std::fs::File::create(&path).expect("create ppm");
    write!(f, "P6\n{w} {h}\n255\n").unwrap();
    let mut rgb = vec![0u8; (w * h * 3) as usize];
    for (d, s) in rgb.chunks_exact_mut(3).zip(rgba.chunks_exact(4)) {
        d.copy_from_slice(&s[0..3]);
    }
    f.write_all(&rgb).unwrap();
    println!("wrote {path}");
}

#[test]
fn compose_linux_rend_une_frame() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux: opt-in (OPENSCREEN_LINUX_COMPOSE=1 + fixture). Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut dec = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    // Scene : fond gradient + padding (l'ecran est inset -> le fond floute se
    // voit tout autour) pour valider visuellement le blur du background.
    let scene_json = r##"{"clips":[],"layout":{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false},"effects":{"padding":0.18,"blur":true,"shadow":0,"roundnessFrac":0.05,"motionBlur":0},"background":{"kind":"gradient","angleDeg":45,"stops":["#ff3b6b","#3b6bff"]},"zoomRegions":[],"annotations":[],"cursor":{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"},"cropByClip":[],"output":{"width":1920,"height":1080,"fps":30}}"##;
    comp.set_scene(Some(Scene::from_json(scene_json).expect("scene json")));

    let (w, h, rgba) = unsafe {
        let sf = dec.seek_to(1.0).expect("Decoder::seek_to");
        let mut cfg = Cfg::c8();
        cfg.bg_blur = 1.0;
        // webcam = screen (mon compose coeur ne dessine que l'ecran).
        comp.compose_frame(sf, sf, 0.0, &cfg).expect("compose_frame");
        comp.readback_direct().expect("readback_direct")
    };

    let n = (rgba.len() / 4) as f32;
    let mut sum = 0u64;
    for px in rgba.chunks_exact(4) {
        sum += px[0] as u64;
    }
    let mean_r = sum as f32 / n;
    println!("compose_linux : {w}x{h} bytes={} mean_R={:.1}", rgba.len(), mean_r);

    // PPM P6 pour inspection visuelle.
    let out = std::env::var("OPENSCREEN_VK_OUT").unwrap_or_else(|_| "target".into());
    let _ = std::fs::create_dir_all(&out);
    let ppm = format!("{out}/compose_linux.ppm");
    {
        use std::io::Write;
        let mut f = std::fs::File::create(&ppm).expect("create ppm");
        write!(f, "P6\n{w} {h}\n255\n").unwrap();
        let mut rgb = vec![0u8; (w * h * 3) as usize];
        for (d, s) in rgb.chunks_exact_mut(3).zip(rgba.chunks_exact(4)) {
            d.copy_from_slice(&s[0..3]);
        }
        f.write_all(&rgb).unwrap();
    }
    println!("wrote {ppm}");

    assert_eq!(rgba.len(), (W * H * 4) as usize);
    assert!(
        mean_r > 5.0 && mean_r < 250.0,
        "mean R={mean_r} hors plage plausible (5..250) — frame vide ?"
    );
}

// ---------------------------------------------------------------------------
// Rotation 3D (modes 8 et 12)
// ---------------------------------------------------------------------------

/// Scene « ecran seul sur fond plat magenta », avec ou sans preset de rotation.
/// Le fond est une couleur SATUREE que l'enregistrement d'ecran de la fixture ne
/// produit nulle part : c'est ce qui permet de separer l'ecran du fond au pixel
/// pres, donc de mesurer la forme reellement dessinee.
fn tilt_scene_json(rotation: &str, shadow: u32, roundness: f32) -> String {
    format!(
        r##"{{"clips":[],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0.2,"blur":false,"shadow":{shadow},"roundnessFrac":{roundness},"motionBlur":0}},"background":{{"kind":"color","color":"#ff00ff"}},"zoomRegions":[{{"clipIndex":0,"startSec":0,"endSec":6,"scale":1.0,"focusX":0.5,"focusY":0.5,"rotation":{rotation}}}],"annotations":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
    )
}

/// `true` si le pixel n'est PAS le fond magenta. Seuil large : le feather des
/// bords et le degrade du sampler ne doivent pas compter comme du fond.
fn not_bg(px: &[u8]) -> bool {
    !(px[0] > 200 && px[1] < 60 && px[2] > 200)
}

/// Pour chaque colonne, la premiere ligne non-fond. `None` = colonne entierement
/// de fond. C'est la trace du BORD HAUT de ce qui est dessine : horizontale pour
/// un ecran droit, oblique pour un ecran incline.
fn top_edge(rgba: &[u8], w: u32, h: u32) -> Vec<Option<u32>> {
    (0..w)
        .map(|x| {
            (0..h).find(|&y| {
                let i = ((y * w + x) * 4) as usize;
                not_bg(&rgba[i..i + 4])
            })
        })
        .collect()
}

/// Ecart max du bord haut, mesure sur les colonnes centrales uniquement : aux
/// deux extremites le bord haut d'un quad incline bascule sur le bord LATERAL,
/// ce qui ajouterait une variation qui n'est pas celle qu'on veut mesurer.
fn top_edge_swing(edge: &[Option<u32>]) -> u32 {
    let n = edge.len();
    let seen: Vec<u32> = edge[n / 4..3 * n / 4].iter().flatten().copied().collect();
    match (seen.iter().min(), seen.iter().max()) {
        (Some(&lo), Some(&hi)) => hi - lo,
        _ => 0,
    }
}

/// Ecran incline (mode 8). Rend DEUX fois la meme scene, seule la rotation
/// change, et compare la silhouette obtenue.
///
/// L'assertion porte sur la GEOMETRIE, pas sur la presence d'un fichier : le
/// bord haut de l'ecran droit est horizontal a moins de 2 px pres, celui de
/// l'ecran incline balaie des dizaines de lignes. Un mode 8 non branche cote
/// Rust, un warp inverse faux, ou un `quad_st_for_root` qui rejetterait tout
/// casse l'une des trois bornes.
#[test]
fn compose_linux_ecran_tilte() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux tilt: opt-in (OPENSCREEN_LINUX_COMPOSE=1 + fixture). Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut dec = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    let mut cfg = Cfg::c8();
    cfg.shadow = false;
    let (w, h, upright, tilted) = unsafe {
        let sf = dec.seek_to(1.0).expect("Decoder::seek_to");
        // `frame` = 90 -> source_t = 90 / 60 = 1,5 s (`FPS` vaut 60 en dur dans
        // `frame_geometry`, ce n'est pas le `fps` de la scene), dans la region [0, 6] et
        // au-dela de la rampe d'entree : la rotation est a pleine force.
        let render = |json: String| {
            let scene = Scene::from_json(&json).expect("scene json");
            // Le padding transite par les live_params, pas la scene brute.
            comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&scene));
            comp.set_scene(Some(scene));
            comp.compose_frame(sf, sf, 90.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback_direct")
        };
        let (w, h, upright) = render(tilt_scene_json("null", 0, 0.0));
        let tilted: Vec<(&str, Vec<u8>)> = ["iso", "left", "right"]
            .iter()
            .map(|p| (*p, render(tilt_scene_json(&format!("\"{p}\""), 0, 0.0)).2))
            .collect();
        (w, h, upright, tilted)
    };

    write_ppm("compose_linux_tilt_upright", w, h, &upright);

    let up_swing = top_edge_swing(&top_edge(&upright, w, h));
    let up_area = upright.chunks_exact(4).filter(|p| not_bg(p)).count();
    println!("compose_linux tilt : {w}x{h} droit bord_haut={up_swing}px aire={up_area}");

    // Garde-fou du detecteur lui-meme : si le fond magenta ne separait pas
    // proprement l'ecran, le bord de la reference droite ne serait pas plat et
    // toute la mesure serait du bruit.
    assert!(
        up_swing <= 2,
        "reference droite : bord haut non horizontal ({up_swing} px) — le detecteur de fond derape"
    );

    // Les TROIS presets. Ils ne donnent pas le meme quadrilatere : iso penche le
    // plus, left/right sont dominés par leur rotateY, donc leur quad approche le
    // cas quasi affine que `quad_inverse_bilinear` traite par une branche a part.
    for (preset, tilted) in &tilted {
        write_ppm(&format!("compose_linux_tilt_{preset}"), w, h, tilted);
        let swing = top_edge_swing(&top_edge(tilted, w, h));
        let area = tilted.chunks_exact(4).filter(|p| not_bg(p)).count();
        println!("compose_linux tilt {preset} : bord_haut={swing}px aire={area}");

        // Chaque preset combine un rotateX et un rotateZ non nuls : sur une largeur
        // d'ecran de ~600 px le bord haut ne peut pas rester horizontal.
        assert!(
            swing >= 15,
            "{preset} : bord haut plat a {swing} px — mode 8 pas dessine (rect droit ?)"
        );
        // Le containment reduit le plan pour qu'il tienne dans le rect d'origine :
        // l'aire couverte baisse. La borne basse attrape le cas « mode 8 ne rend
        // rien » (quad_inverse_bilinear qui rejette tout, alpha a zero...).
        assert!(
            area > up_area * 4 / 10 && area < up_area * 95 / 100,
            "{preset} : aire {area} hors de (0.40, 0.95) x {up_area} — mode 8 vide ou inopérant"
        );
    }
}

/// Ombre du quad projete (mode 12). L'ombre doit suivre le QUADRILATERE : si
/// elle retombait sur le mode 2 (rect arrondi axis-aligned), sa bordure exterieure
/// serait horizontale en haut. On isole l'ombre en soustrayant le meme rendu sans
/// ombre, puis on mesure la pente de la bordure de la zone assombrie.
#[test]
fn compose_linux_ombre_du_quad_tilte() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux ombre tiltee: opt-in. Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut dec = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    let (w, h, sans, avec) = unsafe {
        let sf = dec.seek_to(1.0).expect("Decoder::seek_to");
        let render = |json: String, shadow: bool| {
            let scene = Scene::from_json(&json).expect("scene json");
            comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&scene));
            comp.set_scene(Some(scene));
            let mut cfg = Cfg::c8();
            cfg.shadow = shadow;
            comp.compose_frame(sf, sf, 90.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback_direct")
        };
        // Rayon non nul : c'est la seule facon d'exercer `inset_corner`/`line_cross`
        // (le rentrant des coins de l'ombre) et l'arrondi en repere PLAN du mode 8.
        let (w, h, sans) = render(tilt_scene_json("\"iso\"", 0, 0.04), false);
        let (_, _, avec) = render(tilt_scene_json("\"iso\"", 1, 0.04), true);
        (w, h, sans, avec)
    };

    write_ppm("compose_linux_tilt_shadow", w, h, &avec);

    // Masque de l'ombre : pixels du FOND assombris par le calque 12. On ignore
    // l'ecran lui-meme (l'ombre passe dessous, il n'y change rien).
    let mut mask = vec![false; (w * h) as usize];
    let mut count = 0usize;
    for p in 0..(w * h) as usize {
        let i = p * 4;
        let dark = sans[i] as i32 - avec[i] as i32 > 12 && !not_bg(&sans[i..i + 4]);
        mask[p] = dark;
        count += dark as usize;
    }
    // Bordure HAUTE de la penombre, colonne par colonne.
    let edge: Vec<Option<u32>> = (0..w)
        .map(|x| (0..h).find(|&y| mask[(y * w + x) as usize]))
        .collect();
    let swing = top_edge_swing(&edge);
    println!("compose_linux ombre tiltee : {count} px assombris, bordure haute swing={swing}px");

    assert!(count > 3000, "ombre absente ({count} px assombris) — mode 12 pas dessine ?");
    // Un repli sur le mode 2 donnerait une bordure haute rigoureusement plate.
    assert!(
        swing >= 15,
        "bordure haute de l'ombre plate a {swing} px — l'ombre est un rect droit, pas le quad projete"
    );
}

/// Curseur pose sur l'ecran incline (mode 13). Le curseur est place HORS du
/// centre : c'est la que le plan incline le deplace vraiment. Au centre, la
/// position tiltee et la position droite coincident et le test ne prouverait rien.
///
/// L'assertion est que le sprite BOUGE quand on incline. Un repli sur le
/// placement droit (mode 7) laisserait les deux barycentres au meme endroit ; un
/// mode 13 absent ferait disparaitre le curseur (compte a zero).
#[test]
fn compose_linux_curseur_sur_ecran_tilte() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux curseur tilte: opt-in. Skip.");
        return;
    }
    // Sprite vert 16x16 opaque (le meme que le test du mode 7).
    const SPRITE: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAAGElEQVR4nGNk+MdAEmAhTfmohlENQ0kDAGoRATwbkCdPAAAAAElFTkSuQmCC";

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut dec = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    let track_path = std::env::temp_dir().join("os_cursor_track_tilt.json");
    std::fs::write(
        &track_path,
        r#"{"samples":[{"timeMs":3000,"cx":0.22,"cy":0.24,"cursorType":"arrow"}]}"#,
    )
    .expect("write track");
    let track = CursorTrack::load(track_path.to_str().unwrap(), 0.0, 6.0).expect("CursorTrack::load");
    comp.set_cursor(track);
    comp.set_cursor_time(Some(3.0));

    let scene_json = |rotation: &str| {
        format!(
            r##"{{"clips":[],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0.2,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},"background":{{"kind":"color","color":"#ff00ff"}},"zoomRegions":[{{"clipIndex":0,"startSec":0,"endSec":6,"scale":1.0,"focusX":0.5,"focusY":0.5,"rotation":{rotation}}}],"annotations":[],"cursor":{{"show":true,"size":4,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default","cursorSprites":{{"arrow":{{"path":"{SPRITE}","hotspotX":0.5,"hotspotY":0.5}}}}}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
        )
    };

    let (w, h, upright, tilted) = unsafe {
        let sf = dec.seek_to(1.0).expect("Decoder::seek_to");
        let render = |json: String| {
            let scene = Scene::from_json(&json).expect("scene json");
            comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&scene));
            comp.set_scene(Some(scene));
            comp.compose_frame(sf, sf, 90.0, &Cfg::c8()).expect("compose_frame");
            comp.readback_direct().expect("readback_direct")
        };
        let (w, h, upright) = render(scene_json("null"));
        let (_, _, tilted) = render(scene_json("\"iso\""));
        (w, h, upright, tilted)
    };

    write_ppm("compose_linux_tilt_cursor", w, h, &tilted);

    // Barycentre des pixels verts du sprite.
    let centroid = |rgba: &[u8]| -> (f32, f32, usize) {
        let (mut sx, mut sy, mut n) = (0.0f32, 0.0f32, 0usize);
        for y in 0..h {
            for x in 0..w {
                let i = ((y * w + x) * 4) as usize;
                if rgba[i + 1] > 180 && rgba[i] < 120 && rgba[i + 2] < 120 {
                    sx += x as f32;
                    sy += y as f32;
                    n += 1;
                }
            }
        }
        (sx / n.max(1) as f32, sy / n.max(1) as f32, n)
    };
    let (ux, uy, un) = centroid(&upright);
    let (tx, ty, tn) = centroid(&tilted);
    let shift = ((tx - ux).powi(2) + (ty - uy).powi(2)).sqrt();
    println!(
        "compose_linux curseur tilte : droit=({ux:.1},{uy:.1}) n={un} \
         incline=({tx:.1},{ty:.1}) n={tn} deplacement={shift:.1}px"
    );

    assert!(un > 50, "curseur droit absent (n={un}) — la scene de reference est cassee");
    assert!(tn > 50, "curseur absent sous rotation (n={tn}) — mode 13 pas dessine");
    assert!(
        shift >= 12.0,
        "curseur deplace de {shift:.1}px seulement — il est reste sur le rect droit (mode 7 ?)"
    );
}

/// Curseur : sprite thematise (mode 7) dessine au centre. Sprite VERT (data URI
/// PNG) distinct du fond sombre et de l'ecran, pour l'affirmer sans ambiguite.
#[test]
fn compose_linux_dessine_le_curseur() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux curseur: opt-in (OPENSCREEN_LINUX_COMPOSE=1 + fixture). Skip.");
        return;
    }

    // Sprite vert 16x16 opaque en data URI (decode_data_uri -> crate image).
    const SPRITE: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAAGElEQVR4nGNk+MdAEmAhTfmohlENQ0kDAGoRATwbkCdPAAAAAElFTkSuQmCC";

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut dec = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    // Scene : curseur visible (size 3 pour un sprite bien lisible), sprite "arrow".
    let scene_json = format!(
        r##"{{"clips":[],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0.03,"motionBlur":0}},"background":{{"kind":"color","color":"#101015"}},"zoomRegions":[],"annotations":[],"cursor":{{"show":true,"size":3,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default","cursorSprites":{{"arrow":{{"path":"{SPRITE}","hotspotX":0.5,"hotspotY":0.5}}}}}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
    );
    comp.set_scene(Some(Scene::from_json(&scene_json).expect("scene json")));

    // Piste curseur : un echantillon au centre (0.5, 0.5). `load` lit un fichier.
    let track_path = std::env::temp_dir().join("os_cursor_track.json");
    std::fs::write(
        &track_path,
        r#"{"samples":[{"timeMs":0,"cx":0.5,"cy":0.5,"cursorType":"arrow"}]}"#,
    )
    .expect("write track");
    let track = CursorTrack::load(track_path.to_str().unwrap(), 0.0, 2.0).expect("CursorTrack::load");
    comp.set_cursor(track);
    comp.set_cursor_time(Some(0.0));

    let (w, h, rgba) = unsafe {
        let sf = dec.seek_to(1.0).expect("Decoder::seek_to");
        let cfg = Cfg::c8();
        comp.compose_frame(sf, sf, 0.0, &cfg).expect("compose_frame");
        comp.readback_direct().expect("readback_direct")
    };

    // Le sprite vert doit apparaitre franchement (G haut, R/B bas).
    let green = rgba
        .chunks_exact(4)
        .filter(|p| p[1] > 180 && p[0] < 120 && p[2] < 120)
        .count();
    println!("compose_linux curseur : {w}x{h} pixels verts={green}");

    let out = std::env::var("OPENSCREEN_VK_OUT").unwrap_or_else(|_| "target".into());
    let _ = std::fs::create_dir_all(&out);
    let ppm = format!("{out}/compose_linux_cursor.ppm");
    {
        use std::io::Write;
        let mut f = std::fs::File::create(&ppm).expect("create ppm");
        write!(f, "P6\n{w} {h}\n255\n").unwrap();
        let mut rgb = vec![0u8; (w * h * 3) as usize];
        for (d, s) in rgb.chunks_exact_mut(3).zip(rgba.chunks_exact(4)) {
            d.copy_from_slice(&s[0..3]);
        }
        f.write_all(&rgb).unwrap();
    }
    println!("wrote {ppm}");

    assert!(green > 50, "sprite curseur vert absent (verts={green}) — mode 7 ?");
}

/// Fond image (mode 6 wallpaper) : un PNG orange en data URI remplit le fond
/// (cover-fit) autour de l'ecran inset (padding). Distinct de l'ecran et du
/// gris par defaut, pour l'affirmer sans ambiguite.
#[test]
fn compose_linux_fond_image() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux fond image: opt-in. Skip.");
        return;
    }
    const BG: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAACXBIWXMAAAABAAAAAQBPJcTWAAAAKklEQVR4nO3NwQ0AAAQAMRJ721wswa83wDWn47X63QMAAAAAAAAAAIC7FhLfAfuIQEbyAAAAAElFTkSuQmCC";

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut dec = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    let scene_json = format!(
        r##"{{"clips":[],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0.4,"blur":false,"shadow":0,"roundnessFrac":0.05,"motionBlur":0}},"background":{{"kind":"image","path":"{BG}"}},"zoomRegions":[],"annotations":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
    );
    let scene = Scene::from_json(&scene_json).expect("scene json");
    // Le padding (et les autres effets) transitent par les live_params, pas la
    // scene brute -> sans ca l'ecran remplit tout le cadre et masque le fond.
    comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&scene));
    comp.set_scene(Some(scene));

    let (w, h, rgba) = unsafe {
        let sf = dec.seek_to(1.0).expect("Decoder::seek_to");
        let cfg = Cfg::c8();
        comp.compose_frame(sf, sf, 0.0, &cfg).expect("compose_frame");
        comp.readback_direct().expect("readback_direct")
    };
    // Orange (255,128,0) : R haut, G moyen, B bas.
    let orange = rgba
        .chunks_exact(4)
        .filter(|p| p[0] > 200 && p[1] > 90 && p[1] < 170 && p[2] < 70)
        .count();
    println!("compose_linux fond image : {w}x{h} pixels orange={orange}");

    let out = std::env::var("OPENSCREEN_VK_OUT").unwrap_or_else(|_| "target".into());
    let _ = std::fs::create_dir_all(&out);
    {
        use std::io::Write;
        let mut f = std::fs::File::create(format!("{out}/compose_linux_bgimage.ppm")).expect("ppm");
        write!(f, "P6\n{w} {h}\n255\n").unwrap();
        let mut rgb = vec![0u8; (w * h * 3) as usize];
        for (d, s) in rgb.chunks_exact_mut(3).zip(rgba.chunks_exact(4)) {
            d.copy_from_slice(&s[0..3]);
        }
        f.write_all(&rgb).unwrap();
    }
    assert!(orange > 2000, "fond image absent (orange={orange}) — mode 6 ?");
}

/// Flou de mouvement par VELOCITE du calque ecran (mode 0 du shader).
///
/// La velocite vient d'un zoom en pleine rampe : `plan_frame` calcule alors un
/// `s_dst_prev` different de `s_dst`, et le shader floute chaque pixel le long
/// du segment qui relie son UV d'avant a son UV d'aujourd'hui.
///
/// La MEME frame decodee est composee deux fois, seul `effects.motionBlur`
/// change — toute difference mesuree ne peut donc venir que de l'effet. Deux
/// assertions, parce que « les deux images different » ne dirait pas dans quel
/// SENS : on verifie aussi que la version floutee a moins de detail haute
/// frequence. Un cablage errone de `src_prev`/`dst_prev` ferait bien differer
/// les images, mais pas forcement dans ce sens-la.
#[test]
fn compose_linux_flou_de_velocite_ecran() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux flou de velocite: opt-in. Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut dec = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    // La region de zoom demarre a 2 s ; sa rampe d'entree commence ~1 s plus tot
    // (`ZOOM_IN_TRANSITION_WINDOW_S`). A t = 66/60 = 1,1 s on est donc en pleine
    // montee : `plan_frame` y donne s_dst 1,629 contre s_dst_prev 1,559, soit
    // 4,5 % d'echelle en une frame — largement de quoi etaler le calque.
    let scene_of = |mblur: f32| {
        format!(
            r##"{{"clips":[],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":{mblur}}},"background":{{"kind":"color","color":"#101015"}},"zoomRegions":[{{"id":"z1","startSec":2,"endSec":4,"scale":2.5,"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":null}}],"annotations":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
        )
    };

    // UN SEUL `seek_to` : les deux rendus partagent la meme AVFrame, donc le
    // decodeur ne peut pas introduire de difference qu'on prendrait pour l'effet.
    let (sharp, blurred) = unsafe {
        let sf = dec.seek_to(1.1).expect("Decoder::seek_to");
        let cfg = Cfg::c8();
        let render = |mblur: f32| {
            comp.set_scene(Some(Scene::from_json(&scene_of(mblur)).expect("scene json")));
            comp.compose_frame(sf, sf, 66.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback_direct").2
        };
        (render(0.0), render(1.0))
    };

    write_ppm("compose_linux_mb_screen_off", W, H, &sharp);
    write_ppm("compose_linux_mb_screen_on", W, H, &blurred);

    let mut diff_sum = 0u64;
    for (a, b) in sharp.chunks_exact(4).zip(blurred.chunks_exact(4)) {
        for c in 0..3 {
            diff_sum += (a[c] as i32 - b[c] as i32).unsigned_abs() as u64;
        }
    }
    let mean_diff = diff_sum as f32 / (W * H * 3) as f32;

    // Detail haute frequence : somme des gradients voisins sur le canal vert.
    let sharpness = |img: &[u8]| -> f32 {
        let g = |x: u32, y: u32| img[((y * W + x) * 4 + 1) as usize] as i32;
        let mut acc = 0u64;
        for y in 0..H - 1 {
            for x in 0..W - 1 {
                acc += (g(x + 1, y) - g(x, y)).unsigned_abs() as u64;
                acc += (g(x, y + 1) - g(x, y)).unsigned_abs() as u64;
            }
        }
        acc as f32 / ((W - 1) * (H - 1) * 2) as f32
    };
    let (s_sharp, s_blur) = (sharpness(&sharp), sharpness(&blurred));
    println!(
        "compose_linux flou de velocite : mean_diff={mean_diff:.2} gradient net={s_sharp:.2} floute={s_blur:.2}"
    );

    // Mesure observee : mean_diff 12,5 et gradient 7,9 -> 3,0. Les seuils gardent
    // de la marge tout en restant loin du « ca a bouge d'un poil ».
    assert!(
        mean_diff > 4.0,
        "motionBlur 0 vs 1 rend (quasi) la MEME image (mean_diff={mean_diff:.3}) — mb/src_prev/dst_prev non cables ?"
    );
    assert!(
        s_blur < s_sharp * 0.7,
        "le rendu floute n'est pas plus doux (gradient {s_blur:.2} vs {s_sharp:.2}) — le flou ne suit pas la velocite"
    );
}

/// Meme flou de velocite, mais sur le calque CAMERA — un draw distinct, avec son
/// propre `src_prev` (qui doit suivre le cover-crop et le miroir) et son propre
/// `dst_prev`.
///
/// La velocite vient d'une region « Full Camera » en pleine ouverture : la boite
/// camera passe de 0,526 a 0,579 de large en une frame pendant que `s_dst` ne
/// bouge PAS d'un pouce. C'est ce qui rend le test concluant — une difference
/// mesuree dans la boite camera ne peut pas venir du calque ecran, et
/// l'assertion sur le coin haut-gauche (hors boite) le verifie explicitement.
#[test]
fn compose_linux_flou_de_velocite_camera() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux flou de velocite camera: opt-in. Skip.");
        return;
    }
    let webcam_fixture = "../fixture/webcam.mp4";
    if !Path::new(webcam_fixture).is_file() {
        eprintln!("compose_linux flou de velocite camera: pas de fixture webcam. Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open screen");
    let mut cam = Decoder::open(webcam_fixture, &gpu).expect("Decoder::open webcam");

    // `webcamMirror: true` : le miroir inverse les bornes u de `src`, et
    // `src_prev` doit inverser les MEMES. S'il gardait l'ancien [0,0,1,1] la
    // reprojection viserait une zone de texture jamais affichee.
    let scene_of = |mblur: f32| {
        format!(
            r##"{{"clips":[],"layout":{{"preset":"picture-in-picture","webcamSize":1,"webcamShape":"rectangle","webcamMirror":true,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":{mblur}}},"background":{{"kind":"color","color":"#101015"}},"zoomRegions":[],"cameraFullscreenRegions":[{{"startSec":2,"endSec":4}}],"annotations":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
        )
    };

    let (sharp, blurred) = unsafe {
        let sf = screen.seek_to(2.1).expect("seek screen");
        let wf = cam.seek_to(2.1).expect("seek webcam");
        let cfg = Cfg::c8();
        let render = |mblur: f32| {
            let scene = Scene::from_json(&scene_of(mblur)).expect("scene json");
            comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&scene));
            comp.set_scene(Some(scene));
            // frame 126 = t 2,1 s : la camera est a mi-ouverture.
            comp.compose_frame(sf, wf, 126.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback_direct").2
        };
        (render(0.0), render(1.0))
    };

    write_ppm("compose_linux_mb_camera_off", W, H, &sharp);
    write_ppm("compose_linux_mb_camera_on", W, H, &blurred);

    let mean_diff = |x0: u32, x1: u32, y0: u32, y1: u32| -> f32 {
        let mut sum = 0u64;
        for y in y0..y1 {
            for x in x0..x1 {
                let i = ((y * W + x) * 4) as usize;
                for c in 0..3 {
                    sum += (sharp[i + c] as i32 - blurred[i + c] as i32).unsigned_abs() as u64;
                }
            }
        }
        sum as f32 / ((x1 - x0) * (y1 - y0) * 3) as f32
    };
    // Boite camera a t = 2,1 s : [0,411 ; 0,403 ; 0,579 ; 0,579] de la sortie,
    // soit x 394..950 et y 217..530 en pixels — retrecie ici pour rester loin des
    // bords adoucis. Le coin haut-gauche, lui, ne montre que l'ecran.
    let inside = mean_diff(420, 920, 245, 505);
    let outside = mean_diff(0, 300, 0, 150);
    println!("compose_linux flou de velocite camera : dans la boite={inside:.2} hors boite={outside:.4}");

    assert!(
        inside > 4.0,
        "la camera n'est pas floutee (diff={inside:.3}) — src_prev/dst_prev du calque webcam non cables ?"
    );
    assert!(
        outside < 0.01,
        "l'ecran a bouge aussi (diff={outside:.3}) — le test ne prouve alors rien sur la camera"
    );
}

/// Trainee fantome du curseur (accumulation temporelle, pas un mode de shader).
///
/// Le curseur traverse le cadre ; a `cursor.motionBlur = 1` `plan_cursor` rend
/// 2 a 16 prises, ponderees vers la tete, entre sa position d'il y a UNE frame
/// (1/60 s, l'obturateur borne depuis 34b2e5847) et sa position courante.
/// On compare au meme rendu sans trainee : la seule difference possible etant le
/// curseur, un exces de vert la ou le curseur N'EST PAS (mais est PASSE) est la
/// signature de la trainee.
///
/// « Exces de vert » = G - max(R,B), pas G brut : une copie a 1/taps d'opacite
/// sur un fond CLAIR fait a peine monter le vert (le fond y est deja) mais fait
/// nettement chuter le rouge et le bleu. Mesurer G seul rendrait le test
/// dependant de ce qui passe sous le curseur dans la video.
///
/// Le trajet est volontairement hors de l'axe median (cy = 0,28) : une passe de
/// composition qui retournerait `accum` verticalement enverrait la trainee dans
/// la bande miroir, ce que la seconde assertion interdit. A cy = 0,5 le defaut
/// serait invisible.
#[test]
fn compose_linux_trainee_de_curseur() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux trainee curseur: opt-in. Skip.");
        return;
    }
    const SPRITE: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAAGElEQVR4nGNk+MdAEmAhTfmohlENQ0kDAGoRATwbkCdPAAAAAElFTkSuQmCC";

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut dec = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    // Piste : deplacement horizontal regulier cx 0,1 -> 0,9 en 0,1 s, a cy fixe.
    // L'obturateur de la trainee est borne a UNE frame (`trail_dt = blur01 / FPS`
    // dans `plan_cursor`, 1/60 s a flou 100 %), donc le curseur doit aller vite
    // pour que la trainee separe nettement ses deux extremites : 8 cx/s donne
    // ~128 px a 960 de large. Plus lent, la trainee se superpose au curseur
    // lui-meme (51 px de cote) et on ne peut plus les distinguer.
    let mut samples = String::new();
    for k in 0..=8 {
        let (ms, cx) = (k as f32 * 12.5, 0.1 + 0.1 * k as f32);
        if k > 0 {
            samples.push(',');
        }
        samples.push_str(&format!(
            r#"{{"timeMs":{ms},"cx":{cx},"cy":0.28,"cursorType":"arrow"}}"#
        ));
    }
    let track_path = std::env::temp_dir().join("os_cursor_trail_track.json");
    std::fs::write(&track_path, format!(r#"{{"samples":[{samples}]}}"#)).expect("write track");
    let track = CursorTrack::load(track_path.to_str().unwrap(), 0.0, 2.0).expect("CursorTrack::load");
    comp.set_cursor(track);
    comp.set_cursor_time(Some(0.0875));

    let scene_of = |mblur: f32| {
        format!(
            r##"{{"clips":[],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},"background":{{"kind":"color","color":"#101015"}},"zoomRegions":[],"annotations":[],"cursor":{{"show":true,"size":3,"smoothing":0,"motionBlur":{mblur},"clickBounce":0,"clipToBounds":false,"theme":"default","cursorSprites":{{"arrow":{{"path":"{SPRITE}","hotspotX":0.5,"hotspotY":0.5}}}}}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
        )
    };

    let (sharp, trail) = unsafe {
        let sf = dec.seek_to(1.0).expect("Decoder::seek_to");
        let cfg = Cfg::c8();
        let render = |mblur: f32| {
            let scene = Scene::from_json(&scene_of(mblur)).expect("scene json");
            // `cursor.motionBlur` ET `cursor.size` transitent par les LiveParams,
            // pas par la scene brute : sans ca `plan_cursor` verrait toujours 0.
            comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&scene));
            comp.set_scene(Some(scene));
            comp.compose_frame(sf, sf, 15.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback_direct").2
        };
        (render(0.0), render(1.0))
    };

    write_ppm("compose_linux_cursor_trail_off", W, H, &sharp);
    write_ppm("compose_linux_cursor_trail_on", W, H, &trail);

    // A t = 0,0875 s le curseur est en cx 0,8 (x ~ 768 px) et une frame (1/60 s)
    // plus tot en cx ~ 0,667 (x ~ 640 px) ; le sprite fait 51 px de cote a
    // size 3 (34/1080 de frame_min_px, x3), donc le curseur COURANT occupe
    // x = 742..794 et la copie la plus ancienne x = 614..666. La fenetre
    // ci-dessous tient entre les deux (x = 670..738, y = 130..172 autour de
    // cy = 0,28 soit y ~ 151) : sans trainee il n'y a rien du tout. La bande
    // miroir est son reflet par rapport a l'axe horizontal de l'image (cy = 0,28
    // est hors de cet axe expres), donc un `accum` composite a l'envers y
    // atterrirait.
    let greener = |x0: u32, x1: u32, y0: u32, y1: u32| -> usize {
        let excess = |img: &[u8], i: usize| {
            img[i + 1] as i32 - (img[i] as i32).max(img[i + 2] as i32)
        };
        let mut n = 0;
        for y in y0..y1 {
            for x in x0..x1 {
                let i = ((y * W + x) * 4) as usize;
                if excess(&trail, i) - excess(&sharp, i) > 10 {
                    n += 1;
                }
            }
        }
        n
    };
    let on_path = greener(670, 738, 130, 172);
    let mirrored = greener(670, 738, 368, 410);
    println!("compose_linux trainee curseur : sur le trajet={on_path} bande miroir={mirrored}");

    // La fenetre fait 68x42 = 2856 px et la trainee la remplit entierement : les
    // copies sont espacees de ~8,5 px (16 prises sur 128 px) pour un sprite de
    // 51 px, et chaque pixel en recoit au moins cinq. Le seuil a 1700 laisse de
    // la marge tout en refusant une trainee qui ne couvrirait qu'un bout du
    // trajet.
    assert!(
        on_path > 1700,
        "pas de trainee au milieu du trajet ({on_path} px plus verts) — le curseur n'est dessine qu'a sa position courante"
    );
    assert!(
        mirrored < 50,
        "trainee dans la bande MIROIR ({mirrored} px) — la passe de composition d'accum retourne l'image en Y"
    );
}

/// Export (WP6) : ~1s de la fixture -> MP4 H264 software. Verifie que la marche
/// de timeline + l'encodeur + le muxer produisent un fichier non trivial. Le
/// contenu est re-validable par ffprobe (cf. la commande dans le run manuel).
#[test]
fn export_linux_mp4() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("export_linux: opt-in (OPENSCREEN_LINUX_COMPOSE=1 + fixture). Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    // Petite sortie : l'export est un smoke test, pas un bench.
    let comp = Compositor::new_sized(&gpu, 640, 360).expect("Compositor::new_sized");

    let out = std::env::var("OPENSCREEN_EXPORT_OUT")
        .unwrap_or_else(|_| std::env::temp_dir().join("os_export_linux.mp4").to_string_lossy().into());
    let clips = vec![ClipSource {
        screen: FIXTURE.to_string(),
        webcam: FIXTURE.to_string(),
        source_start_sec: 0.0,
        source_end_sec: 1.0,
        webcam_offset_sec: 0.0,
        has_audio: true,
    }];
    let params = ExportParams {
        width: 640,
        height: 360,
        fps: Some(30),
        codec: ExportCodec::H264,
        bit_rate: None,
    };

    let mut last = 0u64;
    let stats = run_composited_multi(
        &clips,
        &out,
        &gpu,
        &comp,
        &Cfg::c8(),
        &params,
        &mut |n| last = n,
    )
    .expect("run_composited_multi");
    println!(
        "export_linux : {} frames, {:.1} fps encode, {:.2}s video, progress={last} -> {out}",
        stats.frames, stats.fps, stats.video_duration_s
    );

    assert!(stats.frames > 0, "aucune frame exportee");
    let meta = std::fs::metadata(&out).expect("mp4 metadata");
    assert!(meta.len() > 2000, "mp4 trop petit ({} octets) — muxer ?", meta.len());
}

/// Rend une frame qui exerce EN MEME TEMPS les trois corrections de cette
/// serie : ombre portee (ecran + camera), cover-crop de la webcam sous un
/// masque CERCLE (le cas ou l'etirement etait le plus violent : la boite est
/// forcee carree, donc une camera 16:9 s'ecrasait de 1,78x), et une annotation
/// texte avec un fond.
///
/// Opt-in comme les autres tests de ce fichier ; ecrit un PPM a inspecter.
#[test]
fn compose_linux_ombre_webcam_ronde_et_texte() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux ombre/webcam/texte: opt-in. Skip.");
        return;
    }
    let webcam_fixture = "../fixture/webcam.mp4";
    if !Path::new(webcam_fixture).is_file() {
        eprintln!("compose_linux ombre/webcam/texte: pas de fixture webcam. Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open screen");
    let mut cam = Decoder::open(webcam_fixture, &gpu).expect("Decoder::open webcam");

    // `shadow: 1` + camera en cercle + une annotation texte visible a t=1s.
    let scene_json = r##"{"clips":[],"layout":{"preset":"picture-in-picture","webcamSize":1,"webcamShape":"circle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false},"effects":{"padding":0.14,"blur":false,"shadow":1,"roundnessFrac":0.04,"motionBlur":0},"background":{"kind":"gradient","angleDeg":45,"stops":["#1f2933","#3b6bff"]},"zoomRegions":[],"annotations":[{"id":"a1","kind":"text","x":0.08,"y":0.08,"w":0.5,"h":0.14,"startSec":0,"endSec":10,"zIndex":1,"text":{"content":"Ombre + fond","color":"#ffffff","backgroundColor":"#e0245e","fontSizeRel":0.09,"fontFamily":"","fontWeight":"normal","fontStyle":"normal","textDecoration":"none","textAlign":"center"}}],"cursor":{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"},"cropByClip":[],"output":{"width":1920,"height":1080,"fps":30}}"##;
    let parsed = Scene::from_json(scene_json).expect("scene json");
    // Cf. le commentaire dans compose_linux_forme_webcam_cercle : sans les
    // LiveParams, la scene est parsee et ignoree.
    comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&parsed));
    comp.set_scene(Some(parsed));

    let (w, h, rgba) = unsafe {
        let sf = screen.seek_to(1.0).expect("seek screen");
        let wf = cam.seek_to(1.0).expect("seek webcam");
        let mut cfg = Cfg::c8();
        cfg.shadow = true;
        comp.compose_frame(sf, wf, 1.0, &cfg).expect("compose_frame");
        comp.readback_direct().expect("readback_direct")
    };

    let out = std::env::var("OPENSCREEN_VK_OUT").unwrap_or_else(|_| "target".into());
    let _ = std::fs::create_dir_all(&out);
    let ppm = format!("{out}/compose_linux_shadow_webcam_text.ppm");
    {
        use std::io::Write;
        let mut f = std::fs::File::create(&ppm).expect("create ppm");
        write!(f, "P6\n{w} {h}\n255\n").unwrap();
        let mut rgb = vec![0u8; (w * h * 3) as usize];
        for (d, s) in rgb.chunks_exact_mut(3).zip(rgba.chunks_exact(4)) {
            d.copy_from_slice(&s[0..3]);
        }
        f.write_all(&rgb).unwrap();
    }
    println!("wrote {ppm}");

    // L'annotation a un fond ROSE (#e0245e) : il doit exister des pixels
    // nettement rouges-magenta dans le quart haut-gauche, ce qui n'etait pas le
    // cas quand la plaque n'etait pas dessinee du tout.
    let mut plate_px = 0usize;
    for y in 0..(h / 3) {
        for x in 0..(w / 2) {
            let i = ((y * w + x) * 4) as usize;
            let (r, g_, b) = (rgba[i] as i32, rgba[i + 1] as i32, rgba[i + 2] as i32);
            if r > 140 && g_ < 90 && b > 40 && b < 140 {
                plate_px += 1;
            }
        }
    }
    assert!(
        plate_px > 200,
        "fond d'annotation introuvable ({plate_px} px roses) — la plaque n'est pas dessinee"
    );
}

/// Forme de la webcam : `rectangle` contre `circle`.
///
/// Le masque n'est pas un mode de shader dedie — il sort de `radius_px`, que
/// `plan_frame` met a la moitie du cote pour `circle`. Ce test le MESURE au
/// lieu de le supposer.
///
/// La methode : rendre trois fois la meme scene — sans camera, camera
/// rectangle, camera cercle — et diffe chacune des deux dernieres contre la
/// premiere. Le diff EST l'empreinte de la camera, masque compris, sans avoir
/// a deviner ou `plan_frame` l'a posee ni a distinguer la camera du fond. Un
/// disque remplit pi/4 ~= 0,785 de sa boite englobante, un rectangle la
/// remplit entierement : le taux de remplissage separe les deux sans ambiguite.
#[test]
fn compose_linux_forme_webcam_cercle() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux forme webcam: opt-in. Skip.");
        return;
    }
    let webcam_fixture = "../fixture/webcam.mp4";
    if !Path::new(webcam_fixture).is_file() {
        eprintln!("compose_linux forme webcam: pas de fixture webcam. Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open screen");
    let mut cam = Decoder::open(webcam_fixture, &gpu).expect("Decoder::open webcam");

    let scene = |preset: &str, shape: &str| {
        format!(
            r##"{{"clips":[],"layout":{{"preset":"{preset}","webcamSize":1.6,"webcamShape":"{shape}","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0.1,"blur":false,"shadow":0,"roundnessFrac":0.0,"motionBlur":0}},"background":{{"kind":"color","color":"#00ff00"}},"zoomRegions":[],"annotations":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
        )
    };

    let mut render = |preset: &str, shape: &str| -> Vec<u8> {
        let parsed = Scene::from_json(&scene(preset, shape)).expect("scene json");
        // OBLIGATOIRE. `compose_frame` lit les LiveParams, PAS la scene brute :
        // la forme webcam, le padding et les effets y transitent. Sans cette
        // ligne la scene est parsee mais ignoree, et le test mesure la forme par
        // defaut ("rounded") en croyant mesurer celle qu'il a demandee.
        comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&parsed));
        comp.set_scene(Some(parsed));
        unsafe {
            let sf = screen.seek_to(1.0).expect("seek screen");
            let wf = cam.seek_to(1.0).expect("seek webcam");
            let mut cfg = Cfg::c8();
            cfg.shadow = false;
            comp.compose_frame(sf, wf, 1.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback").2
        }
    };

    let none = render("no-webcam", "rectangle");
    let rect = render("picture-in-picture", "rectangle");
    let circle = render("picture-in-picture", "circle");
    write_ppm("compose_linux_webcam_rect", W, H, &rect);
    write_ppm("compose_linux_webcam_circle", W, H, &circle);

    // Empreinte = pixels qui changent quand la camera apparait.
    let footprint = |with: &[u8]| -> Vec<bool> {
        with.chunks_exact(4)
            .zip(none.chunks_exact(4))
            .map(|(a, b)| {
                (a[0] as i32 - b[0] as i32).abs()
                    + (a[1] as i32 - b[1] as i32).abs()
                    + (a[2] as i32 - b[2] as i32).abs()
                    > 24
            })
            .collect()
    };
    // Taux de remplissage de la boite englobante de l'empreinte.
    let fill = |mask: &[bool], label: &str| -> f32 {
        let (mut x0, mut y0, mut x1, mut y1) = (W, H, 0u32, 0u32);
        let mut n = 0u32;
        for y in 0..H {
            for x in 0..W {
                if mask[(y * W + x) as usize] {
                    x0 = x0.min(x); y0 = y0.min(y); x1 = x1.max(x); y1 = y1.max(y); n += 1;
                }
            }
        }
        assert!(x1 > x0 && y1 > y0, "{label} : aucune empreinte de camera");
        let (bw, bh) = (x1 - x0 + 1, y1 - y0 + 1);
        let ar = bw as f32 / bh as f32;
        let f = n as f32 / (bw * bh) as f32;
        println!("{label} : boite {bw}x{bh} (AR {ar:.3}), {n} px, remplissage {f:.3}");
        f
    };

    let rect_fill = fill(&footprint(&rect), "rectangle");
    let circle_fill = fill(&footprint(&circle), "cercle");

    assert!(rect_fill > 0.95, "le rectangle devrait remplir sa boite ({rect_fill:.3})");
    // pi/4 = 0,785 ; on tolere l'antialiasing du SDF sur le pourtour.
    assert!(
        (circle_fill - 0.785).abs() < 0.06,
        "le masque cercle ne rogne pas comme un disque (remplissage {circle_fill:.3}, attendu ~0.785)"
    );
}

/// Un enregistrement SANS camera ne doit rien dessiner dans la boite PiP.
///
/// Le cas est reproduit tel quel : le decodeur « webcam » recoit la frame de
/// l'ECRAN, ce que `open_and_seek_clip` fait en production des que le chemin
/// webcam est vide ou illisible. Seul `LiveParams::has_webcam` distingue alors
/// une vraie camera d'une seconde copie de l'ecran, et ce backend ne le lisait
/// pas : l'enregistrement d'ecran apparaissait dans sa propre vignette.
///
/// L'assertion est une egalite stricte avec le rendu « no-webcam » : pas un
/// seuil, parce qu'il ne s'agit pas de mesurer une empreinte plus petite mais
/// de verifier qu'il n'y en a aucune.
#[test]
fn compose_linux_sans_camera_ne_dessine_pas_de_vignette() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux sans camera: opt-in. Skip.");
        return;
    }

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open screen");

    let scene_json = r##"{"clips":[],"layout":{"preset":"picture-in-picture","webcamSize":1.6,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false},"effects":{"padding":0.1,"blur":false,"shadow":0,"roundnessFrac":0.0,"motionBlur":0},"background":{"kind":"color","color":"#00ff00"},"zoomRegions":[],"annotations":[],"cursor":{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"},"cropByClip":[],"output":{"width":1920,"height":1080,"fps":30}}"##;

    let mut render = |has_webcam: bool| -> Vec<u8> {
        let parsed = Scene::from_json(scene_json).expect("scene json");
        let mut lp = openscreen_compositor::compositor::live_params_from_scene(&parsed);
        lp.has_webcam = has_webcam;
        comp.set_live_params(lp);
        comp.set_scene(Some(parsed));
        unsafe {
            let sf = screen.seek_to(1.0).expect("seek screen");
            let mut cfg = Cfg::c8();
            cfg.shadow = false;
            // La frame ecran passee AUSSI comme webcam : le repli exact de
            // `open_and_seek_clip` quand il n'y a pas de fichier camera.
            comp.compose_frame(sf, sf, 1.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback").2
        }
    };

    let with_camera = render(true);
    let without_camera = render(false);
    write_ppm("compose_linux_sans_camera", W, H, &without_camera);

    let differing = with_camera
        .chunks_exact(4)
        .zip(without_camera.chunks_exact(4))
        .filter(|(a, b)| {
            (a[0] as i32 - b[0] as i32).abs()
                + (a[1] as i32 - b[1] as i32).abs()
                + (a[2] as i32 - b[2] as i32).abs()
                > 24
        })
        .count();
    println!("vignette ecran-dans-la-camera : {differing} px");
    assert!(
        differing > 1000,
        "le rendu de controle ne dessine aucune vignette — le test ne prouve rien ({differing} px)"
    );

    // Reference : le preset qui ne veut pas de camera du tout. Il pose le meme
    // rectangle d'ecran (`plan_frame` : « no-webcam » et « picture-in-picture »
    // partagent `full_screen`), donc seule la vignette peut les separer.
    let no_webcam_preset = {
        let parsed = Scene::from_json(&scene_json.replace(
            r#""preset":"picture-in-picture""#,
            r#""preset":"no-webcam""#,
        ))
        .expect("scene json");
        comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&parsed));
        comp.set_scene(Some(parsed));
        unsafe {
            let sf = screen.seek_to(1.0).expect("seek screen");
            let mut cfg = Cfg::c8();
            cfg.shadow = false;
            comp.compose_frame(sf, sf, 1.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback").2
        }
    };
    let residual = without_camera
        .chunks_exact(4)
        .zip(no_webcam_preset.chunks_exact(4))
        .filter(|(a, b)| {
            (a[0] as i32 - b[0] as i32).abs()
                + (a[1] as i32 - b[1] as i32).abs()
                + (a[2] as i32 - b[2] as i32).abs()
                > 24
        })
        .count();
    assert_eq!(
        residual, 0,
        "sans camera, le rendu devrait etre celui du preset no-webcam ({residual} px d'ecart)"
    );
}

// ---------------------------------------------------------------------------
// Annotations : figure (fleche), flou/mosaique, image, et animations du texte.
//
// Ces quatre familles existaient dans le schema et arrivaient jusqu'au
// compositeur, mais le chemin Linux ne dessinait QUE le texte -- tout le reste
// etait ignore en silence. Les tests ci-dessous les MESURENT sur le GPU au lieu
// de supposer qu'un draw ajoute suffit : la methode est toujours la meme, rendre
// deux fois la meme scene (avec et sans l'annotation) et lire l'empreinte dans
// le diff. Elle ne demande de connaitre ni ou `plan_frame` a pose l'ecran, ni
// quelle couleur la video porte a cet endroit.
// ---------------------------------------------------------------------------

/// Scene de base des tests d'annotation : fond uni, pas d'effets, une liste
/// d'annotations injectee telle quelle.
fn annotation_scene(annotations: &str) -> String {
    annotation_scene_with_zoom("", annotations)
}

/// La meme, avec une liste de regions de zoom injectee telle quelle. Le zoom est
/// ce qui separe le rect d'ancrage des annotations (`s_ann`) de la boite ecran
/// (`s_dst`) : sans lui les deux coincident et rien ne peut le mesurer.
fn annotation_scene_with_zoom(zoom_regions: &str, annotations: &str) -> String {
    format!(
        r##"{{"clips":[],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0.1,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},"background":{{"kind":"color","color":"#00ff00"}},"zoomRegions":[{zoom_regions}],"annotations":[{annotations}],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##
    )
}

/// Indices des pixels qui different entre deux rendus. C'est l'empreinte exacte
/// de ce que l'annotation a ajoute.
fn changed_pixels(a: &[u8], b: &[u8]) -> Vec<usize> {
    a.chunks_exact(4)
        .zip(b.chunks_exact(4))
        .enumerate()
        .filter(|(_, (p, q))| {
            // Seuil 6/255 : au-dessus du bruit de quantification du YUV->RGB,
            // bien en-dessous de tout trait ou masque reel.
            (0..3).any(|c| (p[c] as i32 - q[c] as i32).abs() > 6)
        })
        .map(|(i, _)| i)
        .collect()
}

/// Boite englobante (x0, y0, x1, y1) inclusive d'une liste d'indices de pixels.
fn bbox(px: &[usize], w: u32) -> (u32, u32, u32, u32) {
    let (mut x0, mut y0, mut x1, mut y1) = (u32::MAX, u32::MAX, 0u32, 0u32);
    for &i in px {
        let (x, y) = (i as u32 % w, i as u32 / w);
        x0 = x0.min(x);
        y0 = y0.min(y);
        x1 = x1.max(x);
        y1 = y1.max(y);
    }
    (x0, y0, x1, y1)
}

/// Une fleche est un TRACE, pas un aplat — et elle suit sa direction.
///
/// Deux pieges que ce test ferme. Le premier : ne rien dessiner du tout, ce que
/// faisait le chemin Linux. Le second, plus sournois : dessiner le quad entier
/// (un mode inconnu tombe sur la branche « ombre » du shader et remplit la
/// boite), ce qui se voit comme un rectangle colore et non comme une fleche.
/// L'aire couverte les separe : trois segments d'epaisseur fixe ne peuvent pas
/// remplir la moitie de leur boite.
#[test]
fn compose_linux_annotation_fleche() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux annotation fleche: opt-in. Skip.");
        return;
    }
    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    let mut render = |annotations: &str| -> Vec<u8> {
        let parsed = Scene::from_json(&annotation_scene(annotations)).expect("scene json");
        // Cf. compose_linux_forme_webcam_cercle : sans les LiveParams la scene
        // est parsee puis ignoree, et le test mesure les valeurs par defaut.
        comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&parsed));
        comp.set_scene(Some(parsed));
        // Le 3e argument de `compose_frame` est un NUMERO DE FRAME (source_t =
        // frame / 60), pas des secondes. `set_timeline_time` fixe directement
        // l'instant que lit la fenetre temporelle des annotations -- sans lui,
        // une annotation a `startSec: 1` ne serait tout simplement pas visible,
        // et un test d'animation mesurerait sa propre erreur de cadrage.
        comp.set_timeline_time(Some(1.0));
        unsafe {
            let sf = screen.seek_to(1.0).expect("seek");
            comp.compose_frame(sf, std::ptr::null(), 60.0, &Cfg::c8()).expect("compose_frame");
            comp.readback_direct().expect("readback").2
        }
    };

    let figure = |direction: &str| {
        format!(
            r##"{{"id":"f1","kind":"figure","x":0.2,"y":0.2,"w":0.4,"h":0.4,"startSec":0,"endSec":10,"zIndex":1,"figure":{{"direction":"{direction}","color":"#ff0000","strokeWidth":8}}}}"##
        )
    };
    let none = render("");
    let right = render(&figure("right"));
    let up = render(&figure("up"));

    let right_px = changed_pixels(&none, &right);
    let up_px = changed_pixels(&none, &up);
    assert!(
        right_px.len() > 200,
        "aucune fleche dessinee ({} px changes) — le mode 9 n'atteint pas le shader",
        right_px.len()
    );

    // La boite fait 0.4 x 0.4 du rect ecran ; la fleche s'y inscrit en carre
    // (preserveAspectRatio). Un trait de 8/100 d'epaisseur sur trois segments
    // couvre nettement moins de la moitie de ce carre.
    let (x0, y0, x1, y1) = bbox(&right_px, W);
    let box_area = ((x1 - x0 + 1) * (y1 - y0 + 1)) as f64;
    let fill = right_px.len() as f64 / box_area;
    assert!(
        fill < 0.5,
        "la fleche remplit {fill:.2} de sa boite — c'est un aplat, pas un trace"
    );

    // La direction est vraiment lue : « right » et « up » sont deux tracés
    // differents, donc leurs empreintes ne peuvent pas coincider.
    let common = right_px
        .iter()
        .collect::<std::collections::HashSet<_>>()
        .intersection(&up_px.iter().collect::<std::collections::HashSet<_>>())
        .count();
    let overlap = common as f64 / right_px.len().min(up_px.len()) as f64;
    assert!(
        overlap < 0.75,
        "« right » et « up » se recouvrent a {overlap:.2} — la direction est ignoree"
    );
}

/// Le flou floute vraiment, et la mosaique fait des blocs.
///
/// Mesure sur l'ENERGIE HAUTE FREQUENCE (somme des ecarts entre voisins
/// horizontaux) dans la zone masquee. Compter des pixels changes ne suffirait
/// pas : un masque qui recopierait la frame telle quelle changerait aussi des
/// pixels au bord et passerait. Ce qu'on veut prouver, c'est que le detail a
/// DISPARU — c'est la seule propriete qui rend l'annotation utile.
#[test]
fn compose_linux_annotation_flou_et_mosaique() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux annotation flou: opt-in. Skip.");
        return;
    }
    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    let mut render = |annotations: &str| -> Vec<u8> {
        let parsed = Scene::from_json(&annotation_scene(annotations)).expect("scene json");
        comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&parsed));
        comp.set_scene(Some(parsed));
        // Le 3e argument de `compose_frame` est un NUMERO DE FRAME (source_t =
        // frame / 60), pas des secondes. `set_timeline_time` fixe directement
        // l'instant que lit la fenetre temporelle des annotations -- sans lui,
        // une annotation a `startSec: 1` ne serait tout simplement pas visible,
        // et un test d'animation mesurerait sa propre erreur de cadrage.
        comp.set_timeline_time(Some(1.0));
        unsafe {
            let sf = screen.seek_to(1.0).expect("seek");
            comp.compose_frame(sf, std::ptr::null(), 60.0, &Cfg::c8()).expect("compose_frame");
            comp.readback_direct().expect("readback").2
        }
    };

    // Boite bien a l'interieur du rect ecran, sur de la video (pas sur le fond).
    let blur_ann = |style: &str, amount: f32| {
        format!(
            r##"{{"id":"b1","kind":"blur","x":0.25,"y":0.25,"w":0.5,"h":0.5,"startSec":0,"endSec":10,"zIndex":1,"blur":{{"style":"{style}","shape":"rectangle","color":"white","intensity":{amount},"blockSize":{amount}}}}}"##
        )
    };
    let none = render("");
    let blurred = render(&blur_ann("blur", 24.0));
    let mosaic = render(&blur_ann("mosaic", 16.0));

    let changed = changed_pixels(&none, &blurred);
    assert!(
        changed.len() > 2000,
        "le flou n'a rien change ({} px) — le mode 10 n'atteint pas le shader",
        changed.len()
    );
    let (x0, y0, x1, y1) = bbox(&changed, W);

    // Energie haute frequence sur le canal vert, a l'interieur de la zone, en
    // s'ecartant du bord (les 2 px de bord melangent masque et image nette).
    let hf = |px: &[u8]| -> f64 {
        let mut sum = 0f64;
        let mut n = 0usize;
        for y in (y0 + 2)..=(y1 - 2) {
            for x in (x0 + 2)..(x1 - 2) {
                let i = ((y * W + x) * 4) as usize;
                let j = i + 4;
                sum += (px[i + 1] as i32 - px[j + 1] as i32).abs() as f64;
                n += 1;
            }
        }
        sum / n.max(1) as f64
    };
    let sharp_hf = hf(&none);
    let blur_hf = hf(&blurred);
    assert!(
        sharp_hf > 1.0,
        "la fixture est trop plate a cet endroit ({sharp_hf:.2}) pour mesurer un flou"
    );
    assert!(
        blur_hf < sharp_hf * 0.5,
        "detail toujours present sous le flou : {blur_hf:.2} contre {sharp_hf:.2} sans masque"
    );

    // Mosaique : a l'interieur d'un bloc les pixels sont IDENTIQUES, donc la
    // proportion de voisins strictement egaux explose par rapport a l'image
    // nette. C'est la signature d'un aplat par blocs, qu'un simple flou n'a pas.
    let flat_ratio = |px: &[u8]| -> f64 {
        let (mut eq, mut n) = (0usize, 0usize);
        for y in (y0 + 2)..=(y1 - 2) {
            for x in (x0 + 2)..(x1 - 2) {
                let i = ((y * W + x) * 4) as usize;
                let j = i + 4;
                if px[i..i + 3] == px[j..j + 3] {
                    eq += 1;
                }
                n += 1;
            }
        }
        eq as f64 / n.max(1) as f64
    };
    let sharp_flat = flat_ratio(&none);
    let mosaic_flat = flat_ratio(&mosaic);
    assert!(
        mosaic_flat > sharp_flat + 0.3,
        "pas de blocs : {mosaic_flat:.2} de voisins egaux contre {sharp_flat:.2} sans masque"
    );
}

/// Une image d'annotation tient dans sa boite SANS etre etiree.
///
/// C'est le meme defaut que celui corrige pour la webcam : coller la source au
/// rect deforme tout ce qui n'a pas exactement son rapport. On rend une image
/// 4:1 dans une boite qui ne l'est pas, et on mesure le rapport de l'empreinte
/// — il doit rester 4:1, quelle que soit la boite.
#[test]
fn compose_linux_annotation_image() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux annotation image: opt-in. Skip.");
        return;
    }
    // Aplat magenta 400x100 : un rapport 4:1 franc, et une couleur que la
    // fixture ne porte pas.
    let img_path = std::env::temp_dir().join("openscreen-annotation-4x1.png");
    let img = image::RgbaImage::from_pixel(400, 100, image::Rgba([255, 0, 255, 255]));
    img.save(&img_path).expect("ecrire le png de test");

    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    let mut render = |annotations: &str| -> Vec<u8> {
        let parsed = Scene::from_json(&annotation_scene(annotations)).expect("scene json");
        comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&parsed));
        comp.set_scene(Some(parsed));
        // Le 3e argument de `compose_frame` est un NUMERO DE FRAME (source_t =
        // frame / 60), pas des secondes. `set_timeline_time` fixe directement
        // l'instant que lit la fenetre temporelle des annotations -- sans lui,
        // une annotation a `startSec: 1` ne serait tout simplement pas visible,
        // et un test d'animation mesurerait sa propre erreur de cadrage.
        comp.set_timeline_time(Some(1.0));
        unsafe {
            let sf = screen.seek_to(1.0).expect("seek");
            comp.compose_frame(sf, std::ptr::null(), 60.0, &Cfg::c8()).expect("compose_frame");
            comp.readback_direct().expect("readback").2
        }
    };

    let none = render("");
    // Boite carree en fraction du rect ecran — donc PAS carree en pixels, et
    // dans tous les cas pas 4:1.
    let with_image = render(&format!(
        r##"{{"id":"i1","kind":"image","x":0.25,"y":0.3,"w":0.4,"h":0.4,"startSec":0,"endSec":10,"zIndex":1,"imagePath":"{}"}}"##,
        img_path.display()
    ));

    let changed = changed_pixels(&none, &with_image);
    assert!(
        changed.len() > 500,
        "aucune image dessinee ({} px changes)",
        changed.len()
    );
    let (x0, y0, x1, y1) = bbox(&changed, W);
    let (bw, bh) = ((x1 - x0 + 1) as f64, (y1 - y0 + 1) as f64);
    let aspect = bw / bh;
    assert!(
        (aspect - 4.0).abs() < 0.25,
        "image etiree : empreinte {bw}x{bh} (rapport {aspect:.2}), attendu 4:1"
    );

    // Et c'est bien l'image qui est peinte, pas un aplat de la couleur du bord :
    // le centre doit etre magenta.
    let (cx, cy) = ((x0 + x1) / 2, (y0 + y1) / 2);
    let i = ((cy * W + cx) * 4) as usize;
    let (r, g_, b) = (with_image[i] as i32, with_image[i + 1] as i32, with_image[i + 2] as i32);
    assert!(
        r > 200 && g_ < 80 && b > 200,
        "centre de l'empreinte non magenta : ({r}, {g_}, {b})"
    );
    let _ = std::fs::remove_file(&img_path);
}

/// Les animations d'apparition du texte sont JOUEES.
///
/// `text_anim.rs` etait porte, teste unitairement et transporte par la scene,
/// mais aucun appelant Linux ne l'invoquait : une annotation animee s'affichait
/// simplement d'un bloc. On rend la MEME frame video a deux instants differents
/// de l'animation en deplaçant `startSec` — le seul ecart possible entre les
/// deux rendus est donc l'animation elle-meme.
#[test]
fn compose_linux_animation_texte() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux animation texte: opt-in. Skip.");
        return;
    }
    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    let mut render = |annotations: &str| -> Vec<u8> {
        let parsed = Scene::from_json(&annotation_scene(annotations)).expect("scene json");
        comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&parsed));
        comp.set_scene(Some(parsed));
        // Le 3e argument de `compose_frame` est un NUMERO DE FRAME (source_t =
        // frame / 60), pas des secondes. `set_timeline_time` fixe directement
        // l'instant que lit la fenetre temporelle des annotations -- sans lui,
        // une annotation a `startSec: 1` ne serait tout simplement pas visible,
        // et un test d'animation mesurerait sa propre erreur de cadrage.
        comp.set_timeline_time(Some(1.0));
        unsafe {
            let sf = screen.seek_to(1.0).expect("seek");
            comp.compose_frame(sf, std::ptr::null(), 60.0, &Cfg::c8()).expect("compose_frame");
            comp.readback_direct().expect("readback").2
        }
    };

    // `startSec` deplace l'instant DANS l'animation sans toucher la frame video :
    // a t=1.0s, start=1.0 donne 0 ms ecoulees, start=0.0 en donne 1000 (fini).
    let text = |animation: &str, start: f32| {
        format!(
            r##"{{"id":"t1","kind":"text","x":0.1,"y":0.1,"w":0.6,"h":0.2,"startSec":{start},"endSec":10,"zIndex":1,"text":{{"content":"Hello","color":"#ffffff","backgroundColor":"transparent","fontSizeRel":0.12,"fontFamily":"","fontWeight":"bold","fontStyle":"normal","textDecoration":"none","textAlign":"center","animation":"{animation}"}}}}"##
        )
    };
    let none = render("");
    let settled = render(&text("fade", 0.0));
    let ink_settled = changed_pixels(&none, &settled).len();
    assert!(
        ink_settled > 200,
        "aucun texte rendu ({ink_settled} px) — le test ne mesure rien"
    );

    // Fondu a 0 ms : opacite 0, donc RIEN ne doit apparaitre. Sans l'animation
    // le texte serait deja a pleine opacite et ce compte vaudrait `ink_settled`.
    let starting = render(&text("fade", 1.0));
    let ink_starting = changed_pixels(&none, &starting).len();
    assert!(
        ink_starting < ink_settled / 10,
        "le fondu n'est pas applique : {ink_starting} px a 0 ms contre {ink_settled} px a la fin"
    );

    // Machine a ecrire a mi-course (350 ms sur 700) : la moitie gauche du bloc
    // est revelee, donc l'empreinte est nettement plus etroite qu'a la fin.
    let typed_full = render(&text("typewriter", 0.0));
    let typed_half = render(&text("typewriter", 0.65));
    let full_px = changed_pixels(&none, &typed_full);
    let half_px = changed_pixels(&none, &typed_half);
    assert!(!half_px.is_empty(), "la machine a ecrire n'a rien revele a mi-course");
    let full_right = bbox(&full_px, W).2;
    let half_right = bbox(&half_px, W).2;
    assert!(
        half_right < full_right,
        "le texte n'est pas revele progressivement : bord droit {half_right} a mi-course \
         contre {full_right} a la fin"
    );
}

/// Une caption ne bouge ni ne grossit quand le contenu zoome ou s'incline.
///
/// C'est le contrat de `SceneAnnotation` — l'overlay de la preview est FRERE de
/// l'element qui porte la transform, donc les sous-titres tiennent en place
/// pendant que la video zoome dessous — et c'est celui que ce backend violait :
/// il ancrait les annotations sur `s_dst`, la boite ecran, au lieu de `s_ann`.
/// Windows et macOS avaient ete corriges a l'issue #179, Linux non. Le natif
/// etant la SEULE source de pixels de l'apercu (le DOM ne peint que la poignee
/// de selection, cf. `AnnotationOverlay.tsx`), la derive se voyait des l'edition
/// sur cette plateforme, pas seulement a l'export.
///
/// La bande porte un fond OPAQUE : son empreinte est un RECT PLEIN et non la
/// silhouette des glyphes, donc la boite englobante mesure une geometrie de
/// placement et pas ce que la video montre dessous. Ce rect est la plaque du
/// rasteriseur (`glyphs.plate`), serree sur les lignes posees — pas la boite
/// 0.92x0.22 de l'annotation : peu importe ici, la plaque est une fonction
/// deterministe de `dst` et de `font_size_px`, tous deux ancres sur `s_ann`.
/// Chaque rendu est diffe contre son propre rendu sans annotation, sinon le
/// changement du calque video sous le zoom dominerait la mesure.
///
/// La rotation compte autant que le zoom : un preset iso/left/right est une
/// propriete de region de zoom, donc l'incliner amenait la boite avec lui — et
/// les sous-titres partaient avec elle sans pour autant suivre le plan incline.
#[test]
fn compose_linux_annotation_ancree_hors_zoom() {
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(FIXTURE).is_file() {
        eprintln!("compose_linux annotation hors zoom: opt-in. Skip.");
        return;
    }
    let gpu = Gpu::create(false).expect("Gpu::create");
    let comp = Compositor::new_sized(&gpu, W, H).expect("Compositor::new_sized");
    let mut screen = Decoder::open(FIXTURE, &gpu).expect("Decoder::open");

    // UN SEUL `seek_to`, comme `compose_linux_ecran_tilte` : les six rendus partagent
    // la meme AVFrame, donc le decodeur ne peut pas introduire une difference qu'on
    // prendrait pour un deplacement de la bande.
    let sf = unsafe { screen.seek_to(1.0).expect("seek") };

    let render = |zoom: &str, annotations: &str| -> Vec<u8> {
        let parsed =
            Scene::from_json(&annotation_scene_with_zoom(zoom, annotations)).expect("scene json");
        comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&parsed));
        comp.set_scene(Some(parsed));
        // C'est CET override qui fixe le temps echantillonne, pas le 3e argument de
        // `compose_frame` : `plan_frame` lit `timeline_t_override.unwrap_or(frame / FPS)`,
        // et `FPS` y vaut 60 en dur (pas le `fps` de la scene). t = 3 s tombe au coeur
        // de la region [0, 6], rampe d'entree finie, zoom et rotation a pleine force.
        comp.set_timeline_time(Some(3.0));
        unsafe {
            comp.compose_frame(sf, sf, 90.0, &Cfg::c8()).expect("compose_frame");
            comp.readback_direct().expect("readback").2
        }
    };

    let zoom = |rotation: &str| {
        format!(
            r##"{{"id":"z1","clipIndex":0,"startSec":0,"endSec":6,"scale":2.5,"focusX":0.5,"focusY":0.3,"focusMode":"manual","rotation":{rotation}}}"##
        )
    };
    // Bande basse pleine largeur, comme une vraie caption : hors du centre, donc
    // un ancrage qui suivrait le zoom la deplacerait ET la ferait deborder.
    const BAND: &str = r##"{"id":"c1","kind":"text","x":0.04,"y":0.74,"w":0.92,"h":0.22,"startSec":0,"endSec":10,"zIndex":1,"text":{"content":"Sous-titre","color":"#ffffff","backgroundColor":"#e0245e","fontSizeRel":0.09,"fontFamily":"","fontWeight":"bold","fontStyle":"normal","textDecoration":"none","textAlign":"center"}}"##;

    let (z, tilt) = (zoom("null"), zoom(r#""iso""#));
    let bare_plain = render("", "");
    let with_plain = render("", BAND);
    let bare_zoom = render(&z, "");
    let with_zoom = render(&z, BAND);
    let bare_tilt = render(&tilt, "");
    let with_tilt = render(&tilt, BAND);

    let band_bbox = |bare: &[u8], with: &[u8], label: &str| {
        let px = changed_pixels(bare, with);
        // C'est CE garde-fou qui saute en premier quand le bug est present : ancree sur
        // `s_dst`, la bande part a y ~= 840 px dans un cadre de 540 et sort du champ, donc
        // elle ne change plus aucun pixel au lieu de se decaler de quelques-uns.
        assert!(
            px.len() > 500,
            "bande absente ({} px changes) — {label} : sortie du cadre, donc ancree sur \
             `s_dst` au lieu de `s_ann`",
            px.len()
        );
        bbox(&px, W)
    };
    let plain = band_bbox(&bare_plain, &with_plain, "sans zoom");
    let zoomed = band_bbox(&bare_zoom, &with_zoom, "avec zoom");
    let tilted = band_bbox(&bare_tilt, &with_tilt, "avec rotation 3D");

    // Garde-fou : le zoom doit vraiment agir sur l'image, sinon les egalites
    // ci-dessous seraient vraies pour la mauvaise raison.
    let moved = changed_pixels(&bare_plain, &bare_zoom);
    assert!(
        moved.len() > 10_000,
        "le zoom n'a change que {} px — la scene zoomee n'est pas appliquee",
        moved.len()
    );

    // 2 px de tolerance pour l'antialiasing du bord de la plaque. L'erreur visee est
    // d'un tout autre ordre : sous zoom 2.5 la bande ancree sur `s_dst` descend de
    // ~450 px et grossit d'autant, donc en pratique elle quitte le cadre et c'est le
    // garde-fou « bande absente » ci-dessus qui tranche. Cette boucle attrape le reste :
    // un ancrage qui deriverait sans sortir du champ.
    for (name, got) in [("zoom", zoomed), ("rotation 3D", tilted)] {
        let d = [
            got.0.abs_diff(plain.0),
            got.1.abs_diff(plain.1),
            got.2.abs_diff(plain.2),
            got.3.abs_diff(plain.3),
        ];
        assert!(
            d.iter().all(|&v| v <= 2),
            "la bande a suivi le {name} : {got:?} contre {plain:?} sans — \
             les annotations sont ancrees sur `s_dst` au lieu de `s_ann`"
        );
    }
}

// ---------------------------------------------------------------------------
// Profondeur de champ du mode 8 (pendant Linux de `tilted_depth_of_field.rs`)
// ---------------------------------------------------------------------------

/// Nettete d'une fenetre `r`x`r` centree en `c` : moyenne des ecarts entre voisins (vert).
fn dof_sharpness(rgba: &[u8], w: u32, c: (u32, u32), r: u32) -> f64 {
    let g = |x: u32, y: u32| rgba[((y * w + x) * 4 + 1) as usize] as f64;
    let (mut acc, mut n) = (0.0, 0.0);
    for y in c.1 - r / 2..c.1 + r / 2 {
        for x in c.0 - r / 2..c.0 + r / 2 {
            acc += (g(x + 1, y) - g(x, y)).abs() + (g(x, y + 1) - g(x, y)).abs();
            n += 1.0;
        }
    }
    acc / n
}

/// Octets RGBA de la fenetre `r`x`r` centree en `c`.
fn dof_window_bytes(rgba: &[u8], w: u32, c: (u32, u32), r: u32) -> Vec<u8> {
    let mut out = Vec::new();
    for y in c.1 - r / 2..c.1 + r / 2 {
        let i = ((y * w + c.0 - r / 2) * 4) as usize;
        out.extend_from_slice(&rgba[i..i + (r * 4) as usize]);
    }
    out
}

/// Coin du plan (hors fond magenta) extreme dans la direction `dir`, rentre de `inset`
/// vers le centroide.
fn dof_corner(rgba: &[u8], w: u32, h: u32, dir: (i64, i64), inset: f64) -> (u32, u32) {
    let (mut best, mut at) = (i64::MIN, (0i64, 0i64));
    let (mut sx, mut sy, mut n) = (0f64, 0f64, 0f64);
    for y in 0..h as i64 {
        for x in 0..w as i64 {
            let i = ((y * w as i64 + x) * 4) as usize;
            if !not_bg(&rgba[i..i + 4]) {
                continue;
            }
            sx += x as f64;
            sy += y as f64;
            n += 1.0;
            if x * dir.0 + y * dir.1 > best {
                best = x * dir.0 + y * dir.1;
                at = (x, y);
            }
        }
    }
    let x = at.0 as f64 + (sx / n - at.0 as f64) * inset;
    let y = at.1 as f64 + (sy / n - at.1 as f64) * inset;
    (x as u32, y as u32)
}

/// Golden par backend : iso, focus sur le coin proche. Le coin lointain perd son detail, le
/// proche ne bouge pas d'un octet, et a plat le reglage ne change rien. Un `level(lod)` qui
/// retomberait au niveau 0 (vue a un seul niveau, binding 4 mal lie) rendrait le lointain net.
/// Source : `OPENSCREEN_DOF_SOURCE` (du texte de preference), sinon la fixture.
#[test]
fn compose_linux_profondeur_de_champ() {
    let source = std::env::var("OPENSCREEN_DOF_SOURCE").unwrap_or_else(|_| FIXTURE.into());
    if std::env::var("OPENSCREEN_LINUX_COMPOSE").is_err() || !Path::new(&source).is_file() {
        eprintln!("compose_linux dof: opt-in (OPENSCREEN_LINUX_COMPOSE=1 + source). Skip.");
        return;
    }
    let (w, h) = (1920u32, 1080u32);
    // `create_auto` : lavapipe (backend CPU) compte, et `DOF_ON_CPU_BACKEND` l'y laisse tourner.
    let gpu = Gpu::create_auto(false).expect("Gpu::create_auto");
    let comp = Compositor::new_sized(&gpu, w, h).expect("Compositor::new_sized");
    let mut dec = Decoder::open(&source, &gpu).expect("Decoder::open");
    let mut cfg = Cfg::c8();
    cfg.shadow = false;
    let scene = |rotation: &str, dof: bool| {
        tilt_scene_json(rotation, 0, 0.0)
            .replace(r#""motionBlur":0}"#, &format!(r#""motionBlur":0,"depthOfField":{dof}}}"#))
            .replace(r#""focusX":0.5,"focusY":0.5"#, r#""focusX":0.94,"focusY":0.06"#)
    };
    let (on, off, flat_on, flat_off) = unsafe {
        let sf = dec.seek_to(1.0).expect("Decoder::seek_to");
        let render = |json: String| {
            let scene = Scene::from_json(&json).expect("scene json");
            comp.set_live_params(openscreen_compositor::compositor::live_params_from_scene(&scene));
            comp.set_scene(Some(scene));
            comp.compose_frame(sf, sf, 90.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback_direct").2
        };
        (
            render(scene("\"iso\"", true)),
            render(scene("\"iso\"", false)),
            render(scene("null", true)),
            render(scene("null", false)),
        )
    };
    write_ppm("compose_linux_dof_on", w, h, &on);
    write_ppm("compose_linux_dof_off", w, h, &off);
    let r = 48;
    let near = dof_corner(&off, w, h, (1, -1), 0.12);
    let far = dof_corner(&off, w, h, (-1, 1), 0.12);
    let (near_on, near_off) = (dof_sharpness(&on, w, near, r), dof_sharpness(&off, w, near, r));
    let (far_on, far_off) = (dof_sharpness(&on, w, far, r), dof_sharpness(&off, w, far, r));
    println!(
        "compose_linux dof : proche {near_off:.2} -> {near_on:.2}, lointain {far_off:.2} -> {far_on:.2}"
    );
    assert!(far_off > 2.0, "fenetre lointaine sans detail ({far_off})");
    assert!(
        dof_window_bytes(&on, w, near, r) == dof_window_bytes(&off, w, near, r),
        "coin proche modifie : {near_off} -> {near_on}"
    );
    assert!(far_on < far_off * 0.7, "coin lointain pas floute : {far_off} -> {far_on}");
    assert!(flat_on == flat_off, "rotation nulle : la profondeur de champ a change la frame");
}