Skip to content

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

21.2 KB
Raw Blame
//! Le contact du curseur modélisé et l'impact du clic (mode 16), rendus par le vrai compositeur
//! D3D11 sur une frame NV12 SYNTHÉTIQUE : une maquette d'interface dont les cibles portent une
//! pastille rouge au pixel exact du clic. Sans adaptateur matériel, les tests se sautent
//! (« test saute »).
//!
//! - au contact, la pointe couvre la pastille, même sous un fort lissage (la piste lissée traîne
//!   loin derrière la souris), à plat, sous un angle fixe et sous la caméra réelle ;
//! - l'anneau de l'impact est centré sur la pastille.
//!
//! Et, en opt-in, une vidéo de 4 s à 30 i/s (la flèche puis la main qui cliquent, à plat et en
//! `iso`, côte à côte) et une planche des images autour du contact :
//!
//! ```powershell
//! $env:OPENSCREEN_CURSOR_TAP_OUT = "...\cursor-tap"
//! cargo test -p openscreen-compositor --test cursor_tap_render -- --nocapture
//! ```

#![cfg(windows)]

use openscreen_compositor::compositor::Compositor;
use openscreen_compositor::config::Cfg;
use openscreen_compositor::cursor::CursorTrack;
use openscreen_compositor::d3d::Gpu;
use openscreen_compositor::frame_geometry::{
    live_params_from_scene, plan_cursor, plan_frame, CursorPlacement, CursorPlanInput,
    FrameGeometryInput,
};
use openscreen_compositor::scene::Scene;

mod common;
use common::{gpu, Nv12Frame};

const SRC: (u32, u32) = (1280, 720);
const OUT: (u32, u32) = (1280, 720);
/// Les deux cibles (repère normalisé de l'écran) et l'instant de leur clic : la flèche clique la
/// première, la main (état `pointer`) la seconde. Chacune tombe au centre d'un bloc de chroma
/// NV12 (texels impairs) : la pastille est alors symétrique autour d'elle, chroma comprise.
const TARGETS: [([f32; 2], f32); 2] =
    [([385.0 / 1280.0, 259.0 / 720.0], 1.0), ([897.0 / 1280.0, 447.0 / 720.0], 2.4)];
/// Au creux du contact (`regions::tap`).
const CONTACT_S: f32 = 0.0495;

/// Une maquette d'interface en NV12 (barre de titre, carte, lignes de texte, deux boutons), avec
/// une pastille rouge de 5 texels de rayon au centre exact de chaque cible. Présentée comme une
/// frame D3D11VA (cf. `cursor_model_render.rs`). La luma est évaluée au centre de chaque texel, la
/// chroma au centre de chaque bloc 2×2.
fn mock_frame(gpu: &Gpu) -> Nv12Frame {
    let (w, h) = SRC;
    // (Y, Cb, Cr) de chaque pixel, en BT.709 limité.
    let pixel = |fx: f32, fy: f32| -> (u8, u8, u8) {
        let (x, y) = (fx as u32, fy as u32);
        for ([tx, ty], _) in TARGETS {
            let (cx, cy) = (tx * w as f32, ty * h as f32);
            if (fx - cx).hypot(fy - cy) <= 5.0 {
                return (63, 102, 240); // rouge
            }
        }
        let button = |c: [f32; 2], hw: f32, hh: f32| {
            let (dx, dy) = ((fx - c[0] * w as f32).abs(), (fy - c[1] * h as f32).abs());
            (dx - hw + 10.0).max(0.0).hypot((dy - hh + 10.0).max(0.0)) <= 10.0
        };
        if button(TARGETS[0].0, 130.0, 70.0) {
            return (92, 180, 110); // bouton bleu
        }
        if button(TARGETS[1].0, 90.0, 26.0) {
            return (150, 100, 90); // bouton vert
        }
        if y < 56 {
            return (48, 132, 126); // barre de titre sombre
        }
        if x < 220 {
            let item = (y - 56) % 44;
            return if (14..22).contains(&item) && (24..150).contains(&x) { (150, 128, 128) } else { (222, 129, 127) };
        }
        let card = x > 250 && x < 1240 && y > 90 && y < 690;
        if card && (x == 251 || x == 1239 || y == 91 || y == 689) {
            return (200, 128, 128);
        }
        // Lignes de « texte » dans la carte, à l'écart des boutons.
        let line = (y % 36) >= 14 && (y % 36) < 20 && x > 280 && x < 1200 && (x / 97) % 5 != 4;
        if card && line {
            return (135, 128, 128);
        }
        (if card { 245 } else { 232 }, 128, 128)
    };
    Nv12Frame::new(
        gpu,
        SRC,
        |x, y| pixel(x as f32 + 0.5, y as f32 + 0.5).0,
        |bx, by| {
            let (_, cb, cr) = pixel(2.0 * bx as f32 + 1.0, 2.0 * by as f32 + 1.0);
            [cb, cr]
        },
    )
}

/// `rotation` : valeur JSON du préset ; `hide` : le curseur masqué par la région (la caméra le
/// suit toujours), pour lire la pastille sans lui.
fn scene_json(rotation: &str, hide: bool, click_bounce: f32) -> String {
    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("../../public/cursors/default")
        .to_string_lossy()
        .replace('\\', "/");
    format!(
        r##"{{"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
            "layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false,
                       "screenRect":{{"x":0.1,"y":0.1,"width":0.8,"height":0.8}}}},
            "effects":{{"padding":0.2,"blur":false,"shadow":0.5,"roundnessFrac":0.03,"motionBlur":0}},
            "background":{{"kind":"gradient","angleDeg":135,"stops":["#5b6ee1","#e8a0bf"]}},
            "zoomRegions":[{{"clipIndex":0,"startSec":0,"endSec":10,"scale":1,"focusX":0.5,"focusY":0.5,"rotation":{rotation},"hideCursor":{hide}}}],
            "annotations":[],
            "cursor":{{"show":true,"size":4,"smoothing":0.5,"motionBlur":0.5,"clickBounce":{click_bounce},"model3d":true,"clipToBounds":false,"theme":"default",
                       "cursorSprites":{{"arrow":{{"path":"{dir}/arrow.png","hotspotX":0.1205,"hotspotY":0.0881}},
                                        "pointer":{{"path":"{dir}/pointer.png","hotspotX":0.3874,"hotspotY":0.0032}}}}}},
            "cropByClip":[null],
            "output":{{"width":1280,"height":720,"fps":30}}}}"##
    )
}

/// Le geste : repos, arc jusqu'à la première cible (arrivée 80 ms avant le clic), tenue 120 ms,
/// arc jusqu'à la seconde, qui se survole en main, puis départ. 60 Hz, clics compris, lissé à
/// 0,5 comme le ferait l'application.
fn gesture(name: &str) -> CursorTrack {
    let ([ax, ay], t1) = TARGETS[0];
    let ([bx, by], t2) = TARGETS[1];
    let ease = |u: f32| {
        let u = u.clamp(0.0, 1.0);
        u * u * (3.0 - 2.0 * u)
    };
    let arc = |p: [f32; 2], q: [f32; 2], u: f32, bow: f32| {
        let e = ease(u);
        let (dx, dy) = (q[0] - p[0], q[1] - p[1]);
        let s = (std::f32::consts::PI * e).sin() * bow;
        (p[0] + dx * e - dy * s, p[1] + dy * e + dx * s)
    };
    let pos = |t: f32| -> (f32, f32) {
        let start = [0.12, 0.8];
        let end = [0.9, 0.3];
        if t < t1 - 0.08 {
            arc(start, [ax, ay], (t - 0.1) / (t1 - 0.18), 0.15)
        } else if t < t1 + 0.12 {
            (ax, ay)
        } else if t < t2 - 0.1 {
            arc([ax, ay], [bx, by], (t - t1 - 0.12) / (t2 - t1 - 0.22), -0.2)
        } else if t < t2 + 0.15 {
            (bx, by)
        } else {
            arc([bx, by], end, (t - t2 - 0.15) / 0.9, 0.1)
        }
    };
    let clicks = [t1, t2];
    let body: Vec<String> = (0..=300)
        .map(|i| {
            let t = i as f32 / 60.0;
            let (x, y) = pos(t);
            let click = if clicks.iter().any(|c| (c - t).abs() < 1e-3) { r#","interactionType":"click""# } else { "" };
            let kind = if t > (t1 + t2) * 0.5 { "pointer" } else { "arrow" };
            format!(r#"{{"timeMs":{},"cx":{x},"cy":{y}{click},"cursorType":"{kind}"}}"#, (t * 1000.0).round())
        })
        .collect();
    let path = std::env::temp_dir().join(format!("os_cursor_tap_{name}.json"));
    std::fs::write(&path, format!(r#"{{"samples":[{}]}}"#, body.join(","))).expect("sidecar");
    CursorTrack::load(path.to_str().unwrap(), 0.0, 10.0).expect("piste curseur").smoothed(0.5)
}

fn cfg() -> Cfg {
    let mut cfg = Cfg::c8();
    cfg.bg_blur = 0.0;
    cfg.zoom = false;
    cfg.layout_anim = false;
    cfg.cursor = true;
    cfg.mblur_n = 1;
    cfg.shadow = true;
    cfg
}

/// La frame à `t`, et le pixel du contenu où le plan pose le curseur (la pointe), s'il y en a un.
fn render(comp: &Compositor, screen: &Nv12Frame, json: &str, track: &CursorTrack, t: f32) -> (Vec<u8>, Option<[f32; 2]>) {
    let scene = Scene::from_json(json).expect("scène valide");
    let mut live = live_params_from_scene(&scene);
    live.has_webcam = false;
    comp.set_live_params(live);
    comp.set_has_webcam(false);
    comp.set_scene(Some(scene.clone()));
    comp.set_cursor(track.clone());
    comp.set_cursor_time(Some(t));
    comp.set_timeline_time(Some(t));
    let cfg = cfg();
    let (w, h, rgba) = unsafe {
        comp.compose_frame(screen.as_ptr(), screen.as_ptr(), t * 30.0, &cfg).expect("compose_frame");
        comp.readback_direct().expect("readback")
    };
    assert_eq!((w, h), OUT);
    let render_px = [w as f32, h as f32];
    let src = [SRC.0 as f32, SRC.1 as f32];
    let g = plan_frame(&FrameGeometryInput {
        render_px,
        screen_tex_px: src,
        screen_visible_px: src,
        webcam_visible_px: src,
        u_max: 1.0,
        v_max: 1.0,
        frame: t * 30.0,
        cfg: &cfg,
        live,
        scene: Some(&scene),
        cursor: Some(track),
        timeline_t_override: Some(t),
        programme_time: None,
    });
    let input = CursorPlanInput { render_px, u_max: 1.0, v_max: 1.0, cfg: &cfg, live, scene: Some(&scene), track, t };
    let tip = plan_cursor(&g, &input).map(|plan| match plan.placement {
        CursorPlacement::Tilted { plane_pt, quad, center_px, .. } => {
            let (x, y) = quad.point_px(plane_pt[0], plane_pt[1]);
            [center_px[0] + x, center_px[1] + y]
        }
        CursorPlacement::Upright { center } => [center[0] * render_px[0], center[1] * render_px[1]],
    });
    (rgba, tip)
}

fn px(rgba: &[u8], x: i32, y: i32) -> [i32; 3] {
    let i = ((y * OUT.0 as i32 + x) * 4) as usize;
    [rgba[i] as i32, rgba[i + 1] as i32, rgba[i + 2] as i32]
}

fn is_red(p: [i32; 3]) -> bool {
    p[0] > p[1] + 60 && p[0] > p[2] + 60
}

/// Centre (px) de la pastille rouge la plus proche de `near`, lu dans l'image.
fn marker(rgba: &[u8], near: [f32; 2]) -> [f32; 2] {
    let (mut sx, mut sy, mut n) = (0.0, 0.0, 0.0);
    for y in (near[1] as i32 - 40).max(0)..(near[1] as i32 + 40).min(OUT.1 as i32) {
        for x in (near[0] as i32 - 40).max(0)..(near[0] as i32 + 40).min(OUT.0 as i32) {
            if is_red(px(rgba, x, y)) {
                sx += x as f32 + 0.5;
                sy += y as f32 + 0.5;
                n += 1.0;
            }
        }
    }
    assert!(n > 10.0, "pas de pastille près de {near:?}");
    [sx / n, sy / n]
}

/// Au contact, la pointe couvre la pastille : le pixel du clic n'est plus rouge, et le plan pose
/// la pointe sur le centre mesuré de la pastille à 0,5 px près. À plat, en `iso` et sous la
/// caméra réelle, avec une piste lissée à 0,5 qui passe à des dizaines de px de la cible.
#[test]
fn the_tip_lands_on_the_marked_click_target() {
    let Some(gpu) = gpu() else { return };
    let comp = Compositor::new_sized(&gpu, OUT.0, OUT.1).expect("compositor");
    let screen = mock_frame(&gpu);
    let track = gesture("contact");
    for (name, rotation) in [("flat", "null"), ("iso", r#""iso""#), ("orbit", r#""orbit","focusMode":"auto""#)] {
        for (target, tc) in TARGETS {
            let t = tc + CONTACT_S;
            // La pastille, lue sans curseur au même instant (la caméra suit la même piste).
            let (bare, hidden) = render(&comp, &screen, &scene_json(rotation, true, 2.5), &track, t);
            assert!(hidden.is_none(), "{name}: la région devait masquer le curseur");
            let (touch, tip) = render(&comp, &screen, &scene_json(rotation, false, 2.5), &track, t);
            let tip = tip.expect("curseur au contact");
            let m = marker(&bare, tip);
            let off = (tip[0] - m[0]).hypot(tip[1] - m[1]);
            // Où serait la pointe sur la piste lissée : l'écart que la convergence rattrape, en
            // largeurs d'écran (~1000 px ici).
            let lag = track.at(t).map(|(x, y)| (x - target[0]).hypot(y - target[1])).unwrap() * 1000.0;
            println!("{name} cible {target:?} : pointe à {off:.3} px de la pastille (piste lissée à ~{lag:.0} px)");
            assert!(off < 0.5, "{name} {target:?}: pointe à {off} px de la pastille");
            assert!(lag > 5.0, "{name}: le lissage devrait traîner, sinon le test ne prouve rien");
            // Juste sous le point cliqué, la pointe (l'incrustation noire de la flèche, le trait du
            // doigt, dont le hotspot est le haut) couvre la pastille ; sans la convergence, la
            // pointe serait à des dizaines de px.
            let (x, y) = (m[0] as i32, (m[1] + 2.0) as i32);
            assert!(!is_red(px(&touch, x, y)), "{name} {target:?}: la pastille reste visible sous la pointe");
        }
    }
}

/// L'anneau de l'impact est centré sur la pastille : à plat, il passe à la même distance au-dessus
/// et à gauche d'elle (le curseur couvre le bas et la droite ; les deux côtés sont sur le même
/// bouton), et il n'existe pas sans clic.
#[test]
fn the_impact_ring_is_centred_on_the_click() {
    let Some(gpu) = gpu() else { return };
    let comp = Compositor::new_sized(&gpu, OUT.0, OUT.1).expect("compositor");
    let screen = mock_frame(&gpu);
    let track = gesture("ring");
    let (_, tc) = TARGETS[0];
    let t = tc + 0.16;
    let (bare, _) = render(&comp, &screen, &scene_json("null", true, 2.5), &track, t);
    let (ring, tip) = render(&comp, &screen, &scene_json("null", false, 2.5), &track, t);
    let (quiet, _) = render(&comp, &screen, &scene_json("null", false, 0.0), &track, t);
    let m = marker(&bare, tip.expect("curseur"));
    // Le profil de l'écart dû à l'impact le long d'une demi-droite partant du clic, au-delà du
    // bord de la pointe : le geste du clic y déplace le curseur, que `quiet` (« None ») laisse au
    // repos.
    let peak = |dx: i32, dy: i32| -> (i32, i32) {
        (8..45)
            .map(|r| {
                let (x, y) = (m[0] as i32 + dx * r, m[1] as i32 + dy * r);
                let (a, b) = (px(&ring, x, y), px(&quiet, x, y));
                ((0..3).map(|c| (a[c] - b[c]).abs()).sum::<i32>(), r)
            })
            .max()
            .unwrap()
    };
    let (up, left) = (peak(0, -1), peak(-1, 0));
    println!("anneau : haut {up:?}, gauche {left:?} (gain, rayon px)");
    assert!(up.0 > 60 && left.0 > 60, "anneau absent : {up:?} {left:?}");
    assert!((up.1 - left.1).abs() <= 1, "anneau décentré : {up:?} {left:?}");
    let (late, _) = render(&comp, &screen, &scene_json("null", false, 2.5), &track, tc + 0.5);
    let (late_quiet, _) = render(&comp, &screen, &scene_json("null", false, 0.0), &track, tc + 0.5);
    assert!(late == late_quiet, "l'anneau survit à sa fenêtre");
}

/// Planche des niveaux du clic (opt-in, `OPENSCREEN_CURSOR_TAP_OUT`) : None, Light et Strong en
/// lignes, des instants autour du clic de la flèche en colonnes, agrandis ×2 autour de la pointe.
/// Et la même chose en mouvement, les trois niveaux côte à côte, à 30 i/s puis ralentie ×4.
#[test]
fn cursor_press_levels() {
    let Ok(dir) = std::env::var("OPENSCREEN_CURSOR_TAP_OUT") else {
        eprintln!("OPENSCREEN_CURSOR_TAP_OUT absent — saute");
        return;
    };
    let Some(gpu) = gpu() else { return };
    let comp = Compositor::new_sized(&gpu, OUT.0, OUT.1).expect("compositor");
    let screen = mock_frame(&gpu);
    let track = gesture("levels");
    let frames = format!("{dir}/levels");
    std::fs::create_dir_all(&frames).expect("dossier des frames");
    let ([_, _], tc) = TARGETS[0];
    let levels = [0.0, 1.0, 2.0];
    let img = |rgba: Vec<u8>| image::RgbaImage::from_raw(OUT.0, OUT.1, rgba).expect("readback");
    let (_, tip) = render(&comp, &screen, &scene_json("null", false, 1.0), &track, tc + CONTACT_S);
    let tip = tip.expect("curseur");
    const CELL: u32 = 180;
    let cell = |rgba: Vec<u8>| {
        let (x, y) = ((tip[0] - CELL as f32 * 0.35) as u32, (tip[1] - CELL as f32 * 0.3) as u32);
        image::imageops::crop_imm(&img(rgba), x, y, CELL, CELL).to_image()
    };
    let offsets = [-0.3, -0.2, -0.12, -0.08, -0.04, 0.0, 0.05, 0.1, 0.16, 0.25, 0.42];
    let mut sheet = image::RgbaImage::new(offsets.len() as u32 * 2 * CELL, levels.len() as u32 * 2 * CELL);
    for (row, level) in levels.iter().enumerate() {
        for (col, dt) in offsets.iter().enumerate() {
            let (rgba, _) = render(&comp, &screen, &scene_json("null", false, *level), &track, tc + dt);
            let big = image::imageops::resize(&cell(rgba), 2 * CELL, 2 * CELL, image::imageops::FilterType::Nearest);
            image::imageops::overlay(&mut sheet, &big, (col as u32 * 2 * CELL) as i64, (row as u32 * 2 * CELL) as i64);
        }
    }
    sheet.save(format!("{dir}/press-levels.png")).expect("planche");
    println!("planche des niveaux : lignes {levels:?}, colonnes {offsets:?} s après le clic");
    for (speed, name) in [(1.0, "press-levels.mp4"), (0.25, "press-levels-slow.mp4")] {
        let n = (0.9 / speed * 30.0) as u32;
        for k in 0..n {
            let t = tc - 0.4 + k as f32 / 30.0 * speed;
            let mut row = image::RgbaImage::new(levels.len() as u32 * 2 * CELL, 2 * CELL);
            for (i, level) in levels.iter().enumerate() {
                let (rgba, _) = render(&comp, &screen, &scene_json("null", false, *level), &track, t);
                let big = image::imageops::resize(&cell(rgba), 2 * CELL, 2 * CELL, image::imageops::FilterType::Triangle);
                image::imageops::overlay(&mut row, &big, (i as u32 * 2 * CELL) as i64, 0);
            }
            row.save(format!("{frames}/{k:03}.png")).expect("frame");
        }
        let ffmpeg = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("../thirdparty/ffmpeg-n8.1.2-win64-lgpl-shared/bin/ffmpeg.exe");
        let status = std::process::Command::new(ffmpeg)
            .args(["-y", "-loglevel", "error", "-framerate", "30", "-i"])
            .arg(format!("{frames}/%03d.png"))
            .args(["-c:v", "h264_mf", "-b:v", "8M", "-pix_fmt", "nv12"])
            .arg(format!("{dir}/{name}"))
            .status();
        // Un échec garde les images, pour relancer ou comprendre.
        let status = status.expect("lancement de ffmpeg");
        assert!(status.success(), "ffmpeg a échoué pour {name} : {status}");
        println!("ffmpeg : {status:?} -> {dir}/{name}");
        for k in 0..n {
            let _ = std::fs::remove_file(format!("{frames}/{k:03}.png"));
        }
    }
}

/// Vidéo et planche à regarder (opt-in, `OPENSCREEN_CURSOR_TAP_OUT`).
#[test]
fn cursor_tap_video() {
    let Ok(dir) = std::env::var("OPENSCREEN_CURSOR_TAP_OUT") else {
        eprintln!("OPENSCREEN_CURSOR_TAP_OUT absent — saute");
        return;
    };
    let Some(gpu) = gpu() else { return };
    let comp = Compositor::new_sized(&gpu, OUT.0, OUT.1).expect("compositor");
    let screen = mock_frame(&gpu);
    let track = gesture("video");
    let frames = format!("{dir}/frames");
    std::fs::create_dir_all(&frames).expect("dossier des frames");
    let presets = [("flat", "null"), ("iso", r#""iso""#)];
    let img = |rgba: Vec<u8>| image::RgbaImage::from_raw(OUT.0, OUT.1, rgba).expect("readback");
    for k in 0..120 {
        let t = k as f32 / 30.0;
        let mut both = image::RgbaImage::new(2 * OUT.0, OUT.1);
        for (i, (_, rotation)) in presets.iter().enumerate() {
            let (rgba, _) = render(&comp, &screen, &scene_json(rotation, false, 2.5), &track, t);
            image::imageops::overlay(&mut both, &img(rgba), (i as u32 * OUT.0) as i64, 0);
        }
        both.save(format!("{frames}/{k:03}.png")).expect("frame");
    }
    // La planche : autour de chaque clic, sept instants, agrandis ×2 autour de la pointe.
    const CELL: u32 = 200;
    let offsets = [-0.2, -0.067, 0.033, 0.067, 0.133, 0.233, 0.4];
    let mut sheet = image::RgbaImage::new(offsets.len() as u32 * 2 * CELL, 4 * 2 * CELL);
    for (row, ((name, rotation), (_, tc))) in presets.iter().flat_map(|p| TARGETS.iter().map(move |t| (p, t))).enumerate() {
        let (_, center) = render(&comp, &screen, &scene_json(rotation, false, 2.5), &track, tc + CONTACT_S);
        let center = center.expect("curseur");
        for (col, dt) in offsets.iter().enumerate() {
            let (rgba, _) = render(&comp, &screen, &scene_json(rotation, false, 2.5), &track, tc + dt);
            let (x, y) = ((center[0] - CELL as f32 * 0.5) as u32, (center[1] - CELL as f32 * 0.5) as u32);
            let crop = image::imageops::crop_imm(&img(rgba), x, y, CELL, CELL).to_image();
            let big = image::imageops::resize(&crop, 2 * CELL, 2 * CELL, image::imageops::FilterType::Nearest);
            image::imageops::overlay(&mut sheet, &big, (col as u32 * 2 * CELL) as i64, (row as u32 * 2 * CELL) as i64);
        }
        println!("planche, ligne {row} : {name}, clic à {tc} s, colonnes {offsets:?} s");
    }
    sheet.save(format!("{dir}/contact-sheet.png")).expect("planche");
    let ffmpeg = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("../thirdparty/ffmpeg-n8.1.2-win64-lgpl-shared/bin/ffmpeg.exe");
    let status = std::process::Command::new(ffmpeg)
        .args(["-y", "-loglevel", "error", "-framerate", "30", "-i"])
        .arg(format!("{frames}/%03d.png"))
        .args(["-c:v", "h264_mf", "-b:v", "16M", "-pix_fmt", "nv12"])
        .arg(format!("{dir}/cursor-tap.mp4"))
        .status();
    println!("ffmpeg : {status:?} -> {dir}/cursor-tap.mp4");
}