Skip to content

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

364 KB
Raw Blame
//! Moteur de composition Linux -- wgpu / WGSL.
//!
//! Equivalent Linux de `compositor_windows.rs` / `compositor_macos.rs` : meme
//! surface publique (`Compositor::{new, new_sized, normalize_render_size,
//! render_size, set_scene, set_live_params, set_cursor, set_cursor_time,
//! set_timeline_time, set_programme_time, clear_cursor, scene_snapshot,
//! clear_srv_cache, compose_frame, readback_direct}`) pour que `live.rs` et `compositor-view-napi`
//! (cfg-re-exportes via `crate::compositor`) l'utilisent sans connaitre la
//! plateforme. S'y ajoutent, specifiques a ce backend, les trois entrees de la
//! ring de staging (`set_readback_depth`, `readback_submit`, `readback_take`) :
//! seul l'export Linux les utilise, cf. `ReadbackRing`.
//!
//! **Iso-render.** La GEOMETRIE (placement de chaque calque) vient de
//! `frame_geometry::plan_frame` -- la MEME fonction que Windows/macOS, au pixel
//! pres. Ce module ne fait que RENDRE le `FrameGeometry` via wgpu/WGSL
//! (`vk_shaders/layer.wgsl`), la ou macOS le rend via Metal/MSL.
//!
//! **Portee actuelle.** `compose_frame` rend le coeur : fond uni + calque ecran
//! cover-fit (coins arrondis). Les calques riches (webcam PiP, curseur,
//! annotations texte mode 11, blur de fond, motion blur) sont dessines
//! par les memes primitives (`draw_layer`) et arrivent par iterations, comme le
//! port Metal les a ajoutes -- chacun reutilise `layer.wgsl` (modes deja portes)
//! ou une passe dediee (`blur.wgsl`).
//!
//! **Segmentation du sujet webcam.** Les quatre etages tournent ici comme sur les
//! deux autres back-ends : `capture_webcam_rgb` rend la camera dans une cible
//! 256x144 et la relit, `segmentation.rs` (partage, EP CPU d'ONNX Runtime) produit
//! le masque sur son propre thread, `set_webcam_mask` le televerse en R8, et
//! `layer.wgsl` branche dessus sur `fx.z`. Cf.
//! `technical-documentation/engineering/webcam-segmentation.md`.

use std::cell::RefCell;

use anyhow::Result;
use wgpu::util::DeviceExt;

use crate::config::Cfg;
use crate::d3d::Gpu;
use crate::ffi::AVFrame;
// Re-exports que le code partage (live.rs, compositor-view-napi) consomme via
// `crate::compositor::…`, a l'identique de `compositor_macos`.
pub use crate::frame_geometry::{
    live_params_from_scene, webcam_shape_code, FIXTURE_FRAMES, LayerCB, LiveParams, OUT_H, OUT_W,
};
use crate::frame_geometry::{
    cursor_glass_cb, cursor_model_cb, cursor_sprite_cb, cursor_sprite_dst, parse_hex, plan_cursor,
    plan_frame, tilted_screen_cb, CursorPlacement, CursorPlanInput, FrameGeometryInput,
    ShadowCaster, SpriteShape,
};
use crate::scene::{Scene, SceneBackground, SceneShaderEffect, ShaderEffectTarget, WallpaperMotion};

const LAYER_WGSL: &str = include_str!("vk_shaders/layer.wgsl");
const BLUR_WGSL: &str = include_str!("vk_shaders/blur.wgsl");

/// `layer.wgsl` avec ou sans ses modeles 3D (modes 15 a 17) : la constante que le shader teste
/// pour les compiler, prefixee au source (pourquoi deux pipelines : le haut de `layer.wgsl`).
fn layer_source(models: bool) -> String {
    format!("const LAYER_MODELS: bool = {models};\n{LAYER_WGSL}")
}

/// Budget du cache de textures image (`img_cache`), en octets.
///
/// Doit tenir le JEU ACTIF d'une frame -- au pire un wallpaper d'ecran ET un
/// fond de camera, que rien n'empeche d'etre deux 7680x7680 a 225 Mo piece.
/// Sous ce seuil l'eviction ne peut plus rendre de memoire sans toucher au jeu
/// actif, ce qu'elle refuse de faire. 512 Mo borne la fuite (1 774 Mo mesures
/// en parcourant les 18 wallpapers livres) en laissant le jeu actif resident.
const IMG_CACHE_BUDGET_BYTES: u64 = 512 * 1024 * 1024;

/// Taille du buffer uniforme d'un calque : `LayerCB` entier (176 octets), le `struct Layer` de
/// `layer.wgsl`. `blur.wgsl` n'en lit que les 128 premiers.
const LAYER_BYTES: u64 = std::mem::size_of::<LayerCB>() as u64;

/// `&LayerCB` -> ses octets. `LayerCB` est `#[repr(C, align(16))]`, son layout EST le buffer
/// uniforme WGSL (dix vec4 et un vec2 + 2 f32 = 176 octets).
fn layer_bytes(cb: &LayerCB) -> &[u8] {
    unsafe { std::slice::from_raw_parts(cb as *const LayerCB as *const u8, LAYER_BYTES as usize) }
}

/// Le maillage de Prism Glow tel que le lit le WGSL (`PrismMesh`) : les triangles, les
/// polygones, un point par vec4 (le pas d'un tableau uniform), puis les boîtes.
fn prism_mesh_bytes() -> Vec<u8> {
    use crate::prism_mesh::{BOXES, POLYS, TRIS};
    let points = POLYS.iter().map(|&[x, y]| [x, y, 0.0, 0.0]);
    TRIS.iter().copied().chain(points).chain(BOXES).flatten().flat_map(f32::to_ne_bytes).collect()
}

/// Un calque de fond deja lie, en attente de son `draw`. `_buf`/`_tex`/`_view`
/// ne sont jamais relus : ils gardent en vie ce que le bind group reference
/// jusqu'au submit. Ce backend encode toute la frame avant de la soumettre, la
/// ou D3D11 dessine au fil de l'eau ; d'ou cette boite, la que Windows n'a pas
/// besoin d'equivalent.
///
/// Vit au niveau module (et non dans `compose_frame`) parce que le fond d'ecran
/// ET le fond de la bulle webcam sont desormais construits par les memes
/// methodes.
struct BgDraw {
    layer: LayerBind,
    _tex: Option<wgpu::Texture>,
    _view: Option<wgpu::TextureView>,
}

/// Un calque pret a dessiner : son uniforme (qui doit vivre jusqu'au draw), son bind group, et
/// s'il est l'un des modeles 3D, que seul `pipeline_models` compile (`LayerCB::needs_models`).
/// `draw_layer` en tire le pipeline : c'est le mode du calque qui decide, pas le site d'appel.
struct LayerBind {
    _buf: wgpu::Buffer,
    bind: wgpu::BindGroup,
    models: bool,
}

/// Le fond tel que la passe 1 (et son flou) l'a laisse dans le RT, et tout ce qui l'a decide
/// (`key`, cf. `compose_frame`).
struct BgCache {
    key: crate::frame_geometry::BackgroundKey,
    tex: wgpu::Texture,
}

/// Un effet shader de la scène (`shader_fx`), par hash de sa source.
enum ShaderFx {
    /// Module et pipeline se construisent sur un thread de fond (`spawn_shader_fx`).
    Pending(std::sync::mpsc::Receiver<Result<wgpu::RenderPipeline, String>>),
    Ready(wgpu::RenderPipeline),
    /// Erreur déjà écrite ; l'effet ne se dessine pas.
    Failed,
}

struct ShaderFxEntry {
    state: ShaderFx,
    /// Dernier usage, pour l'éviction (`SHADER_FX_CACHE`).
    used: u64,
}

/// Combien d'effets compilés le compositeur garde. Un agent qui itère en crée un par version.
const SHADER_FX_CACHE: usize = 64;

/// Une copie RT -> staging DEJA SOUMISE, dont le mapping est arme mais pas
/// encore recolte. On garde `idx` (l'index de soumission rendu par
/// `Queue::submit`) pour n'attendre QUE cette soumission-la, et les dimensions
/// telles qu'elles etaient au moment de la copie -- ce sont elles qui decrivent
/// le contenu du buffer, pas celles du compositeur au moment de la recolte.
struct PendingCopy {
    buf: wgpu::Buffer,
    idx: wgpu::SubmissionIndex,
    rx: std::sync::mpsc::Receiver<Result<(), wgpu::BufferAsyncError>>,
    w: u32,
    h: u32,
    bpr: u32,
}

/// Ring de staging de la relecture.
///
/// AVANT : `readback_direct` enregistrait la copie, la soumettait, puis bloquait
/// dans `device.poll(Maintain::Wait)`. Cette attente n'absorbait pas la copie
/// (8,3 Mo = ~0,33 ms de DMA) mais TOUTE la file GPU en cours -- la chaine
/// Kawase et chaque draw de calque, que `compose_frame` avait soumis sans
/// attendre juste avant. Mesure 1080p : 3,8 ms (scene simple) a 6,2 ms (scene
/// chargee) par frame, pendant que `sws_scale` + `avcodec_send_frame` (12,6 ms
/// de CPU pur) attendaient leur tour. Le GPU et le CPU ne se recouvraient
/// jamais.
///
/// MAINTENANT : `readback_submit` soumet la copie de la frame N vers un buffer
/// libre, arme son `map_async` et rend la main ; il ne recolte que la frame la
/// plus ANCIENNE encore en vol. Avec `depth = 2`, c'est la frame N-1, dont la
/// copie a ete soumise avant l'encodage de N-1 et le decodage/composition de N :
/// le GPU a eu ~19 ms de CPU pour finir 6 ms de travail, l'attente tombe a zero.
///
/// PROFONDEUR. 2 est le minimum utile et suffit ici : le seul travail a
/// recouvrir est ce que le CPU fait entre deux relectures (sws + encode,
/// 12,6 ms mesures) et il depasse deja largement la chaine GPU (3,8 a 6,2 ms).
/// Une 3e frame n'ajouterait que 8 Mo de memoire mappable et une frame de
/// latence de plus. La profondeur reste parametrable parce que la POLITIQUE
/// differe par chemin (cf. `set_readback_depth`), pas pour empiler les buffers.
///
/// UN SEUL RT. Le RT n'est pas double-bufferise : la copie de la frame N est
/// soumise AVANT les commandes de composition de la frame N+1, sur la meme
/// queue, et wgpu insere la barriere qui va bien. Le GPU lit donc le RT avant
/// de le reecrire, sans que le CPU ait a l'attendre.
struct ReadbackRing {
    depth: usize,
    /// Buffers disponibles (aucune copie en vol, aucun mapping arme).
    free: Vec<wgpu::Buffer>,
    /// Copies soumises, dans l'ordre de soumission (FIFO strict : les frames
    /// sortent dans l'ordre ou elles ont ete composees).
    pending: std::collections::VecDeque<PendingCopy>,
}

/// Cibles et pipelines de la conversion RGBA -> YUV420P sur le GPU.
///
/// Trois cibles R8Unorm plutot qu'une seule : Y est en pleine resolution et U/V
/// en demie (4:2:0), et wgpu ne sait pas ecrire des attachements de tailles
/// differentes dans une meme passe.
/// Disposition de la chrominance. PAS un gout : une consequence de l'encodeur
/// qui va consommer la frame. `libopenh264` n'accepte que du YUV420P planaire
/// (ses `pix_fmts` sont yuv420p/yuvj420p), VAAPI encode depuis du NV12. Le
/// compositeur doit donc savoir produire les deux.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum YuvFormat {
    /// U et V dans deux plans `R8Unorm` separes.
    I420,
    /// U et V entrelaces dans un seul plan `Rg8Unorm`.
    Nv12,
}

/// Les cibles de chrominance, dont la forme depend du format.
enum Chroma {
    Planar {
        _u: wgpu::Texture,
        _v: wgpu::Texture,
        u_view: wgpu::TextureView,
        v_view: wgpu::TextureView,
        pipe_u: wgpu::RenderPipeline,
        pipe_v: wgpu::RenderPipeline,
    },
    Interleaved {
        _uv: wgpu::Texture,
        uv_view: wgpu::TextureView,
        pipe_uv: wgpu::RenderPipeline,
    },
}

struct YuvTargets {
    /// Gardee en vie pour sa vue ; seule la vue sert au rendu.
    _y: wgpu::Texture,
    y_view: wgpu::TextureView,
    chroma: Chroma,
    fmt: YuvFormat,
    bind: wgpu::BindGroup,
    pipe_y: wgpu::RenderPipeline,
    /// Dimensions pour lesquelles tout ceci a ete construit : un resize doit
    /// tout refaire, et comparer ici est moins fragile que de s'en souvenir.
    w: u32,
    h: u32,
    /// `bytes_per_row` alignes a 256. En 1080p, Y passe de 1920 a 2048 et U/V de
    /// 960 a 1024 : contrairement au RGBA (7680 = 30*256, deja aligne), les plans
    /// PORTENT du padding, et le lecteur doit le retirer ligne a ligne.
    bpr_y: u32,
    bpr_uv: u32,
    /// Offsets des plans de chrominance dans le buffer de staging unique.
    /// Alignes a 256 (exigence de `copy_texture_to_buffer`), ce que la taille du
    /// plan Y garantit deja puisque `bpr_y` l'est. En NV12 il n'y a qu'un plan de
    /// chrominance : `off_v` vaut alors `off_u` et ne doit pas etre lu.
    off_u: u64,
    off_v: u64,
    total: u64,
}

// ---------------------------------------------------------------------------
// Segmentation du sujet webcam
// ---------------------------------------------------------------------------

/// Cadence de l'inference. Meme valeur et meme raison que
/// `compositor_windows::SEGMENTATION_HZ` : une silhouette ne bouge pas de facon
/// perceptible en 16 ms, et c'est le seul levier mesure qui divise le cout par
/// deux sans toucher au modele.
const SEGMENTATION_HZ: u32 = 30;

/// Cible RGBA + buffer de staging pour extraire la frame webcam a la resolution
/// du modele. Pendant wgpu de `compositor_windows::SegCapture`.
///
/// La divergence tient au `bpr`. D3D11 rend un row pitch decide par le driver et
/// Metal accepte la largeur nue ; `copy_texture_to_buffer` exige, lui, un
/// `bytes_per_row` multiple de 256. Il est donc padde ICI, a la creation, et
/// depadde a la lecture — exactement ce que `ReadbackRing` fait deja pour le RT.
/// A 256 px de large le padding est nul (1024 est deja aligne), mais rien dans
/// cette structure ne le suppose : c'est `width` qui decide, pas le modele.
struct SegCapture {
    /// Cible de la passe de capture, et source de la copie vers `staging`.
    rt: wgpu::Texture,
    view: wgpu::TextureView,
    /// Buffer de staging REUTILISE d'une capture a l'autre : a 30 Hz, en
    /// reallouer un par tour serait un cout gratuit.
    staging: wgpu::Buffer,
    width: u32,
    height: u32,
    bpr: u32,
}

/// Texture du masque de segmentation, recreee seulement quand la resolution du
/// modele change — c'est-a-dire jamais, en regime etabli.
///
/// La vue vit A COTE de la texture plutot que d'etre recreee par draw :
/// `make_bind` lie le binding 4 sur CHAQUE draw de calque (le layout l'exige, cf.
/// `tex_entry(4)`), donc une vue par draw ferait une dizaine d'allocations par
/// frame pour rien. La texture, elle, reste indispensable : `write_texture`
/// prend une `Texture`, pas une `TextureView`.
struct WebcamMask {
    tex: wgpu::Texture,
    view: wgpu::TextureView,
    width: u32,
    height: u32,
}

/// Pyramide de profondeur de champ (cf. `Compositor::dof_pyramid`). `_tex` garde la
/// texture en vie ; `view` porte tous les niveaux (binding 6 des modes 8 et 18), `mips` un
/// niveau chacune (cible du remplissage puis de `generate_mips`).
struct DofPyramid {
    _tex: wgpu::Texture,
    view: wgpu::TextureView,
    mips: Vec<wgpu::TextureView>,
    width: u32,
    height: u32,
}

pub struct Compositor {
    gpu: Gpu,
    render_w: u32,
    render_h: u32,

    // Pipeline de calque (VS + FS `layer.wgsl`), sampler lineaire, bind group
    // layout (uniform + 2 textures + sampler). Immuables apres `new_sized`.
    // `pipeline` n'a pas les modeles 3D (modes 15 a 17) : ils passent par `pipeline_models`.
    pipeline: wgpu::RenderPipeline,
    /// Meme shader et meme layout que `pipeline`, blend ADDITIF pondere par la
    /// constante de blend. Sert a sommer les copies de la trainee du curseur
    /// dans `accum` ; cf. `blend_add` cote Windows.
    pipeline_add: wgpu::RenderPipeline,
    /// `pipeline` et `pipeline_add` avec les modeles 3D : le curseur modelise, l'impact de son
    /// clic, l'appareil et son ombre, et rien d'autre (cf. `layer_source`, `draw_layer`).
    pipeline_models: wgpu::RenderPipeline,
    pipeline_add_models: wgpu::RenderPipeline,
    /// Copie plein ecran d'`accum` vers le RT en « over » premultiplie
    /// (`blur.wgsl` : `vs_fullscreen` + `fs_copy`). Utilise le layout du blur.
    pipeline_copy: wgpu::RenderPipeline,
    bind_group_layout: wgpu::BindGroupLayout,
    sampler: wgpu::Sampler,
    /// Le maillage de Prism Glow (`prism_mesh.rs`) tel que le lit le WGSL (`PrismMesh`, binding 7).
    prism_mesh: wgpu::Buffer,

    // Chaine de blur Kawase du fond (`blur.wgsl`) : layout dedie (uniform + 1
    // tex + sampler), 2 pipelines (down/up), 3 textures de pyramide (1/2, 1/4,
    // 1/8 de la sortie). Les `TextureView` gardent leurs textures en vie.
    blur_bgl: wgpu::BindGroupLayout,
    blur_down: wgpu::RenderPipeline,
    blur_up: wgpu::RenderPipeline,
    blur_half: wgpu::TextureView,
    blur_qtr: wgpu::TextureView,
    blur_oct: wgpu::TextureView,
    /// Rendu isole de l'ecran cadre (ombre, cadre, metrage, appareil), transparent autour, que
    /// le mode 18 recompose le long de sa trajectoire (`FrameGeometry::screen_trail`). Taille et
    /// format du RT : il est dessine par le meme pipeline.
    trail_view: wgpu::TextureView,

    // Render target offscreen + ring de staging de la relecture (recrees au resize).
    rt: wgpu::Texture,
    rt_view: wgpu::TextureView,
    /// Cible ISOLEE d'accumulation, meme taille et meme format que le RT.
    /// `_accum` garde la texture en vie ; seule la vue est utilisee.
    _accum: wgpu::Texture,
    accum_view: wgpu::TextureView,
    /// `bytes_per_row` padde a 256 (contrainte wgpu de copy_texture_to_buffer).
    readback_bpr: u32,
    /// Ring de buffers de staging (cf. `ReadbackRing`). `RefCell` : les methodes
    /// publiques du compositeur sont `&self`, comme tout le reste de l'etat.
    readback: RefCell<ReadbackRing>,

    /// Conversion RGBA -> Y/U/V sur le GPU, construite a la premiere demande.
    ///
    /// Paresseuse et non dans `new` pour une raison de contrat : la preview
    /// n'en veut pas (elle rend du RGBA a un `<canvas>`) et la payer a chaque
    /// construction de compositeur couterait trois textures et trois pipelines
    /// a tout le monde pour le seul benefice de l'export.
    yuv: RefCell<Option<YuvTargets>>,
    /// Ring de staging DEDIEE aux plans YUV : ses buffers font 3,1 Mo la ou
    /// ceux de `readback` en font 8,3, et melanger les deux tailles dans une
    /// seule ring rendrait la reutilisation dependante de l'ordre des appels.
    readback_yuv: RefCell<ReadbackRing>,

    // Etat pilote par live.rs (interior mutability : les methodes sont `&self`).
    live_params: RefCell<LiveParams>,
    scene: RefCell<Option<Scene>>,
    cursor: RefCell<Option<crate::cursor::CursorTrack>>,
    cursor_time: RefCell<Option<f32>>,
    /// Le métrage dans la dernière image composée, que l'éditeur lit avec elle (`live.rs`).
    footage: std::cell::Cell<Option<crate::frame_geometry::FootageQuad>>,
    timeline_time: RefCell<Option<f32>>,
    /// Temps programme (secondes de sortie) -- cf. `FrameGeometryInput::programme_time`.
    programme_time: RefCell<Option<f32>>,

    /// Rasterizer de texte (annotations mode 11). `None` si l'init cosmic-text
    /// echoue -- le rendu continue sans texte plutot que de tout casser.
    #[allow(dead_code)]
    text_raster: Option<crate::text::TextRasterizer>,

    /// Cache des sprites curseur (PNG RGBA -> texture wgpu), par chemin. Meme
    /// role que `img_cache` cote macOS. Charge une fois, PAS pour la session : l'entree
    /// est evincable des qu'elle sort du jeu actif d'une frame, et un retour dessus la
    /// rechargera -- cf. `cached_image`.
    /// Le quatrieme champ du tuple est le tick d'usage, qui donne l'ordre LRU
    /// -- cf. `cached_image`.
    img_cache: RefCell<std::collections::HashMap<String, (wgpu::Texture, u32, u32, u64)>>,
    /// Compteur d'acces de `img_cache`, pour l'ordre LRU. Un compteur plutot
    /// que l'index de frame : une frame touche plusieurs entrees, et il faut
    /// pouvoir les ordonner entre elles.
    img_tick: std::cell::Cell<u64>,
    /// Valeur de `img_tick` au debut de la frame en cours. Tout ce qui a ete
    /// touche depuis appartient au jeu actif et ne peut pas etre evince -- voir
    /// `cached_image`.
    img_frame_start: std::cell::Cell<u64>,
    /// Le dernier fond fixe compose. Un fond qui ne bouge pas est le meme a chaque frame : on le
    /// recopie au lieu de le redessiner (passe 1 de `compose_frame`).
    bg_cache: RefCell<Option<BgCache>>,
    /// Champs de distance des sprites de curseur (mode 15), R16F, par chemin, avec leur forme.
    /// Pas d'eviction : seuls les sprites du theme en cours y passent (~2,6 Mo pour les seize).
    sdf_cache: RefCell<std::collections::HashMap<String, (wgpu::Texture, SpriteShape)>>,

    /// Copie mipmappee de la frame composee, lue par les annotations « flou »
    /// (mode 10). `ann_copy` garde la texture en vie, `ann_copy_view` porte tous
    /// les niveaux (echantillonnage), `ann_copy_mips` un niveau chacune (cibles
    /// de la generation). Cf. `make_ann_copy`.
    ann_copy: wgpu::Texture,
    ann_copy_view: wgpu::TextureView,
    ann_copy_mips: Vec<wgpu::TextureView>,

    /// Pyramide de profondeur de champ (mode 8) : la video en RGBA8 a demi-resolution
    /// de la texture DECODEUR, mips compris (texture, vue tous niveaux, vue par niveau),
    /// et sa taille de niveau 0. Allouee au premier ecran incline, recreee quand la
    /// texture decodeur change de taille. Cf. `compositor_windows::RgbaTarget`.
    dof_pyramid: RefCell<Option<DofPyramid>>,
    /// L'enregistrement a sa resolution, pour les effets qui lisent `footage()` (taille, texture,
    /// vue) : alloue au premier d'entre eux, recree quand la coupe change de taille, peint
    /// seulement aux frames ou un tel effet est actif. Cf. `compositor_windows::fill_footage_copy`.
    footage_copy: RefCell<Option<(u32, u32, wgpu::Texture, wgpu::TextureView)>>,

    /// Images d'annotation, indexees par ID d'annotation -- PAS par chemin comme
    /// `img_cache`. Une annotation image porte souvent une data-URI de plusieurs
    /// mega-octets ; s'en servir comme cle de HashMap la ferait hacher a chaque
    /// frame. La longueur de la source sert de temoin de changement, comme cote
    /// macOS.
    ann_img_cache: RefCell<std::collections::HashMap<String, (wgpu::Texture, u32, u32, usize)>>,

    // --- Segmentation du sujet webcam (cf. `pump_segmentation`) ---
    /// Masque du sujet, R8 a la resolution du modele. Ecrit par
    /// `set_webcam_mask`, lu par `make_bind` au moment de construire chaque bind
    /// group. `None` tant qu'aucune frame n'a ete segmentee — l'effet reste
    /// alors eteint plutot que de rendre une webcam invisible en detourage.
    webcam_mask: RefCell<Option<WebcamMask>>,
    /// Cible + staging de la capture, crees a la premiere capture et jamais
    /// redimensionnes : le modele a une entree fixe.
    seg_capture: RefCell<Option<SegCapture>>,
    /// Worker d'inference, absent tant que `enable_segmentation` n'a pas ete
    /// appele.
    seg_worker: RefCell<Option<crate::segmentation::SegmentationWorker>>,
    /// Segmenteur tenu SUR LE THREAD DE RENDU, utilise a la place du worker en
    /// mode deterministe. Voir `set_segmentation_deterministic`.
    seg_sync: RefCell<Option<crate::segmentation::Segmenter>>,
    /// Export : cadence par frame et inference synchrone, au lieu de l'horloge
    /// et du worker.
    seg_deterministic: std::cell::Cell<bool>,
    /// Boite aux lettres du worker. Le masque est depose depuis le thread
    /// d'inference et televerse depuis le thread de rendu : aucun appel wgpu ne
    /// traverse de thread, ce qui compte ici puisque `Compositor` n'est ni `Send`
    /// ni `Sync` (tout son etat vit dans des `RefCell`).
    seg_inbox: std::sync::Arc<std::sync::Mutex<Option<Vec<u8>>>>,
    seg_rate: RefCell<crate::segmentation::RateLimiter>,
    /// Frame RGB reutilisee d'une capture a l'autre.
    seg_scratch: RefCell<Vec<u8>>,
    /// Le chargement du modele a echoue : ne pas reessayer a chaque frame.
    seg_failed: RefCell<bool>,

    /// Layout des effets shader : les quatre bindings du prélude (`shader_fx::PRELUDE_V1`).
    shader_fx_bgl: wgpu::BindGroupLayout,
    shader_fx_layout: wgpu::PipelineLayout,
    /// Effets shader de la scène, compilés une fois par source, les moins récents évincés au-delà
    /// de `SHADER_FX_CACHE`.
    shader_fx: RefCell<std::collections::HashMap<u64, ShaderFxEntry>>,
    shader_fx_tick: std::cell::Cell<u64>,
    /// Vrai par défaut : une frame dont l'effet compile encore attend son pipeline, parce qu'un
    /// export ne doit jamais rendre de frame sans l'effet. La preview le passe à faux et saute
    /// l'effet le temps de la compilation, puis recompose (`shader_fx_landed`).
    shader_fx_blocking: std::cell::Cell<bool>,
    /// Le calque transparent des textes, alloué à la première frame qui porte un effet `text`.
    text_layer: RefCell<Option<(wgpu::Texture, wgpu::TextureView)>>,
}

impl Compositor {
    pub fn new(gpu: &Gpu) -> Result<Compositor> {
        Self::new_sized(gpu, OUT_W, OUT_H)
    }

    pub fn new_sized(gpu: &Gpu, w: u32, h: u32) -> Result<Compositor> {
        let (w, h) = Self::normalize_render_size(w, h);
        let gpu = Gpu {
            device: gpu.device.clone(),
            context: gpu.context.clone(),
            backend: gpu.backend,
            feature_level: gpu.feature_level,
        };

        let mk_module = |label: &str, models: bool| {
            gpu.device.create_shader_module(wgpu::ShaderModuleDescriptor {
                label: Some(label),
                source: wgpu::ShaderSource::Wgsl(layer_source(models).into()),
            })
        };
        let module = mk_module("layer.wgsl", false);
        let module_models = mk_module("layer.wgsl (modeles)", true);
        let sampler = gpu.device.create_sampler(&wgpu::SamplerDescriptor {
            label: Some("layer"),
            address_mode_u: wgpu::AddressMode::ClampToEdge,
            address_mode_v: wgpu::AddressMode::ClampToEdge,
            address_mode_w: wgpu::AddressMode::ClampToEdge,
            mag_filter: wgpu::FilterMode::Linear,
            min_filter: wgpu::FilterMode::Linear,
            // Trilineaire pour le LOD fractionnaire du mode 10 : `log2(rayon)`
            // tombe entre deux niveaux, et en `Nearest` le flou avancerait par
            // paliers visibles quand le rayon varie. Sans effet sur tout le
            // reste -- aucune autre texture liee ici n'a plus d'un niveau.
            mipmap_filter: wgpu::FilterMode::Linear,
            ..Default::default()
        });
        let tex_entry = |binding: u32| wgpu::BindGroupLayoutEntry {
            binding,
            visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
            ty: wgpu::BindingType::Texture {
                sample_type: wgpu::TextureSampleType::Float { filterable: true },
                view_dimension: wgpu::TextureViewDimension::D2,
                multisampled: false,
            },
            count: None,
        };
        let bind_group_layout =
            gpu.device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                label: Some("layer"),
                entries: &[
                    wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Uniform,
                            has_dynamic_offset: false,
                            min_binding_size: wgpu::BufferSize::new(LAYER_BYTES),
                        },
                        count: None,
                    },
                    tex_entry(1),
                    tex_entry(2),
                    wgpu::BindGroupLayoutEntry {
                        binding: 3,
                        visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                        count: None,
                    },
                    // Masque de segmentation du sujet webcam. TOUJOURS declare, meme sans
                    // masque : wgpu valide le bind group contre le layout, donc une entree
                    // absente ferait echouer chaque draw et pas seulement ceux qui l'utilisent.
                    // `dummy_view()` est lie a la place, et la branche du shader n'est de
                    // toute facon prise que si fx.z > 0.5.
                    tex_entry(4),
                    // Plan V. En 5 et pas en 3 : les bindings 0-4 etaient deja
                    // pris quand le chroma est passe d'un plan entrelace a deux
                    // plans, et renumeroter aurait touche tous les bind groups
                    // pour un gain nul.
                    tex_entry(5),
                    // Pyramide de profondeur de champ (modes 8 et 18), `dummy` ailleurs : le
                    // mode 18 lit a la fois le metrage, son rendu isole (binding 4) et elle.
                    tex_entry(6),
                    // Le maillage de Prism Glow (mode 15). Un uniform et non des tables dans le
                    // shader : lavapipe les recopiait a chaque pixel de chaque calque, et une
                    // frame sans curseur se rendait 3,4 fois plus lentement.
                    wgpu::BindGroupLayoutEntry {
                        binding: 7,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Uniform,
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    },
                ],
            });
        let prism_mesh = gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("prism-mesh"),
            contents: &prism_mesh_bytes(),
            usage: wgpu::BufferUsages::UNIFORM,
        });
        let pipeline_layout = gpu.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("layer"),
            bind_group_layouts: &[&bind_group_layout],
            push_constant_ranges: &[],
        });
        // Deux pipelines par source de calque : seul le blend change.
        let mk_layer = |label: &str, module: &wgpu::ShaderModule, blend: wgpu::BlendState| {
            gpu.device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                label: Some(label),
                layout: Some(&pipeline_layout),
                vertex: wgpu::VertexState {
                    module,
                    entry_point: Some("vs_main"),
                    compilation_options: wgpu::PipelineCompilationOptions::default(),
                    buffers: &[],
                },
                fragment: Some(wgpu::FragmentState {
                    module,
                    entry_point: Some("fs_main"),
                    compilation_options: wgpu::PipelineCompilationOptions::default(),
                    targets: &[Some(wgpu::ColorTargetState {
                        format: wgpu::TextureFormat::Rgba8Unorm,
                        blend: Some(blend),
                        write_mask: wgpu::ColorWrites::ALL,
                    })],
                }),
                primitive: wgpu::PrimitiveState {
                    topology: wgpu::PrimitiveTopology::TriangleStrip,
                    ..Default::default()
                },
                depth_stencil: None,
                multisample: wgpu::MultisampleState::default(),
                multiview: None,
                cache: None,
            })
        };
        let over = wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING;
        let pipeline = mk_layer("layer", &module, over);
        let pipeline_models = mk_layer("layer-models", &module_models, over);
        // SOMME pondere : `src * constante + dst`. La constante (posee par pass
        // via `set_blend_constant`) vaut 1/taps, donc N copies d'un curseur
        // parfaitement immobile redonnent exactement ce curseur. Transcription
        // du `blend_add` D3D11 (BLEND_FACTOR / ONE / OP_ADD sur couleur ET
        // alpha) ; l'alpha doit suivre la couleur, sinon la somme n'est plus
        // premultipliee et la composition finale delave la trainee.
        let sum = wgpu::BlendComponent {
            src_factor: wgpu::BlendFactor::Constant,
            dst_factor: wgpu::BlendFactor::One,
            operation: wgpu::BlendOperation::Add,
        };
        let add = wgpu::BlendState { color: sum, alpha: sum };
        let pipeline_add = mk_layer("layer-add", &module, add);
        let pipeline_add_models = mk_layer("layer-add-models", &module_models, add);

        // --- Chaine de blur Kawase du fond (`blur.wgsl`) ---
        let blur_module = gpu.device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("blur.wgsl"),
            source: wgpu::ShaderSource::Wgsl(BLUR_WGSL.into()),
        });
        // Layout blur : 0 = uniform, 1 = texture, 2 = sampler (blur.wgsl).
        let blur_bgl = gpu.device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("blur"),
            entries: &[
                wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: wgpu::BufferSize::new(128),
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 1,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Texture {
                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
                        view_dimension: wgpu::TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 2,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                    count: None,
                },
            ],
        });
        let blur_pl = gpu.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("blur"),
            bind_group_layouts: &[&blur_bgl],
            push_constant_ranges: &[],
        });
        let mk_blur = |entry: &str| {
            gpu.device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                label: Some(entry),
                layout: Some(&blur_pl),
                vertex: wgpu::VertexState {
                    module: &blur_module,
                    entry_point: Some("vs_main"),
                    compilation_options: wgpu::PipelineCompilationOptions::default(),
                    buffers: &[],
                },
                fragment: Some(wgpu::FragmentState {
                    module: &blur_module,
                    entry_point: Some(entry),
                    compilation_options: wgpu::PipelineCompilationOptions::default(),
                    targets: &[Some(wgpu::ColorTargetState {
                        format: wgpu::TextureFormat::Rgba8Unorm,
                        blend: None,
                        write_mask: wgpu::ColorWrites::ALL,
                    })],
                }),
                primitive: wgpu::PrimitiveState {
                    topology: wgpu::PrimitiveTopology::TriangleList,
                    ..Default::default()
                },
                depth_stencil: None,
                multisample: wgpu::MultisampleState::default(),
                multiview: None,
                cache: None,
            })
        };
        let blur_down = mk_blur("fs_kawase_down");
        let blur_up = mk_blur("fs_kawase_up");
        // Composition d'`accum` sur le RT : meme layout que le blur (uniform +
        // 1 texture + sampler) et blend « over » premultiplie. Son VS est
        // `vs_fullscreen` et non le `vs_main` du Kawase -- une passe UNIQUE ne
        // pardonne pas une erreur d'orientation, cf. le commentaire la-bas.
        let pipeline_copy = gpu.device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("accum-copy"),
            layout: Some(&blur_pl),
            vertex: wgpu::VertexState {
                module: &blur_module,
                entry_point: Some("vs_fullscreen"),
                compilation_options: wgpu::PipelineCompilationOptions::default(),
                buffers: &[],
            },
            fragment: Some(wgpu::FragmentState {
                module: &blur_module,
                entry_point: Some("fs_copy"),
                compilation_options: wgpu::PipelineCompilationOptions::default(),
                targets: &[Some(wgpu::ColorTargetState {
                    format: wgpu::TextureFormat::Rgba8Unorm,
                    blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),
                    write_mask: wgpu::ColorWrites::ALL,
                })],
            }),
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                ..Default::default()
            },
            depth_stencil: None,
            multisample: wgpu::MultisampleState::default(),
            multiview: None,
            cache: None,
        });
        // Effets shader (`shader_fx`) : un layout explicite, celui du prélude. Avec `layout: None`,
        // un effet qui ne lit pas `ctx` perdrait ce binding, et son bind group ne validerait plus.
        let fx_entry = |binding: u32, ty: wgpu::BindingType| wgpu::BindGroupLayoutEntry {
            binding,
            visibility: wgpu::ShaderStages::FRAGMENT,
            ty,
            count: None,
        };
        let fx_uniform = wgpu::BindingType::Buffer {
            ty: wgpu::BufferBindingType::Uniform,
            has_dynamic_offset: false,
            min_binding_size: None,
        };
        let shader_fx_bgl = gpu.device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("shader-fx"),
            entries: &[
                fx_entry(
                    0,
                    wgpu::BindingType::Texture {
                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
                        view_dimension: wgpu::TextureViewDimension::D2,
                        multisampled: false,
                    },
                ),
                fx_entry(1, wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering)),
                fx_entry(2, fx_uniform),
                fx_entry(3, fx_uniform),
                fx_entry(
                    4,
                    wgpu::BindingType::Texture {
                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
                        view_dimension: wgpu::TextureViewDimension::D2,
                        multisampled: false,
                    },
                ),
            ],
        });
        let shader_fx_layout = gpu.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("shader-fx"),
            bind_group_layouts: &[&shader_fx_bgl],
            push_constant_ranges: &[],
        });
        let (blur_half, blur_qtr, blur_oct, trail_view) = Self::make_blur_targets(&gpu, w, h);
        let (rt, rt_view, accum, accum_view, readback_bpr) = Self::make_targets(&gpu, w, h);
        let (ann_copy, ann_copy_view, ann_copy_mips) = Self::make_ann_copy(&gpu, w, h);
        // Profondeur 1 par defaut = chemin synchrone historique, a l'octet et a
        // la latence pres. C'est l'export qui demande explicitement 2 (cf.
        // `set_readback_depth`) ; tout autre appelant garde l'ancien contrat.
        let readback = RefCell::new(ReadbackRing {
            depth: 1,
            free: vec![Self::make_staging(&gpu, readback_bpr, h)],
            pending: std::collections::VecDeque::new(),
        });
        // Vide : les buffers YUV sont dimensionnes par `YuvTargets` (qui connait
        // les trois `bytes_per_row` alignes) et alloues a la premiere relecture.
        let readback_yuv = RefCell::new(ReadbackRing {
            depth: 1,
            free: Vec::new(),
            pending: std::collections::VecDeque::new(),
        });

        Ok(Compositor {
            gpu,
            render_w: w,
            render_h: h,
            pipeline,
            pipeline_add,
            pipeline_models,
            pipeline_add_models,
            pipeline_copy,
            bind_group_layout,
            sampler,
            prism_mesh,
            blur_bgl,
            blur_down,
            blur_up,
            blur_half,
            blur_qtr,
            blur_oct,
            trail_view,
            rt,
            rt_view,
            _accum: accum,
            accum_view,
            readback_bpr,
            readback,
            yuv: RefCell::new(None),
            readback_yuv,
            live_params: RefCell::new(LiveParams::default()),
            scene: RefCell::new(None),
            cursor: RefCell::new(None),
            cursor_time: RefCell::new(None),
            footage: std::cell::Cell::new(None),
            timeline_time: RefCell::new(None),
            programme_time: RefCell::new(None),
            text_raster: crate::text::TextRasterizer::new().ok(),
            img_cache: RefCell::new(std::collections::HashMap::new()),
            sdf_cache: RefCell::new(std::collections::HashMap::new()),
            img_tick: std::cell::Cell::new(0),
            img_frame_start: std::cell::Cell::new(0),
            bg_cache: RefCell::new(None),
            ann_copy,
            ann_copy_view,
            ann_copy_mips,
            dof_pyramid: RefCell::new(None),
            footage_copy: RefCell::new(None),
            ann_img_cache: RefCell::new(std::collections::HashMap::new()),
            webcam_mask: RefCell::new(None),
            seg_capture: RefCell::new(None),
            seg_worker: RefCell::new(None),
            seg_sync: RefCell::new(None),
            seg_deterministic: std::cell::Cell::new(false),
            seg_inbox: std::sync::Arc::new(std::sync::Mutex::new(None)),
            seg_rate: RefCell::new(crate::segmentation::RateLimiter::new(SEGMENTATION_HZ)),
            seg_scratch: RefCell::new(Vec::new()),
            seg_failed: RefCell::new(false),
            shader_fx_bgl,
            shader_fx_layout,
            shader_fx: RefCell::new(std::collections::HashMap::new()),
            shader_fx_tick: std::cell::Cell::new(0),
            shader_fx_blocking: std::cell::Cell::new(true),
            text_layer: RefCell::new(None),
        })
    }

    /// Le meme compositeur, rasterisant a `w`x`h` : seules les cibles qui ont la taille du
    /// rendu sont reallouees. Cf. `compositor_windows::Compositor::resized`. Ici, reconstruire
    /// le compositeur entier refaisait en plus tous les shaders et pipelines wgpu.
    ///
    /// Les rings de relecture repartent vides a leur profondeur : leurs buffers ont l'ancienne
    /// taille, comme les cibles YUV, reconstruites a la premiere demande. Une copie encore en
    /// vol est perdue, comme avec la reconstruction ; la preview n'en laisse aucune
    /// (`readback_direct` draine).
    pub fn resized(self, w: u32, h: u32) -> Result<Compositor> {
        let (w, h) = Self::normalize_render_size(w, h);
        let gpu = &self.gpu;
        let (blur_half, blur_qtr, blur_oct, trail_view) = Self::make_blur_targets(gpu, w, h);
        let (rt, rt_view, accum, accum_view, readback_bpr) = Self::make_targets(gpu, w, h);
        let (ann_copy, ann_copy_view, ann_copy_mips) = Self::make_ann_copy(gpu, w, h);
        let depth = self.readback.borrow().depth;
        let readback = RefCell::new(ReadbackRing {
            depth,
            free: (0..depth).map(|_| Self::make_staging(gpu, readback_bpr, h)).collect(),
            pending: std::collections::VecDeque::new(),
        });
        let readback_yuv = RefCell::new(ReadbackRing {
            depth: self.readback_yuv.borrow().depth,
            free: Vec::new(),
            pending: std::collections::VecDeque::new(),
        });
        Ok(Compositor {
            render_w: w,
            render_h: h,
            blur_half,
            blur_qtr,
            blur_oct,
            trail_view,
            rt,
            rt_view,
            _accum: accum,
            accum_view,
            readback_bpr,
            readback,
            yuv: RefCell::new(None),
            readback_yuv,
            ann_copy,
            ann_copy_view,
            ann_copy_mips,
            bg_cache: RefCell::new(None),
            text_layer: RefCell::new(None),
            ..self
        })
    }

    /// Pyramide du blur Kawase du fond (1/2, 1/4, 1/8 du rendu) et cible de la
    /// trainee de l'ecran (pleine taille), dans cet ordre.
    fn make_blur_targets(
        gpu: &Gpu,
        w: u32,
        h: u32,
    ) -> (wgpu::TextureView, wgpu::TextureView, wgpu::TextureView, wgpu::TextureView) {
        let mk = |dw: u32, dh: u32, label: &str| {
            gpu.device
                .create_texture(&wgpu::TextureDescriptor {
                    label: Some(label),
                    size: wgpu::Extent3d {
                        width: dw.max(1),
                        height: dh.max(1),
                        depth_or_array_layers: 1,
                    },
                    mip_level_count: 1,
                    sample_count: 1,
                    dimension: wgpu::TextureDimension::D2,
                    format: wgpu::TextureFormat::Rgba8Unorm,
                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
                        | wgpu::TextureUsages::TEXTURE_BINDING,
                    view_formats: &[],
                })
                .create_view(&wgpu::TextureViewDescriptor::default())
        };
        (
            mk(w / 2, h / 2, "blur-half"),
            mk(w / 4, h / 4, "blur-qtr"),
            mk(w / 8, h / 8, "blur-oct"),
            mk(w, h, "screen-trail"),
        )
    }

    /// RT RGBA8, cible d'accumulation de meme geometrie, et `bytes_per_row` de
    /// la relecture (padde a 256).
    ///
    /// `accum` est alloue ICI et pas ailleurs pour qu'il soit impossible de le
    /// laisser a l'ancienne taille apres un changement de resolution : c'est le
    /// meme appel qui produit les deux, et un accum plus petit que le RT ferait
    /// une passe de composition tronquee.
    fn make_targets(
        gpu: &Gpu,
        w: u32,
        h: u32,
    ) -> (wgpu::Texture, wgpu::TextureView, wgpu::Texture, wgpu::TextureView, u32) {
        let mk = |label: &str, extra: wgpu::TextureUsages| {
            gpu.device.create_texture(&wgpu::TextureDescriptor {
                label: Some(label),
                size: wgpu::Extent3d {
                    width: w,
                    height: h,
                    depth_or_array_layers: 1,
                },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: wgpu::TextureFormat::Rgba8Unorm,
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT
                    | wgpu::TextureUsages::TEXTURE_BINDING
                    | extra,
                view_formats: &[],
            })
        };
        // COPY_DST : le fond fixe y est recopie (`bg_cache`).
        let rt = mk("rt", wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST);
        let accum = mk("accum", wgpu::TextureUsages::empty());
        let rt_view = rt.create_view(&wgpu::TextureViewDescriptor::default());
        let accum_view = accum.create_view(&wgpu::TextureViewDescriptor::default());
        let bpr = (w * 4).div_ceil(256) * 256;
        (rt, rt_view, accum, accum_view, bpr)
    }

    /// Copie du RT avec chaine de mips COMPLETE, source des annotations « flou ».
    ///
    /// Le mode 10 lit un niveau de mip choisi par `log2(rayon)` : c'est la
    /// pyramide qui FAIT le flou, pas un noyau de taps (cf. le commentaire du
    /// shader). Il lui faut donc tous les niveaux jusqu'a 1x1, sinon un grand
    /// rayon demande un LOD qui n'existe pas et le sampler retombe sur le dernier
    /// disponible -- le flou plafonne en silence.
    ///
    /// Retourne aussi une vue PAR NIVEAU : `generate_ann_mips` rend le niveau i
    /// depuis le niveau i-1, et une vue de render target ne peut porter qu'un
    /// seul niveau.
    fn make_ann_copy(
        gpu: &Gpu,
        w: u32,
        h: u32,
    ) -> (wgpu::Texture, wgpu::TextureView, Vec<wgpu::TextureView>) {
        // floor(log2(max)) + 1 : le dernier niveau mesure 1x1.
        let levels = 32 - w.max(h).max(1).leading_zeros();
        Self::make_mip_chain(gpu, "ann-copy", w, h, levels)
    }

    /// Texture RGBA8 a `levels` niveaux : la texture, une vue sur tous les niveaux
    /// (echantillonnage) et une vue PAR niveau (cibles de `generate_mips`). Partagee
    /// par `ann_copy` et la pyramide de profondeur de champ.
    fn make_mip_chain(
        gpu: &Gpu,
        label: &str,
        w: u32,
        h: u32,
        levels: u32,
    ) -> (wgpu::Texture, wgpu::TextureView, Vec<wgpu::TextureView>) {
        let tex = gpu.device.create_texture(&wgpu::TextureDescriptor {
            label: Some(label),
            size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
            mip_level_count: levels,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba8Unorm,
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT
                | wgpu::TextureUsages::TEXTURE_BINDING
                | wgpu::TextureUsages::COPY_DST,
            view_formats: &[],
        });
        let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
        let mips = (0..levels)
            .map(|level| {
                tex.create_view(&wgpu::TextureViewDescriptor {
                    label: Some("mip-level"),
                    base_mip_level: level,
                    mip_level_count: Some(1),
                    ..Default::default()
                })
            })
            .collect();
        (tex, view, mips)
    }

    /// Fige la frame composee dans `ann_copy` et remplit sa pyramide.
    ///
    /// UNE seule fois par frame, AVANT toute annotation : les flous doivent voir
    /// l'image composee SANS les flous eux-memes, sinon deux zones qui se
    /// recouvrent s'echantillonnent l'une l'autre selon l'ordre de dessin. Meme
    /// contrat que le `blit` + `generate_mipmaps` de `compositor_macos`.
    ///
    fn generate_ann_mips(&self, encoder: &mut wgpu::CommandEncoder) {
        encoder.copy_texture_to_texture(
            self.rt.as_image_copy(),
            self.ann_copy.as_image_copy(),
            wgpu::Extent3d {
                width: self.render_w,
                height: self.render_h,
                depth_or_array_layers: 1,
            },
        );
        self.generate_mips(encoder, &self.ann_copy_mips);
    }

    /// Alloue (ou realloue a la taille de la texture decodeur) la pyramide de profondeur
    /// de champ : demi-resolution, `dof_pyramid_levels` niveaux. Ses UV sont ceux des
    /// plans video, le calcul d'UV du mode 8 ne change donc pas.
    fn ensure_dof_pyramid(&self, tex_w: u32, tex_h: u32) {
        let (w, h) = (tex_w.div_ceil(2).max(1), tex_h.div_ceil(2).max(1));
        let stale =
            self.dof_pyramid.borrow().as_ref().is_none_or(|p| (p.width, p.height) != (w, h));
        if stale {
            let levels = crate::frame_geometry::dof_pyramid_levels(w, h);
            let (tex, view, mips) = Self::make_mip_chain(&self.gpu, "dof-pyramid", w, h, levels);
            *self.dof_pyramid.borrow_mut() =
                Some(DofPyramid { _tex: tex, view, mips, width: w, height: h });
        }
    }

    /// Remplit les niveaux 1.. de `mips` depuis le niveau 0 (une vue par niveau).
    ///
    /// wgpu n'a pas de `generate_mipmaps` : chaque niveau est une passe de rendu
    /// plein ecran qui echantillonne le precedent. Le filtre lineaire sur une
    /// source exactement deux fois plus grande EST la moyenne 2x2, donc cette
    /// boucle produit la meme pyramide que le blit Metal.
    fn generate_mips(&self, encoder: &mut wgpu::CommandEncoder, mips: &[wgpu::TextureView]) {
        // Les bind groups doivent survivre a leur passe : on les garde tous ici.
        let mut keep: Vec<(wgpu::Buffer, wgpu::BindGroup)> = Vec::new();
        for level in 1..mips.len() {
            let uniform = self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                label: Some("ann-mip-uniform"),
                // `fs_copy` ne lit pas l'uniforme, mais le layout du blur l'exige.
                contents: layer_bytes(&LayerCB::default()),
                usage: wgpu::BufferUsages::UNIFORM,
            });
            let bind = self.gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
                label: Some("ann-mip"),
                layout: &self.blur_bgl,
                entries: &[
                    wgpu::BindGroupEntry { binding: 0, resource: uniform.as_entire_binding() },
                    wgpu::BindGroupEntry {
                        binding: 1,
                        resource: wgpu::BindingResource::TextureView(&mips[level - 1]),
                    },
                    wgpu::BindGroupEntry {
                        binding: 2,
                        resource: wgpu::BindingResource::Sampler(&self.sampler),
                    },
                ],
            });
            keep.push((uniform, bind));
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("ann-mip-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &mips[level],
                    resolve_target: None,
                    ops: wgpu::Operations {
                        // Clear plutot que Load : le niveau n'a jamais ete ecrit,
                        // et `pipeline_copy` blende « over ». Sur une cible vidée
                        // le « over » rend la source telle quelle -- l'ecrasement
                        // qu'on veut ici.
                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline_copy);
            rpass.set_bind_group(0, &keep[keep.len() - 1].1, &[]);
            rpass.draw(0..3, 0..1);
        }
    }

    /// Un buffer de staging de la ring. La taille depend de `bpr` (donc de la
    /// largeur de rendu) et de la hauteur : changer la geometrie de rendu impose
    /// de les reallouer -- ce que fait `resized`, qui remplace la ring entiere.
    /// L'ancienne est detruite avec ses buffers, wgpu les gardant vivants
    /// jusqu'a la fin des soumissions qui les referencent.
    fn make_staging(gpu: &Gpu, bpr: u32, h: u32) -> wgpu::Buffer {
        gpu.device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("readback"),
            size: u64::from(bpr) * u64::from(h),
            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
            mapped_at_creation: false,
        })
    }

    /// Une passe Kawase : lit `src`, ecrit `dst` (fullscreen triangle, 3
    /// vertices). `src_px` = dimensions de la source (pour le pas de texel).
    fn blur_pass(
        &self,
        encoder: &mut wgpu::CommandEncoder,
        pipeline: &wgpu::RenderPipeline,
        src: &wgpu::TextureView,
        dst: &wgpu::TextureView,
        src_px: [f32; 2],
        off: f32,
    ) {
        let cb = LayerCB {
            mode: -1.0,
            color: [1.0, 1.0, 1.0, 1.0],
            // Convention HLSL/Metal (`compositor_windows::blur_bg`) : texel de la
            // SOURCE en .xy, offset en .z. Parite des trois backends.
            fx: [1.0 / src_px[0], 1.0 / src_px[1], off, 0.0],
            ..Default::default()
        };
        let uniform = self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("blur-uniform"),
            contents: layer_bytes(&cb),
            usage: wgpu::BufferUsages::UNIFORM,
        });
        let bind = self.gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("blur"),
            layout: &self.blur_bgl,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: uniform.as_entire_binding(),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::TextureView(src),
                },
                wgpu::BindGroupEntry {
                    binding: 2,
                    resource: wgpu::BindingResource::Sampler(&self.sampler),
                },
            ],
        });
        let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            label: Some("blur-pass"),
            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                view: dst,
                resolve_target: None,
                ops: wgpu::Operations {
                    load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
                    store: wgpu::StoreOp::Store,
                },
            })],
            depth_stencil_attachment: None,
            timestamp_writes: None,
            occlusion_query_set: None,
        });
        rpass.set_pipeline(pipeline);
        rpass.set_bind_group(0, &bind, &[]);
        rpass.draw(0..3, 0..1);
    }

    /// Floute le RT (le fond deja dessine) : dual-Kawase, `levels` down (RT -> 1/2 ->
    /// 1/4 -> 1/8) puis autant d'up, niveaux et ecart tires de la force
    /// (`background_blur_steps`, partage avec D3D/Metal). ~gaussien a cout borne.
    fn blur_bg(&self, encoder: &mut wgpu::CommandEncoder, amount: f32) {
        let Some((levels, off)) = crate::frame_geometry::background_blur_steps(amount) else {
            return;
        };
        let dims = |d: u32| {
            [(self.render_w / d).max(1) as f32, (self.render_h / d).max(1) as f32]
        };
        let pyramid = [
            (&self.rt_view, dims(1)),
            (&self.blur_half, dims(2)),
            (&self.blur_qtr, dims(4)),
            (&self.blur_oct, dims(8)),
        ];
        for i in 0..levels {
            let (src, src_px) = pyramid[i];
            self.blur_pass(encoder, &self.blur_down, src, pyramid[i + 1].0, src_px, off);
        }
        for i in (0..levels).rev() {
            let (src, src_px) = pyramid[i + 1];
            self.blur_pass(encoder, &self.blur_up, src, pyramid[i].0, src_px, off);
        }
    }

    /// Dimensions paires (NV12 4:2:0), min 2x2. Symetrie avec les autres backends.
    pub fn normalize_render_size(w: u32, h: u32) -> (u32, u32) {
        ((w.max(2) + 1) & !1, (h.max(2) + 1) & !1)
    }

    pub fn render_size(&self) -> (u32, u32) {
        (self.render_w, self.render_h)
    }

    pub fn set_live_params(&self, p: LiveParams) {
        *self.live_params.borrow_mut() = p;
    }

    /// Cf. `compositor_windows::set_has_webcam` — le seul champ de `LiveParams` qui dépend du
    /// clip courant, rebranché par `walk_composited_timeline` sans écraser le reste.
    pub fn set_has_webcam(&self, v: bool) {
        self.live_params.borrow_mut().has_webcam = v;
    }

    pub fn set_scene(&self, s: Option<Scene>) {
        *self.scene.borrow_mut() = s;
        // Les effets nouveaux partent compiler tout de suite, hors du thread de rendu : à la
        // première frame qui les montre, ils sont en général déjà prêts. Après la pose de la
        // scène : l'éviction épargne ce qu'elle montre.
        if let Some(scene) = self.scene.borrow().as_ref() {
            for effect in &scene.shader_effects {
                self.shader_fx_entry(effect);
            }
        }
    }

    /// Faux pour la preview : voir `shader_fx_blocking`.
    pub fn set_shader_fx_blocking(&self, on: bool) {
        self.shader_fx_blocking.set(on);
    }

    /// Fait aboutir les compilations terminées. Vrai si un effet vient d'être prêt : la preview
    /// en pause doit alors recomposer, sinon elle resterait sur la frame sans l'effet.
    pub fn shader_fx_landed(&self) -> bool {
        let mut landed = false;
        for entry in self.shader_fx.borrow_mut().values_mut() {
            let got = match &entry.state {
                ShaderFx::Pending(rx) => rx.try_recv(),
                _ => continue,
            };
            match got {
                Ok(result) => {
                    entry.state = Self::finish_shader_fx(result);
                    landed = true;
                }
                Err(std::sync::mpsc::TryRecvError::Empty) => {}
                Err(std::sync::mpsc::TryRecvError::Disconnected) => entry.state = ShaderFx::Failed,
            }
        }
        landed
    }

    /// La clé de cache d'`effect`, sa compilation lancée s'il est neuf, et son dernier usage noté.
    /// `None` pour un contrat que ce compositeur ne connaît pas : la région ne se dessine pas.
    fn shader_fx_entry(&self, effect: &SceneShaderEffect) -> Option<u64> {
        if effect.contract != crate::shader_fx::CONTRACT {
            return None;
        }
        let key = crate::shader_fx::source_hash(effect);
        let tick = self.shader_fx_tick.get() + 1;
        self.shader_fx_tick.set(tick);
        let mut fx = self.shader_fx.borrow_mut();
        fx.entry(key)
            .or_insert_with(|| ShaderFxEntry {
                state: ShaderFx::Pending(self.spawn_shader_fx(effect)),
                used: tick,
            })
            .used = tick;
        // Un agent qui itère crée une entrée par version : on garde les plus récentes, et toutes
        // celles que la scène montre.
        if fx.len() > SHADER_FX_CACHE {
            let scene = self.scene.borrow();
            let shown = scene.as_ref().map_or(&[][..], |s| &s.shader_effects[..]);
            if let Some(oldest) = crate::shader_fx::eviction_victim(fx.iter().map(|(k, e)| (*k, e.used)), shown) {
                fx.remove(&oldest);
            }
        }
        Some(key)
    }

    /// Construit le pipeline d'`effect` sur un thread de fond : `Device` est `Send + Sync`, et le
    /// pilote compile le SPIR-V dans `create_render_pipeline`. naga valide le code avant wgpu :
    /// aucun `on_uncaptured_error` n'est posé, et une erreur de validation wgpu fait paniquer. Si
    /// wgpu panique malgré tout, seul ce thread meurt, et le canal fermé vaut un échec.
    fn spawn_shader_fx(
        &self,
        effect: &SceneShaderEffect,
    ) -> std::sync::mpsc::Receiver<Result<wgpu::RenderPipeline, String>> {
        let (tx, rx) = std::sync::mpsc::channel();
        let (device, layout) = (self.gpu.device.clone(), self.shader_fx_layout.clone());
        let (code, params) = (effect.code.clone(), effect.params.clone());
        std::thread::Builder::new()
            .name("shader-fx".into())
            .spawn(move || {
                let built = crate::shader_fx::analyze(&code, &params).map(|_| {
                    let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
                        label: Some("shader-fx"),
                        source: wgpu::ShaderSource::Wgsl(
                            crate::shader_fx::module_source(&code, &params).into(),
                        ),
                    });
                    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                        label: Some("shader-fx"),
                        layout: Some(&layout),
                        vertex: wgpu::VertexState {
                            module: &module,
                            entry_point: Some("fx_vs"),
                            compilation_options: wgpu::PipelineCompilationOptions::default(),
                            buffers: &[],
                        },
                        fragment: Some(wgpu::FragmentState {
                            module: &module,
                            entry_point: Some("fx_fs"),
                            compilation_options: wgpu::PipelineCompilationOptions::default(),
                            targets: &[Some(wgpu::ColorTargetState {
                                format: wgpu::TextureFormat::Rgba8Unorm,
                                blend: None,
                                write_mask: wgpu::ColorWrites::ALL,
                            })],
                        }),
                        primitive: wgpu::PrimitiveState::default(),
                        depth_stencil: None,
                        multisample: wgpu::MultisampleState::default(),
                        multiview: None,
                        cache: None,
                    })
                });
                let _ = tx.send(built);
            })
            .expect("thread shader-fx");
        rx
    }

    fn finish_shader_fx(result: Result<wgpu::RenderPipeline, String>) -> ShaderFx {
        match result {
            Ok(pipeline) => ShaderFx::Ready(pipeline),
            Err(e) => {
                eprintln!("[shader-fx] {e}");
                ShaderFx::Failed
            }
        }
    }

    /// Le pipeline d'`effect`. Le compositeur d'export attend sa compilation ; la preview
    /// (`shader_fx_blocking` faux) rend `None` tant qu'il compile. `None` aussi s'il a échoué.
    fn shader_fx_ready(&self, effect: &SceneShaderEffect) -> Option<wgpu::RenderPipeline> {
        let key = self.shader_fx_entry(effect)?;
        let mut fx = self.shader_fx.borrow_mut();
        let entry = fx.get_mut(&key)?;
        if let ShaderFx::Pending(rx) = &entry.state {
            let got = if self.shader_fx_blocking.get() {
                rx.recv().map_err(|e| e.to_string())
            } else {
                match rx.try_recv() {
                    Ok(result) => Ok(result),
                    Err(std::sync::mpsc::TryRecvError::Empty) => return None,
                    Err(e) => Err(e.to_string()),
                }
            };
            entry.state = Self::finish_shader_fx(got.and_then(|result| result));
        }
        match &entry.state {
            ShaderFx::Ready(pipeline) => Some(pipeline.clone()),
            _ => None,
        }
    }

    /// Une passe d'effet sur `dst` (le RT, ou le calque des textes) : `dst` est copié dans le
    /// niveau 0 d'`ann_copy`, libre à ce stade (les flous et le cristal de Prism Glow l'ont déjà
    /// lu, plus tôt dans l'encodeur), puis l'effet le repeint en entier.
    fn encode_shader_effect(
        &self,
        encoder: &mut wgpu::CommandEncoder,
        effect: &SceneShaderEffect,
        dst: (&wgpu::Texture, &wgpu::TextureView),
        ctx: &crate::shader_fx::FxContext,
        footage: Option<&wgpu::TextureView>,
    ) {
        let Some(pipeline) = self.shader_fx_ready(effect) else { return };
        let ctx_bytes = unsafe {
            std::slice::from_raw_parts(
                ctx as *const crate::shader_fx::FxContext as *const u8,
                std::mem::size_of::<crate::shader_fx::FxContext>(),
            )
        };
        let params: Vec<u8> =
            crate::shader_fx::pack_params(effect).iter().flat_map(|v| v.to_ne_bytes()).collect();
        let uniform = |label: &str, contents: &[u8]| {
            self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                label: Some(label),
                contents,
                usage: wgpu::BufferUsages::UNIFORM,
            })
        };
        let (ctx_buf, params_buf) = (uniform("shader-fx-ctx", ctx_bytes), uniform("shader-fx-params", &params));
        // Les bindings du prélude : la frame (0), le sampler (1), `ctx` (2), `params` (3) et
        // `footage()` (4), une texture vide pour un effet qui ne la lit pas.
        let dummy = footage.is_none().then(|| self.dummy_view());
        let footage = footage.or(dummy.as_ref()).expect("une vue ou l'autre");
        let bind = self.gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("shader-fx"),
            layout: &self.shader_fx_bgl,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: wgpu::BindingResource::TextureView(&self.ann_copy_view),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::Sampler(&self.sampler),
                },
                wgpu::BindGroupEntry { binding: 2, resource: ctx_buf.as_entire_binding() },
                wgpu::BindGroupEntry { binding: 3, resource: params_buf.as_entire_binding() },
                wgpu::BindGroupEntry { binding: 4, resource: wgpu::BindingResource::TextureView(footage) },
            ],
        });
        encoder.copy_texture_to_texture(
            dst.0.as_image_copy(),
            self.ann_copy.as_image_copy(),
            wgpu::Extent3d { width: self.render_w, height: self.render_h, depth_or_array_layers: 1 },
        );
        let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            label: Some("shader-fx-pass"),
            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                view: dst.1,
                resolve_target: None,
                ops: wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store },
            })],
            depth_stencil_attachment: None,
            timestamp_writes: None,
            occlusion_query_set: None,
        });
        rpass.set_pipeline(&pipeline);
        rpass.set_bind_group(0, &bind, &[]);
        rpass.draw(0..3, 0..1);
    }

    /// Peint l'enregistrement a sa resolution pour `footage()` (`docs/shader-effects.md`, C.2). Port
    /// de `compositor_windows::fill_footage_copy` : la coupe du metrage (`content_cut`, le repere de
    /// `fx_to_footage`) en UN draw du mode 0, par la meme conversion que l'ecran dessine.
    #[allow(clippy::too_many_arguments)]
    fn encode_footage_copy(
        &self,
        encoder: &mut wgpu::CommandEncoder,
        planes: (&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView),
        cut: [f32; 4],
        tex_w: u32,
        tex_h: u32,
    ) -> wgpu::TextureView {
        let (w, h) = crate::shader_fx::footage_copy_px(cut, [tex_w as f32, tex_h as f32]);
        let stale = self.footage_copy.borrow().as_ref().is_none_or(|c| (c.0, c.1) != (w, h));
        if stale {
            let tex = self.gpu.device.create_texture(&wgpu::TextureDescriptor {
                label: Some("footage-copy"),
                size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: wgpu::TextureFormat::Rgba8Unorm,
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
                view_formats: &[],
            });
            let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
            *self.footage_copy.borrow_mut() = Some((w, h, tex, view));
        }
        let view = self.footage_copy.borrow().as_ref().expect("copie allouee ci-dessus").3.clone();
        let full = [0.0, 0.0, 1.0, 1.0];
        let cb = LayerCB {
            dst: full,
            src: cut,
            quad_px: [w as f32, h as f32],
            mode: 0.0,
            color: [1.0, 1.0, 1.0, 1.0],
            src_prev: cut,
            dst_prev: full,
            mb: [1.0, 0.0, 1.0, 0.0],
            ..Default::default()
        };
        let dummy = self.dummy_view();
        let fill = self.make_bind(&cb, Some(planes), &dummy);
        let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            label: Some("footage-copy-pass"),
            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                view: &view,
                resolve_target: None,
                ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT), store: wgpu::StoreOp::Store },
            })],
            depth_stencil_attachment: None,
            timestamp_writes: None,
            occlusion_query_set: None,
        });
        rpass.set_pipeline(&self.pipeline);
        self.draw_layer(&mut rpass, &fill, false);
        drop(rpass);
        view
    }

    /// Le calque transparent des textes, à la taille de rendu, alloué à la première frame qui en a
    /// besoin (un effet `ShaderEffectTarget::Text`).
    fn text_layer(&self) -> (wgpu::Texture, wgpu::TextureView) {
        if let Some(layer) = self.text_layer.borrow().as_ref() {
            return layer.clone();
        }
        let tex = self.gpu.device.create_texture(&wgpu::TextureDescriptor {
            label: Some("text-layer"),
            size: wgpu::Extent3d { width: self.render_w, height: self.render_h, depth_or_array_layers: 1 },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba8Unorm,
            // COPY_SRC : un effet `text` le copie dans `ann_copy` avant de le repeindre.
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT
                | wgpu::TextureUsages::TEXTURE_BINDING
                | wgpu::TextureUsages::COPY_SRC,
            view_formats: &[],
        });
        let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
        *self.text_layer.borrow_mut() = Some((tex.clone(), view.clone()));
        (tex, view)
    }

    pub fn set_cursor(&self, track: crate::cursor::CursorTrack) {
        *self.cursor.borrow_mut() = Some(track);
    }

    pub fn set_cursor_time(&self, t: Option<f32>) {
        *self.cursor_time.borrow_mut() = t;
    }

    pub fn set_timeline_time(&self, t: Option<f32>) {
        *self.timeline_time.borrow_mut() = t;
    }

    pub fn set_programme_time(&self, t: Option<f32>) {
        *self.programme_time.borrow_mut() = t;
    }

    /// Dernier temps programme reçu : pour que les tests vérifient ce qui atteint vraiment
    /// `FrameGeometryInput`, pas seulement ce que l'appelant croit envoyer.
    #[doc(hidden)]
    pub fn programme_time(&self) -> Option<f32> {
        *self.programme_time.borrow()
    }

    pub fn clear_cursor(&self) {
        *self.cursor.borrow_mut() = None;
    }

    pub fn scene_snapshot(&self) -> Option<Scene> {
        self.scene.borrow().clone()
    }

    /// Pas de cache de SRV cote wgpu (les `TextureView`s sont recreees a chaque
    /// draw depuis le carrier) -- no-op conserve pour la symetrie d'API.
    pub fn clear_srv_cache(&self) {}

    // -- seam frame (lit le carrier `data[0]`) --

    fn pixel_buffer_of(frame: *const AVFrame) -> Option<()> {
        if frame.is_null() || unsafe { (*frame).data[0] }.is_null() {
            None
        } else {
            Some(())
        }
    }

    unsafe fn nv12_srvs(
        &self,
        frame: *const AVFrame,
    ) -> Result<(wgpu::TextureView, wgpu::TextureView, wgpu::TextureView)> {
        crate::linux_frames::nv12_planes(frame)
    }

    unsafe fn tex_dims(&self, frame: *const AVFrame) -> (u32, u32) {
        if frame.is_null() || (*frame).data[0].is_null() {
            return (1, 1);
        }
        crate::linux_frames::carrier_dims(frame)
    }

    // -- rendu --

    /// Prepare un draw de calque : buffer uniforme init a `cb` + bind group
    /// (uniform + deux textures + sampler). Cree AVANT la render pass pour que
    /// les ressources vivent pendant tout le pass. Un buffer PAR draw :
    /// `write_buffer` entre draws d'une meme pass ne s'entrelace pas.
    /// `LayerCB` d'une ombre portee (mode 2), identique a `draw_shadow` cote
    /// macOS et au bloc equivalent cote Windows.
    ///
    /// Le quad est ELARGI de `spread` de chaque cote et decale de `offset_px` ;
    /// le shader y trace un SDF de rect arrondi dont l'alpha decroit sur la
    /// largeur du spread. C'est pour ca que `fx.x` porte le spread : le
    /// fragment en a besoin pour normaliser sa penombre.
    fn shadow_cb(
        &self,
        dst: [f32; 4],
        size_px: [f32; 2],
        radius: f32,
        spread: f32,
        offset_px: [f32; 2],
        opacity: f32,
    ) -> LayerCB {
        let (rw, rh) = (self.render_w as f32, self.render_h as f32);
        let (sx, sy) = (spread / rw, spread / rh);
        let (ox, oy) = (offset_px[0] / rw, offset_px[1] / rh);
        LayerCB {
            dst: [dst[0] - sx + ox, dst[1] - sy + oy, dst[2] + 2.0 * sx, dst[3] + 2.0 * sy],
            quad_px: [size_px[0] + 2.0 * spread, size_px[1] + 2.0 * spread],
            radius_px: radius,
            mode: 2.0,
            color: [0.0, 0.0, 0.0, opacity],
            fx: [spread, 0.0, 0.0, 0.0],
            mb: [0.0, 1.0, 1.0, 0.0],
            ..Default::default()
        }
    }

    /// `LayerCB` de l'ombre d'un ecran INCLINE (mode 12) : la penombre suit le
    /// quadrilatere projete, pas son rect englobant. Port de
    /// `compositor_macos::draw_quad_shadow`.
    #[allow(clippy::too_many_arguments)]
    fn quad_shadow_cb(
        &self,
        corners: &[(f32, f32); 4],
        center_px: [f32; 2],
        radius: f32,
        // Le slot d'un layout en bloc, qui rogne le plan (`shadow_mask_fields`).
        mask: Option<crate::frame_geometry::ScreenMask>,
        spread: f32,
        offset_px: [f32; 2],
        opacity: f32,
    ) -> LayerCB {
        let (rw, rh) = (self.render_w as f32, self.render_h as f32);
        let (min_x, max_x) =
            corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(x, _)| (mn.min(x), mx.max(x)));
        let (min_y, max_y) =
            corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(_, y)| (mn.min(y), mx.max(y)));
        // La boite doit contenir la penombre entiere, sinon elle se coupe net.
        let box_w = (max_x - min_x) + 2.0 * spread;
        let box_h = (max_y - min_y) + 2.0 * spread;
        let local = |(x, y): (f32, f32)| -> [f32; 2] { [x - min_x + spread, y - min_y + spread] };
        let [tl0, tl1] = local(corners[0]);
        let [tr0, tr1] = local(corners[1]);
        let [br0, br1] = local(corners[2]);
        let [bl0, bl1] = local(corners[3]);
        let (mask_rect, mask_radius) = crate::frame_geometry::shadow_mask_fields(
            mask,
            [center_px[0] + min_x - spread, center_px[1] + min_y - spread],
            [rw, rh],
        );
        LayerCB {
            dst: [
                (center_px[0] + min_x - spread + offset_px[0]) / rw,
                (center_px[1] + min_y - spread + offset_px[1]) / rh,
                box_w / rw,
                box_h / rh,
            ],
            quad_px: [box_w, box_h],
            radius_px: radius,
            mode: 12.0,
            color: [0.0, 0.0, 0.0, opacity],
            fx: [tl0, tl1, tr0, tr1],
            src_prev: [br0, br1, bl0, bl1],
            dst_prev: mask_rect,
            // Le spread vit ici et NON dans `fx.x` : `fx` porte deja les coins.
            mb: [0.0, spread, 1.0, mask_radius],
            ..Default::default()
        }
    }

    /// L'ecran cadre, dans son ordre : ombre, cadre de fenetre (sous l'ecran), ecran, appareil
    /// (devant lui). Dans la passe d'avant-plan, ou dans le rendu isole du mode 18.
    fn draw_screen_group(
        &self,
        rpass: &mut wgpu::RenderPass<'_>,
        shadow: &Option<LayerBind>,
        window_frame: &Option<LayerBind>,
        screen: &LayerBind,
        device_frame: &Option<LayerBind>,
    ) {
        for layer in [shadow.as_ref(), window_frame.as_ref(), Some(screen), device_frame.as_ref()]
            .into_iter()
            .flatten()
        {
            self.draw_layer(rpass, layer, false);
        }
    }

    fn make_bind(
        &self,
        cb: &LayerCB,
        planes: Option<(&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView)>,
        dummy: &wgpu::TextureView,
    ) -> LayerBind {
        self.make_bind_b4(cb, planes, dummy, None, None)
    }

    /// `make_bind`, binding 4 impose (le rendu isole du mode 18, a la place du masque webcam
    /// qu'il ne lit pas), et la pyramide de profondeur de champ en binding 6 (modes 8 et 18).
    /// Le mode 15 y met le champ de son sprite et le sprite.
    fn make_bind_b4(
        &self,
        cb: &LayerCB,
        planes: Option<(&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView)>,
        dummy: &wgpu::TextureView,
        b4: Option<&wgpu::TextureView>,
        dof: Option<&wgpu::TextureView>,
    ) -> LayerBind {
        let uniform = self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("layer-uniform"),
            contents: layer_bytes(cb),
            usage: wgpu::BufferUsages::UNIFORM,
        });
        let (y, u, v) = planes.unwrap_or((dummy, dummy, dummy));
        // Le masque est lie sur TOUS les draws, pas seulement celui de la camera.
        // wgpu valide le bind group contre le layout : le binding 4 est declare
        // (`tex_entry(4)`), donc une entree absente ferait echouer CHAQUE draw et
        // pas seulement ceux qui l'echantillonnent. Le lier partout ne coute rien
        // — la branche du shader n'est prise que si `fx.z > 0.5`, et seul le
        // calque webcam leve `fx.z`. `dummy` reste le repli tant qu'aucune frame
        // n'a ete segmentee.
        let mask = self.webcam_mask.borrow();
        let mask_view = b4.unwrap_or_else(|| mask.as_ref().map_or(dummy, |m| &m.view));
        let bind = self.gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("layer"),
            layout: &self.bind_group_layout,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: uniform.as_entire_binding(),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::TextureView(y),
                },
                wgpu::BindGroupEntry {
                    binding: 2,
                    resource: wgpu::BindingResource::TextureView(u),
                },
                wgpu::BindGroupEntry {
                    binding: 3,
                    resource: wgpu::BindingResource::Sampler(&self.sampler),
                },
                wgpu::BindGroupEntry {
                    binding: 4,
                    resource: wgpu::BindingResource::TextureView(mask_view),
                },
                wgpu::BindGroupEntry {
                    binding: 5,
                    resource: wgpu::BindingResource::TextureView(v),
                },
                wgpu::BindGroupEntry {
                    binding: 6,
                    resource: wgpu::BindingResource::TextureView(dof.unwrap_or(dummy)),
                },
                wgpu::BindGroupEntry { binding: 7, resource: self.prism_mesh.as_entire_binding() },
            ],
        });
        LayerBind { _buf: uniform, bind, models: cb.needs_models() }
    }

    /// Dessine un calque par le pipeline plat que l'appelant a lie (`pipeline`, ou `pipeline_add`
    /// si `add`) -- sauf un modele 3D, qui passe le temps de son draw par la variante
    /// « modeles » de ce pipeline, la seule a le compiler (pourquoi : le haut de `layer.wgsl`).
    fn draw_layer(&self, rpass: &mut wgpu::RenderPass<'_>, layer: &LayerBind, add: bool) {
        rpass.set_bind_group(0, &layer.bind, &[]);
        if layer.models {
            let (models, flat) = if add {
                (&self.pipeline_add_models, &self.pipeline_add)
            } else {
                (&self.pipeline_models, &self.pipeline)
            };
            rpass.set_pipeline(models);
            rpass.draw(0..4, 0..1);
            rpass.set_pipeline(flat);
        } else {
            rpass.draw(0..4, 0..1);
        }
    }

    /// Charge un PNG/JPEG (chemin fichier ou data URI) en texture RGBA8. Port
    /// wgpu du `load_image_texture` macOS, memes chemins (`decode_data_uri`
    /// partage, crate `image`). Sert aux sprites de curseur (mode 7).
    fn load_image_texture(&self, path: &str) -> Result<(wgpu::Texture, u32, u32)> {
        let img = if let Some(bytes) = crate::frame_geometry::decode_data_uri(path) {
            image::load_from_memory(&bytes)
                .map_err(|e| anyhow::anyhow!("data URI image ({} octets) : {e}", bytes.len()))?
                .to_rgba8()
        } else {
            image::open(path)
                .map_err(|e| anyhow::anyhow!("sprite {path} : {e}"))?
                .to_rgba8()
        };
        let (w, h) = (img.width(), img.height());
        let pixels = img.into_raw();
        let tex = self.gpu.device.create_texture(&wgpu::TextureDescriptor {
            label: Some("sprite"),
            size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba8Unorm,
            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
            view_formats: &[],
        });
        self.gpu.context.write_texture(
            wgpu::TexelCopyTextureInfo {
                texture: &tex,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            &pixels,
            wgpu::TexelCopyBufferLayout {
                offset: 0,
                bytes_per_row: Some(w * 4),
                rows_per_image: Some(h),
            },
            wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
        );
        Ok((tex, w, h))
    }

    /// Champ de distance du sprite `path` (binding 2 du mode 15) et sa forme, calcules au
    /// premier appel. Parite `compositor_windows::cursor_sdf`.
    fn cursor_sdf(&self, path: &str) -> Result<(wgpu::Texture, SpriteShape)> {
        if let Some(hit) = self.sdf_cache.borrow().get(path) {
            return Ok(hit.clone());
        }
        let sdf = crate::cursor_sdf::CursorSdf::load(path)?;
        let texels = sdf.f16_bytes();
        let size = wgpu::Extent3d { width: sdf.width, height: sdf.height, depth_or_array_layers: 1 };
        let tex = self.gpu.device.create_texture(&wgpu::TextureDescriptor {
            label: Some("cursor-sdf"),
            size,
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::R16Float,
            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
            view_formats: &[],
        });
        self.gpu.context.write_texture(
            wgpu::TexelCopyTextureInfo {
                texture: &tex,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            &texels,
            wgpu::TexelCopyBufferLayout {
                offset: 0,
                bytes_per_row: Some(sdf.width * 2),
                rows_per_image: Some(sdf.height),
            },
            size,
        );
        let entry = (tex, sdf.shape);
        self.sdf_cache.borrow_mut().insert(path.to_string(), entry.clone());
        Ok(entry)
    }

    /// Ouvre une frame du point de vue d'`img_cache` : tout ce qui sera touche
    /// apres cet appel est le jeu actif, et devient inevincable jusqu'a la
    /// frame suivante.
    fn begin_image_frame(&self) {
        // `+ 1` : la premiere entrée de cette frame recevra `img_tick + 1`, et la protection
        // porte sur `tick >= img_frame_start`. Sans le decalage on protégerait aussi la
        // DERNIERE entrée de la frame precedente, qui n'appartient plus au jeu actif — le
        // résident pourrait alors dépasser le budget d'une texture entière.
        self.img_frame_start.set(self.img_tick.get() + 1);
    }

    /// Texture d'un fichier image, decodee une seule fois puis reutilisee.
    ///
    /// Le cache etait NON BORNE, et c'est un vrai cout : les wallpapers livres
    /// pesent 23,7 Mo sur disque mais 1 774 Mo une fois decodes en RGBA8 --
    /// `wallpaper8.jpg` fait 7680x7680, soit 225 Mo a lui seul. Parcourir le
    /// selecteur les chargeait tous et n'en liberait aucun.
    ///
    /// L'eviction est LRU sous un budget en octets, et ne touche jamais une
    /// texture que la frame EN COURS a deja servie : sans ca, un fond d'ecran
    /// et un fond de camera un peu gros se chasseraient l'un l'autre a chaque
    /// frame, et un decodage coute 129 ms contre les ~3,5 ms d'une frame. Si le
    /// jeu actif depasse a lui seul le budget, on depasse le budget.
    fn cached_image(&self, path: &str) -> Result<(wgpu::Texture, u32, u32)> {
        let tick = self.img_tick.get() + 1;
        self.img_tick.set(tick);
        // Recherche isolee dans un `let` pour que l'emprunt immuable soit
        // relache AVANT le `borrow_mut` (piege du double emprunt 1re frame).
        let hit = self.img_cache.borrow().get(path).cloned();
        if let Some((tex, w, h, _)) = hit {
            self.img_cache.borrow_mut().insert(path.to_string(), (tex.clone(), w, h, tick));
            return Ok((tex, w, h));
        }
        let (tex, w, h) = self.load_image_texture(path)?;
        let mut cache = self.img_cache.borrow_mut();
        cache.insert(path.to_string(), (tex.clone(), w, h, tick));
        // La politique vit dans `frame_geometry` : les trois backends la
        // partagent, comme la geometrie, plutot que d'entretenir trois copies
        // qui finiraient par diverger.
        let entries: Vec<(String, u64, u64)> =
            cache.iter().map(|(k, e)| (k.clone(), e.1 as u64 * e.2 as u64 * 4, e.3)).collect();
        let protect_from = self.img_frame_start.get();
        for key in
            crate::frame_geometry::lru_evictions(&entries, IMG_CACHE_BUDGET_BYTES, protect_from)
        {
            cache.remove(&key);
        }
        Ok((tex, w, h))
    }

    /// Calque image (mode 6) couvrant `dst`, en cover-fit contre `aspect` -- le
    /// ratio du RECT vise, et non celui de la sortie : le rognage se calcule
    /// contre la zone qu'on remplit, ce qui permet a la bulle webcam d'emprunter
    /// le chemin du fond d'ecran au lieu d'en refaire un.
    ///
    /// Err plutot qu'un repli maison : chaque appelant a son propre message et
    /// son propre repli, et un echec silencieux redonnerait le noir qu'on corrige.
    ///
    /// `motion` anime l'image au temps programme `programme_t` ; la bulle webcam
    /// passe `WallpaperMotion::None`.
    #[allow(clippy::too_many_arguments)]
    fn image_bg_draw(
        &self,
        path: &str,
        dst: [f32; 4],
        quad_px: [f32; 2],
        radius_px: f32,
        aspect: f32,
        motion: WallpaperMotion,
        programme_t: f32,
        dummy: &wgpu::TextureView,
    ) -> Result<BgDraw> {
        let (tex, iw, ih) = self.cached_image(path)?;
        // Cover-fit : l'image remplit tout le rect, on rogne l'axe long.
        let ai = iw as f32 / ih.max(1) as f32;
        let src = if ai > aspect {
            let vis = aspect / ai;
            [(1.0 - vis) * 0.5, 0.0, 1.0 - (1.0 - vis) * 0.5, 1.0]
        } else {
            let vis = ai / aspect;
            [0.0, (1.0 - vis) * 0.5, 1.0, 1.0 - (1.0 - vis) * 0.5]
        };
        let (anim, mb) = crate::frame_geometry::wallpaper_motion_slots(motion, programme_t, aspect);
        let cb = LayerCB {
            dst,
            src,
            quad_px,
            radius_px,
            mode: 6.0,
            fx: [0.0, 0.0, anim[0], anim[1]],
            mb,
            ..Default::default()
        };
        let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
        let layer = self.make_bind(&cb, Some((&view, &view, &view)), dummy);
        Ok(BgDraw { layer, _tex: Some(tex), _view: Some(view) })
    }

    /// Prepare le fond du mode « personnalise », peint DANS la bulle webcam juste
    /// avant que la camera n'y soit decoupee par-dessus.
    ///
    /// Le shader ne sait peindre qu'une couleur plate sous le masque, donc un
    /// degrade ou une image y tombaient sur du noir -- et le defaut EST une image
    /// (`DEFAULT_WALLPAPER`), si bien que le mode ne rendait jamais ce que le
    /// selecteur montrait. Peindre le fond puis composer la camera en detourage
    /// donne exactement le meme resultat (`lerp(fond, camera, personne)`, ici par
    /// le melange alpha) pour les trois sortes de fond, en reutilisant les chemins
    /// deja eprouves du fond d'ecran, et sans rien ajouter aux trois shaders.
    ///
    /// `quad_px` / `radius_px` sont ceux de la bulle : le fond doit epouser ses
    /// coins arrondis, sinon un rectangle deborde derriere la camera.
    fn webcam_bg_draw(
        &self,
        bg: Option<&SceneBackground>,
        dst: [f32; 4],
        quad_px: [f32; 2],
        radius_px: f32,
        dummy: &wgpu::TextureView,
    ) -> BgDraw {
        const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
        let flat = |cb: LayerCB| BgDraw { layer: self.make_bind(&cb, None, dummy), _tex: None, _view: None };
        let solid = |color: [f32; 4]| LayerCB {
            dst,
            quad_px,
            radius_px,
            mode: 1.0,
            color,
            ..Default::default()
        };
        match bg {
            Some(SceneBackground::Color { color }) => {
                flat(solid(parse_hex(color).unwrap_or(BLACK)))
            }
            // Le mouvement ne vaut que pour le fond d'ecran : la bulle garde son degrade immobile.
            Some(SceneBackground::Gradient { angle_deg, stops, offsets, .. }) => {
                // angle CSS -> direction unitaire, meme convention que le fond
                // d'ecran (dont la direction se lit en espace SORTIE : le degrade
                // traverse le cadre, la bulle n'en montre que sa tranche).
                let a = angle_deg.to_radians();
                flat(LayerCB {
                    dst,
                    quad_px,
                    radius_px,
                    fx: [a.sin(), -a.cos(), 0.0, 0.0],
                    ..crate::frame_geometry::gradient_layer(stops, offsets, BLACK)
                })
            }
            Some(SceneBackground::Image { path, .. }) => {
                // Le cover-fit se mesure sur la BULLE, pas sur la sortie : c'est
                // elle que l'image doit remplir sans etirement.
                let aspect = if quad_px[1] > 0.0 { quad_px[0] / quad_px[1] } else { 1.0 };
                let still = WallpaperMotion::None;
                match self.image_bg_draw(path, dst, quad_px, radius_px, aspect, still, 0.0, dummy) {
                    Ok(d) => d,
                    Err(e) => {
                        // Meme contrat que le fond d'ecran : un chemin casse est
                        // logge puis remplace par du noir. Un repli silencieux
                        // redonnerait le bug qu'on corrige.
                        eprintln!("[fond webcam] \"{path}\" : {e:#}");
                        flat(solid(BLACK))
                    }
                }
            }
            // Personnalise sans fond : noir, comme avant -- mais c'est desormais
            // le seul chemin qui y mene, au lieu de l'etre pour toute image et
            // tout degrade.
            None => flat(solid(BLACK)),
        }
    }

    // -- segmentation du sujet webcam --

    /// Extrait la frame webcam en RGB8 a la resolution du modele, dans `out`.
    ///
    /// Pendant wgpu de `compositor_windows::capture_webcam_rgb`, avec les memes
    /// contraintes d'appel. Comme cote Metal, rien n'est « requisitionne » : la
    /// passe s'ouvre sur `SegCapture::view` et se referme. La contrainte d'ordre
    /// tient malgre tout, et pour une autre raison — cette methode ATTEND sa
    /// propre soumission, donc l'appeler une fois la passe de composition
    /// encodee serialiserait CPU et GPU sur exactement le chemin que cette
    /// conception garde recouvert. Elle tourne donc dans le prologue de
    /// `compose_frame`, avant le moindre encodeur.
    ///
    /// `src` est le rect source en UV. L'appelant y passe la frame ENTIERE et non
    /// le sous-rect dessine — cf. `pump_segmentation`.
    ///
    /// # Le readback
    ///
    /// Meme forme que `ReadbackRing`, en plus simple parce qu'il n'y a rien a
    /// recouvrir : une seule copie, attendue tout de suite. Ce qui EST repris de
    /// la ring, parce que c'est la lecon qu'elle porte, c'est
    /// `WaitForSubmissionIndex` — jamais `Maintain::Wait`, qui absorberait toute
    /// la file GPU (3,8 a 6,2 ms mesurees en 1080p, cf. l'en-tete de
    /// `ReadbackRing`) au lieu de la seule copie de 147 Ko demandee ici.
    ///
    /// C'est le second readback synchrone du chemin de preview, qui en paie deja
    /// un a profondeur 1 (`live.rs`). C'est le seul cout que ce portage ajoute au
    /// rendu, et il ne se paie que quand un effet est demande.
    ///
    /// A l'EXPORT, ou la ring tourne a profondeur 2, il faut etre honnete sur ce
    /// que cette attente coute : une file GPU se termine dans l'ordre, donc
    /// attendre CETTE soumission, c'est attendre aussi la copie de la frame
    /// precedente que la ring gardait justement en vol. Le travail CPU de la
    /// frame courante ne la recouvre donc plus. Ce n'est pas gratuit, c'est
    /// seulement borne : 30 Hz et non 60, et zero quand aucun effet n'est demande.
    /// Aucune des deux mesures §C.2 n'a ete faite — cf. « Still open » dans
    /// `webcam-segmentation.md`.
    pub unsafe fn capture_webcam_rgb(
        &self,
        wy: &wgpu::TextureView,
        wu: &wgpu::TextureView,
        wv: &wgpu::TextureView,
        src: [f32; 4],
        width: u32,
        height: u32,
        out: &mut Vec<u8>,
    ) -> Result<()> {
        if width == 0 || height == 0 {
            anyhow::bail!("capture webcam de dimensions nulles ({width}x{height})");
        }
        {
            let mut slot = self.seg_capture.borrow_mut();
            if !matches!(slot.as_ref(), Some(c) if c.width == width && c.height == height) {
                let rt = self.gpu.device.create_texture(&wgpu::TextureDescriptor {
                    label: Some("seg-capture"),
                    size: wgpu::Extent3d { width, height, depth_or_array_layers: 1 },
                    mip_level_count: 1,
                    sample_count: 1,
                    dimension: wgpu::TextureDimension::D2,
                    // Meme format que le RT : c'est celui que `mk_layer` a cable
                    // dans la cible couleur du pipeline de calque, et une passe
                    // dont la piece jointe ne l'a pas est refusee.
                    format: wgpu::TextureFormat::Rgba8Unorm,
                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
                        | wgpu::TextureUsages::COPY_SRC,
                    view_formats: &[],
                });
                let view = rt.create_view(&wgpu::TextureViewDescriptor::default());
                let bpr = (width * 4).div_ceil(256) * 256;
                let staging = self.gpu.device.create_buffer(&wgpu::BufferDescriptor {
                    label: Some("seg-capture-staging"),
                    size: u64::from(bpr) * u64::from(height),
                    usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
                    mapped_at_creation: false,
                });
                *slot = Some(SegCapture { rt, view, staging, width, height, bpr });
            }
        }
        let slot = self.seg_capture.borrow();
        let cap = slot.as_ref().expect("cree juste au-dessus");

        // Plein cadre de la cible, sans coins ni motion blur : le modele veut
        // l'image, pas la mise en forme. `fx` reste a zero — la branche de masque
        // du shader ne doit surtout pas se prendre sur la capture qui l'alimente.
        // `color.a = 1` n'est pas decoratif : `fs_main` calcule son alpha en
        // `layer.color.a * alpha_mask`, donc le defaut (0) rendrait un quad
        // entierement transparent.
        let layer = self.make_bind(
            &LayerCB {
                dst: [0.0, 0.0, 1.0, 1.0],
                src,
                quad_px: [width as f32, height as f32],
                mode: 0.0,
                color: [0.0, 0.0, 0.0, 1.0],
                mb: [1.0, 1.0, 1.0, 0.0],
                ..Default::default()
            },
            Some((wy, wu, wv)),
            &self.dummy_view(),
        );

        let mut encoder = self.gpu.device.create_command_encoder(
            &wgpu::CommandEncoderDescriptor { label: Some("seg-capture") },
        );
        {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("seg-capture-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &cap.view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline);
            self.draw_layer(&mut rpass, &layer, false);
        }
        encoder.copy_texture_to_buffer(
            wgpu::TexelCopyTextureInfo {
                texture: &cap.rt,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            wgpu::TexelCopyBufferInfo {
                buffer: &cap.staging,
                layout: wgpu::TexelCopyBufferLayout {
                    offset: 0,
                    bytes_per_row: Some(cap.bpr),
                    rows_per_image: Some(height),
                },
            },
            wgpu::Extent3d { width, height, depth_or_array_layers: 1 },
        );
        let idx = self.gpu.context.submit(std::iter::once(encoder.finish()));
        let (tx, rx) = std::sync::mpsc::channel();
        cap.staging.slice(..).map_async(wgpu::MapMode::Read, move |r| {
            let _ = tx.send(r);
        });
        // `WaitForSubmissionIndex` et JAMAIS `Maintain::Wait` : cf. l'en-tete de
        // `ReadbackRing`, qui est le proces-verbal de cette regression-la.
        self.gpu.device.poll(wgpu::Maintain::WaitForSubmissionIndex(idx));
        rx.recv()
            .map_err(|_| anyhow::anyhow!("map_async channel (capture webcam)"))?
            .map_err(|e| anyhow::anyhow!("map_async (capture webcam): {e:?}"))?;
        let slice = cap.staging.slice(..);
        let mapped = slice.get_mapped_range();

        let (w, h, bpr) = (width as usize, height as usize, cap.bpr as usize);
        // `clear` + `reserve` plutot qu'un `Vec` neuf : la capacite survit d'une
        // capture a l'autre, donc apres le premier tour plus une seule
        // reallocation. A 30 Hz ce n'est pas une coquetterie.
        out.clear();
        out.reserve(w * h * 3);
        for row in 0..h {
            // La ligne fait `w * 4` octets utiles dans un pas de `bpr` : le
            // padding d'alignement se saute ici, il n'a jamais de sens pour le
            // modele.
            for px in mapped[row * bpr..row * bpr + w * 4].chunks_exact(4) {
                // RGBA -> RGB : le modele n'a pas de canal alpha en entree.
                out.push(px[0]);
                out.push(px[1]);
                out.push(px[2]);
            }
        }
        drop(mapped);
        // Sans `unmap`, la capture suivante echouerait a re-armer `map_async` sur
        // un buffer deja mappe.
        cap.staging.unmap();
        Ok(())
    }

    /// Publie le masque de segmentation du sujet webcam (R8, `width`x`height`,
    /// 0 = fond).
    ///
    /// `Queue::write_texture` et non une copie par buffer : il n'impose aucun
    /// alignement de ligne (c'est `copy_texture_to_buffer` qui exige 256, cf.
    /// `SegCapture`), et c'est deja par lui que `linux_frames` televerse les plans
    /// NV12 avec les strides SIMD de swscale. La texture n'est recreee que si la
    /// resolution du modele change, ce qui n'arrive pas en regime etabli.
    ///
    /// Pas de double buffer, et pour la meme raison que cote Metal : quand
    /// `pump_segmentation` appelle ceci, la frame precedente est deja drainee —
    /// `capture_webcam_rgb` attend sa soumission, et la preview comme l'export
    /// passent par `readback_take`, qui attend la sienne. Si cet invariant
    /// changeait, c'est ce code-ci qui casserait.
    pub fn set_webcam_mask(&self, data: &[u8], width: u32, height: u32) -> Result<()> {
        if width == 0 || height == 0 {
            anyhow::bail!("masque webcam de dimensions nulles ({width}x{height})");
        }
        let expected = (width as usize) * (height as usize);
        if data.len() < expected {
            anyhow::bail!(
                "masque webcam trop court : {} octets pour {width}x{height}",
                data.len()
            );
        }

        let mut slot = self.webcam_mask.borrow_mut();
        if !matches!(slot.as_ref(), Some(m) if m.width == width && m.height == height) {
            let tex = self.gpu.device.create_texture(&wgpu::TextureDescriptor {
                label: Some("webcam-mask"),
                size: wgpu::Extent3d { width, height, depth_or_array_layers: 1 },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: wgpu::TextureFormat::R8Unorm,
                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
                view_formats: &[],
            });
            let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
            *slot = Some(WebcamMask { tex, view, width, height });
        }
        let mask = slot.as_ref().expect("alloue juste au-dessus");
        self.gpu.context.write_texture(
            wgpu::TexelCopyTextureInfo {
                texture: &mask.tex,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            // `data` peut etre plus long que le masque (le garde ci-dessus est un
            // minimum) : on ne televerse que ce que la texture porte.
            &data[..expected],
            wgpu::TexelCopyBufferLayout {
                offset: 0,
                bytes_per_row: Some(width),
                rows_per_image: Some(height),
            },
            wgpu::Extent3d { width, height, depth_or_array_layers: 1 },
        );
        Ok(())
    }

    /// Un tour de segmentation : televerse le masque pret, puis soumet une
    /// nouvelle frame si la cadence l'autorise. Port de
    /// `compositor_windows::pump_segmentation` — worker, boite aux lettres,
    /// limiteur de cadence et demarrage paresseux sont independants de la
    /// plateforme, seuls les deux appels GPU changent.
    ///
    /// Les deux moities sont volontairement desynchronisees. Le masque televerse
    /// ici vient de la frame precedente — une frame de retard sur une silhouette
    /// est invisible, alors qu'attendre l'inference bloquerait le rendu, ce qui
    /// est exactement le cout que toute cette conception cherche a ne pas payer.
    unsafe fn pump_segmentation(
        &self,
        wy: &wgpu::TextureView,
        wu: &wgpu::TextureView,
        wv: &wgpu::TextureView,
        valid: [f32; 2],
    ) -> Result<()> {
        if *self.seg_failed.borrow() {
            return Ok(());
        }
        // Rien a faire si aucun effet n'est demande : ni capture, ni inference,
        // ni masque. Le cout de la fonctionnalite est alors exactement nul.
        let (wants_effect, model_path) = {
            let scene = self.scene.borrow();
            match scene.as_ref().and_then(|s| s.webcam_effect.as_ref()) {
                Some(e) if e.shader_code() > 0.0 => (true, e.model_path.clone()),
                _ => (false, None),
            }
        };
        if !wants_effect {
            return Ok(());
        }

        // Demarrage paresseux, pilote par la scene : personne n'a a appeler
        // `enable_segmentation` a la main, et un modele introuvable eteint l'effet
        // au lieu de faire tomber le rendu.
        if self.seg_worker.borrow().is_none() && self.seg_sync.borrow().is_none() {
            let Some(path) = model_path else { return Ok(()) };
            if let Err(e) = self.enable_segmentation(std::path::Path::new(&path)) {
                eprintln!("[segmentation] desactivee : {e}");
                // Une scene qui reste identique retenterait a chaque frame ; on
                // leve le verrou plutot que de journaliser 60 fois par seconde.
                *self.seg_failed.borrow_mut() = true;
                return Ok(());
            }
            // En preview on rend cette frame sans masque : le worker vient de
            // demarrer et l'effet apparaitra dans quelques millisecondes, ce que
            // personne ne voit. A l'export cette frame part dans le fichier — on
            // enchaine donc sur la capture et l'inference plutot que de la laisser
            // sortir non detouree.
            if !self.seg_deterministic.get() {
                return Ok(());
            }
        }

        if let Some(mask) = self.seg_inbox.lock().unwrap().take() {
            self.set_webcam_mask(
                &mask,
                crate::segmentation::MODEL_WIDTH,
                crate::segmentation::MODEL_HEIGHT,
            )?;
        }

        // La cadence horloge est le bon reglage en preview et le mauvais a
        // l'export, ou les frames defilent aussi vite que la machine decode : le
        // nombre de frames couvertes par un masque dependrait alors de la charge.
        // En deterministe, une inference par frame.
        if !self.seg_deterministic.get()
            && !self.seg_rate.borrow_mut().should_run(std::time::Instant::now())
        {
            return Ok(());
        }
        let mut scratch = self.seg_scratch.borrow_mut();
        // La frame ENTIERE, pas le sous-rect dessine : un crop utilisateur serre
        // amputerait le sujet en entree du modele, et le masque serait faux la ou
        // il compte le plus. Le shader ramene ses coordonnees dans cet espace via
        // `fx.xy`.
        self.capture_webcam_rgb(
            wy,
            wu,
            wv,
            [0.0, 0.0, valid[0], valid[1]],
            crate::segmentation::MODEL_WIDTH,
            crate::segmentation::MODEL_HEIGHT,
            &mut scratch,
        )?;
        if self.seg_deterministic.get() {
            // Synchrone : le masque doit exister avant que cette frame ne soit
            // composee, sinon on retombe sur le defaut qu'on corrige. Une
            // inference ratee laisse le masque precedent, comme le fait le worker.
            let mut sync = self.seg_sync.borrow_mut();
            if let Some(seg) = sync.as_mut() {
                match seg.run(&scratch) {
                    Ok(mask) => {
                        // `run` rend une tranche empruntee au segmenteur : copier
                        // puis relacher, sinon `set_webcam_mask` reemprunterait
                        // `seg_sync` encore emprunte ici.
                        let mask = mask.to_vec();
                        drop(sync);
                        self.set_webcam_mask(
                            &mask,
                            crate::segmentation::MODEL_WIDTH,
                            crate::segmentation::MODEL_HEIGHT,
                        )?;
                    }
                    Err(e) => eprintln!("[segmentation] frame ignoree : {e}"),
                }
            }
        } else if let Some(w) = self.seg_worker.borrow().as_ref() {
            w.submit(&scratch);
        }
        Ok(())
    }

    /// Demarre la segmentation du sujet webcam pour ce compositeur.
    ///
    /// Idempotent. Tant qu'elle n'est pas appelee, `compose_frame` ne fait rien de
    /// plus et la webcam se dessine comme avant — c'est ce qui rend l'effet inerte
    /// plutot que casse sur une build sans modele.
    pub fn enable_segmentation(&self, model_path: &std::path::Path) -> Result<()> {
        if self.seg_worker.borrow().is_some() || self.seg_sync.borrow().is_some() {
            return Ok(());
        }
        let segmenter = crate::segmentation::Segmenter::load(model_path)?;
        // En deterministe, le segmenteur reste ici : l'inference tourne sur le
        // thread de rendu, donc le masque de la frame N est pret AVANT qu'elle ne
        // soit composee. Le worker est un choix de preview — ne jamais bloquer
        // l'affichage — et c'est exactement ce qui rend l'export irreproductible,
        // le masque arrivant quelques frames plus tard selon la charge.
        if self.seg_deterministic.get() {
            *self.seg_sync.borrow_mut() = Some(segmenter);
            return Ok(());
        }
        let inbox = std::sync::Arc::clone(&self.seg_inbox);
        let worker =
            crate::segmentation::SegmentationWorker::spawn(segmenter, move |mask, _, _| {
                // Ecrase le masque precedent s'il n'a pas encore ete televerse :
                // c'est le plus recent qui vaut, jamais une file.
                *inbox.lock().unwrap() = Some(mask.to_vec());
            });
        *self.seg_worker.borrow_mut() = Some(worker);
        Ok(())
    }

    /// Bascule la segmentation en mode reproductible, pour l'export.
    ///
    /// En preview, la cadence suit l'horloge (30 Hz reels) et l'inference tourne
    /// sur un worker : c'est le bon choix, l'affichage ne doit jamais attendre. A
    /// l'export les frames sont rendues aussi vite que la machine decode, sans
    /// rapport avec le temps reel — et ces deux choix deviennent alors des bugs.
    /// La cadence horloge fait dependre le nombre de frames couvertes par un
    /// masque de la vitesse de la machine, et le worker asynchrone rend les
    /// premieres frames AVANT que le premier masque n'existe : elles partent dans
    /// le fichier avec le vrai arriere-plan de la webcam. Deux exports du meme
    /// projet ne donnent donc pas les memes pixels, ce qui casse l'invariant
    /// « l'export est identique a la preview ».
    ///
    /// En deterministe : une inference PAR FRAME, synchrone. Plus couteux
    /// (~3 ms/frame), mais l'export est hors ligne et chaque frame porte le masque
    /// calcule depuis SA propre image.
    ///
    /// A appeler avant la premiere frame — c'est ce qui decide comment
    /// `enable_segmentation` s'installe.
    pub fn set_segmentation_deterministic(&self, on: bool) {
        if self.seg_deterministic.get() == on {
            return;
        }
        self.seg_deterministic.set(on);
        // Changer de mode change le MOTEUR, et `enable_segmentation` est idempotent sur la
        // PRESENCE d'un moteur : sans demonter celui qui ne correspond plus, le drapeau
        // mentirait. Un compositeur qui a deja servi en preview garderait son worker,
        // `seg_sync` resterait vide, et l'export entier ne ferait AUCUNE inference. Le
        // demarrage paresseux de `pump_segmentation` reinstalle le bon moteur a la frame
        // suivante.
        *self.seg_worker.borrow_mut() = None;
        *self.seg_sync.borrow_mut() = None;
        // Et le masque que le worker demonte avait peut-etre deja depose : il vient de l'autre
        // mode, il n'a rien a faire sur la premiere frame de celui-ci.
        *self.seg_inbox.lock().unwrap() = None;
    }

    /// Eteint l'effet : la webcam se redessine telle quelle a la frame suivante.
    pub fn clear_webcam_mask(&self) {
        *self.webcam_mask.borrow_mut() = None;
    }

    /// Le métrage dans la dernière image composée : ses coins et son warp (`FootageQuad`).
    pub fn footage_quad(&self) -> Option<crate::frame_geometry::FootageQuad> {
        self.footage.get()
    }

    /// Rend une frame dans le RT interne. Le screen `screen`/`webcam` sont des
    /// carriers `linux_frames` ; la geometrie vient de `plan_frame`. Coeur :
    /// fond uni + ecran cover-fit. `readback_direct` lit ensuite le RT.
    pub unsafe fn compose_frame(
        &self,
        screen: *const AVFrame,
        webcam: *const AVFrame,
        frame: f32,
        cfg: &Cfg,
    ) -> Result<()> {
        self.begin_image_frame();
        if Self::pixel_buffer_of(screen).is_none() {
            return self.clear_rt();
        }
        let (sy, su, sv) = self.nv12_srvs(screen)?;
        let (stw, sth) = self.tex_dims(screen);
        let (wtw, wth) = self.tex_dims(webcam);
        let (scw, sch) = ((*screen).width as f32, (*screen).height as f32);
        let (wcw, wch) = if webcam.is_null() {
            (1.0, 1.0)
        } else {
            ((*webcam).width as f32, (*webcam).height as f32)
        };
        let u_max = scw / (stw.max(1)) as f32;
        let v_max = sch / (sth.max(1)) as f32;
        let (rw, rh) = (self.render_w as f32, self.render_h as f32);
        // Etendue valide de la texture webcam : les decodeurs allouent des
        // textures alignees (`linux_frames` arrondit deja aux dimensions paires),
        // donc la frame n'occupe pas forcement toute la texture. `.max(1)` au
        // denominateur — `tex_dims` rend (1, 1) sur une webcam absente, la ou le
        // chemin Windows divise sans garde parce qu'il a toujours les deux frames.
        let w_valid = [wcw / (wtw.max(1)) as f32, wch / (wth.max(1)) as f32];

        // Segmentation, AVANT le moindre encodeur de composition :
        // `capture_webcam_rgb` attend sa propre soumission, et attendre au milieu
        // de la frame serialiserait CPU et GPU. Dernier point ou `wtw/wth/wcw/wch`
        // sont en portee sans emprunt de `self.scene` — `pump_segmentation`
        // emprunte la scene lui-meme.
        //
        // L'effet est teste ICI en plus de l'etre dans `pump_segmentation` : sur
        // ce backend `nv12_srvs` ALLOUE deux `TextureView` a chaque appel (il n'y
        // a pas de cache, cf. `clear_srv_cache`), et la fonctionnalite doit couter
        // exactement zero quand elle est eteinte — ce qui est le cas general.
        let wants_seg = self
            .scene
            .borrow()
            .as_ref()
            .and_then(|s| s.webcam_effect.as_ref())
            .is_some_and(|e| e.shader_code() > 0.0);
        if wants_seg && !webcam.is_null() {
            // `nv12_srvs` dereference `data[0]` sans verifier la frame elle-meme,
            // d'ou le garde de nullite au-dessus (meme condition que le draw PiP).
            if let Ok((wy, wu, wv)) = self.nv12_srvs(webcam) {
                self.pump_segmentation(&wy, &wu, &wv, w_valid)?;
            }
        }

        let scene_ref = self.scene.borrow();
        let cursor_ref = self.cursor.borrow();
        let lp = *self.live_params.borrow();
        let g = plan_frame(&FrameGeometryInput {
            render_px: [rw, rh],
            screen_tex_px: [stw as f32, sth as f32],
            screen_visible_px: [scw, sch],
            webcam_visible_px: [wcw, wch],
            u_max,
            v_max,
            frame,
            cfg,
            live: lp,
            scene: scene_ref.as_ref(),
            cursor: cursor_ref.as_ref(),
            timeline_t_override: *self.timeline_time.borrow(),
            programme_time: *self.programme_time.borrow(),
        });
        self.footage.set(Some(g.footage_quad([rw, rh])));
        // (`wtw`/`wth` sont les dims de la TEXTURE webcam, consommees par le
        // cover-crop du calque PiP plus bas.)

        // Fond : Color -> clear a la couleur ; Gradient -> mode 5 ; Image ->
        // mode 6 wallpaper cover-fit (via load_image_texture). Le blur (si
        // cfg.bg_blur) floute ensuite ce fond, avant l'ecran.
        enum BgLayer {
            Gradient(LayerCB),
            Image(String, WallpaperMotion),
        }
        let (bg_clear, bg_layer) = match scene_ref.as_ref().map(|s| s.background.clone()) {
            Some(SceneBackground::Color { color }) => {
                (parse_hex(&color).unwrap_or(lp.bg_color), None)
            }
            Some(SceneBackground::Gradient { angle_deg, stops, offsets, motion }) => {
                let a = angle_deg.to_radians();
                let (anim, mb) =
                    crate::frame_geometry::wallpaper_motion_slots(motion, g.programme_t, rw / rh);
                let cb = LayerCB {
                    dst: [0.0, 0.0, 1.0, 1.0],
                    quad_px: [rw, rh],
                    fx: [a.sin(), -a.cos(), anim[0], anim[1]],
                    mb,
                    ..crate::frame_geometry::gradient_layer(&stops, &offsets, lp.bg_color)
                };
                ([0.0, 0.0, 0.0, 1.0], Some(BgLayer::Gradient(cb)))
            }
            Some(SceneBackground::Image { path, motion }) => {
                ([0.0, 0.0, 0.0, 1.0], Some(BgLayer::Image(path, motion)))
            }
            None => (lp.bg_color, None),
        };

        // ROTATION 3D (presets iso/left/right d'une zoom region). La geometrie du
        // tilt est calculee UNE fois : l'ombre et l'ecran doivent porter exactement
        // le meme quadrilatere, sinon l'ombre se decolle des que l'un des deux
        // change. `regions` fait toute la trigo (partagee avec macOS/Windows) ; ici
        // on ne fait que l'empaqueter.
        let s_px = [g.s_dst[2] * rw, g.s_dst[3] * rh];
        let tilt = g.screen_tilt(s_px);
        let quad_center_px = [
            (g.s_dst[0] + g.s_dst[2] * 0.5) * rw,
            (g.s_dst[1] + g.s_dst[3] * 0.5) * rh,
        ];
        // Profondeur de champ : pyramide allouee et remplie seulement sur une frame
        // inclinee qui la lit. L'emprunt tient jusqu'a la soumission de l'encodeur.
        let dof = g.depth_of_field_on(self.gpu.backend == crate::d3d::Backend::Cpu);
        if dof {
            self.ensure_dof_pyramid(stw, sth);
        }
        let dof_guard = self.dof_pyramid.borrow();
        let dof_pyramid = dof_guard.as_ref().filter(|_| dof);

        // Calque ecran : mode 0 (rect droit, NV12 -> RGB) quand la rotation est
        // neutre, mode 8 (warp bilineaire inverse dans la bbox du quad projete)
        // sinon. Place par plan_frame (cover-fit + coins arrondis) ;
        // `src = g.cut` (crop utilisateur + zoom en UV texture) dans les deux cas.
        //
        // FLOU DE VELOCITE. Au mode 0, `src_prev`/`dst_prev` decrivent le MEME
        // calque a la frame precedente ; le shader remappe chaque pixel de sortie
        // par ce couple pour retrouver l'UV qu'il occupait alors, et floute le long
        // du segment. `src_prev = g.cut` et non un `cut` d'avant : la coupe est
        // identique aux deux frames (`plan_frame` ne fait varier que le rect de
        // DESTINATION entre `s_dst` et `s_dst_prev`), ce que Windows documente
        // aussi. Le mouvement vient donc entierement de `dst_prev`.
        //
        // Au mode 8, ces deux champs portent deja les coins projetes du quad
        // (BR/BL dans `src_prev`, `plane_px` dans `dst_prev`) : le plan d'avant
        // arrive dans ses propres champs (`trail_a`/`trail_b`/`trail_mb`,
        // `FrameGeometry::tilt_pixel_trail`), meme flou borne a une frame.
        // Dans les deux modes, ce flou par pixel s'efface quand l'ecran CADRE est
        // floute en bloc (mode 18, `trail` plus bas).
        // Sous un cadre de fenetre, l'ecran garde ses coins HAUTS carres (`mb.w` au mode 0,
        // `dst_prev.z` au mode 8) ; 0 sans cadre, soit le rendu d'avant.
        let square_top = g.screen_square_top();
        // Et la remontee du contour interieur du chrome au-dessus de l'ecran (`mb.z` au mode 0,
        // `color.z` au mode 8) : l'arrondi du haut se fait par le cadre. 0 sans fenetre.
        let top_lift = g.screen_top_lift_px([rw, rh]);
        let screen_layer = match tilt.as_ref() {
            None => {
                // Sous le masque d'un layout en bloc, rogne au slot (`mask_flat_screen`).
                let (dst, src, quad_px, radius_px) =
                    g.mask_flat_screen(g.s_dst, g.cut, s_px, g.s_radius, [rw, rh]);
                LayerCB {
                    dst,
                    src,
                    quad_px,
                    radius_px,
                    mode: 0.0,
                    color: [1.0, 1.0, 1.0, 1.0],
                    src_prev: g.cut,
                    dst_prev: g.s_dst_prev,
                    mb: [g.screen_pixel_taps([rw, rh]), g.mb_amount, top_lift, square_top],
                    ..Default::default()
                }
            }
            // Mode 8, partage avec Windows et macOS (`tilted_screen_cb`).
            Some(quad) => tilted_screen_cb(
                quad,
                s_px,
                quad_center_px,
                g.cut,
                g.focus_plane,
                g.s_radius,
                top_lift,
                dof,
                [rw, rh],
                g.screen_mask,
                g.tilt_pixel_trail([rw, rh]),
            ),
        };
        // Bind group construit AVANT le pass (doit vivre pendant tout le pass) ; `LayerBind`
        // garde le buffer uniforme en vie (reference par le bind).
        let dummy = self.dummy_view();
        // Binding 6 du mode 8 : la pyramide si l'effet tourne, sinon `dummy` (`k = 0`, le
        // shader n'y lit rien).
        let screen_bind = self.make_bind_b4(
            &screen_layer,
            Some((&sy, &su, &sv)),
            &dummy,
            None,
            dof_pyramid.map(|p| &p.view),
        );
        // Remplissage de la pyramide : UN draw du mode 0 en UV plein vers son niveau 0
        // (cf. `compositor_windows::fill_dof_pyramid`), `color.a = 1`, un seul tap.
        let dof_fill = dof_pyramid.map(|p| {
            let full = [0.0, 0.0, 1.0, 1.0];
            let cb = LayerCB {
                dst: full,
                src: full,
                quad_px: [p.width as f32, p.height as f32],
                mode: 0.0,
                color: [1.0, 1.0, 1.0, 1.0],
                src_prev: full,
                dst_prev: full,
                mb: [1.0, 0.0, 1.0, 0.0],
                ..Default::default()
            };
            self.make_bind(&cb, Some((&sy, &su, &sv)), &dummy)
        });

        // OMBRE PORTEE de l'ecran, dessinee JUSTE AVANT le calque ecran. Le shader
        // la connait depuis le debut ; ce qui manquait etait uniquement le draw
        // cote Rust, si bien que le curseur « Ombre » de l'UI ne faisait rien sur
        // Linux.
        //
        // Les fractions de reglage viennent de `frame_geometry`, partagees avec
        // macOS/Windows : l'ombre a la meme taille relative sur les trois
        // plateformes quelle que soit la resolution de sortie.
        //
        // L'ombre suit la silhouette REELLEMENT affichee : rect arrondi (mode 2)
        // quand l'ecran est droit, quadrilatere projete (mode 12) quand il penche. Avec un
        // cadre de fenetre, c'est le CADRE qui la porte (`shadow_caster`), sinon la barre de
        // titre flotterait au-dessus de l'ombre.
        let screen_shadow = cfg.shadow.then(|| {
            let spread = crate::frame_geometry::SCREEN_SHADOW_SPREAD_FRAC * g.screen_unit_px;
            let offset = g.screen_shadow_offset();
            let opacity = 0.45 * lp.shadow_scale;
            // Un appareil porte l'ombre de sa silhouette 3D (mode 17), pas celle d'un quad.
            let cb = match g.device_shadow_cb([rw, rh], spread, offset, opacity) {
                Some(cb) => cb,
                None => match g.shadow_caster([rw, rh]) {
                    ShadowCaster::Upright { dst, size_px, radius } => {
                        self.shadow_cb(dst, size_px, radius, spread, offset, opacity)
                    }
                    ShadowCaster::Tilted { corners, center_px, radius, mask } => self
                        .quad_shadow_cb(&corners, center_px, radius, mask, spread, offset, opacity),
                },
            };
            self.make_bind(&cb, None, &dummy)
        });
        // Le cadre (mode 14), dessine entre l'ombre et l'ecran : l'ecran le recouvre et ne
        // laisse voir que la barre de titre et le filet.
        let window_frame = g.window_frame_cb([rw, rh]).map(|cb| self.make_bind(&cb, None, &dummy));
        // L'appareil modele (mode 17), lui, passe APRES l'ecran : son socle vient DEVANT le plan
        // du metrage et sa lunette mord dessus. Le shader s'arrete au plan du metrage dans
        // l'ouverture, donc il ne recouvre jamais l'image.
        let device_frame = g.device_frame_cb([rw, rh]).map(|cb| self.make_bind(&cb, None, &dummy));
        // Flou de mouvement de l'ecran CADRE (`FrameGeometry::screen_trail`) : l'ombre, le cadre,
        // le metrage et l'appareil ci-dessus passent dans un rendu isole (`trail_view`), que le
        // mode 18 recompose sur le fond, droit ou incline ; binding 4 = ce rendu, les plans = le
        // metrage, binding 6 = la pyramide, pour le relire hors de la sortie comme le mode 8.
        let trail = g.screen_trail([rw, rh]).then(|| {
            self.make_bind_b4(
                &g.screen_trail_cb([rw, rh], dof),
                Some((&sy, &su, &sv)),
                &dummy,
                Some(&self.trail_view),
                dof_pyramid.map(|p| &p.view),
            )
        });

        // Le fond de la frame d'avant, s'il est celui qu'on demande (`BackgroundKey`) : la passe 1
        // le recopie au lieu de le redessiner.
        let bg_desc = scene_ref.as_ref().map(|s| &s.background);
        let bg_cached = self
            .bg_cache
            .borrow()
            .as_ref()
            .is_some_and(|c| c.key.matches(bg_desc, cfg.bg_blur, lp.bg_color, [rw, rh]));
        let bg_wanted = bg_layer.is_some();

        // Fond (gradient mode 5 OU image mode 6), dessine dans la passe de fond.
        let bg_draw = bg_layer.filter(|_| !bg_cached).and_then(|bl| match bl {
            BgLayer::Gradient(cb) => {
                Some(BgDraw { layer: self.make_bind(&cb, None, &dummy), _tex: None, _view: None })
            }
            // Le wallpaper couvre tout le cadre, donc dst plein et pas de coins :
            // `image_bg_draw` sert aussi la bulle webcam, qui elle en a.
            BgLayer::Image(path, motion) => {
                let full = [0.0, 0.0, 1.0, 1.0];
                let t = g.programme_t;
                match self.image_bg_draw(&path, full, [0.0, 0.0], 0.0, rw / rh, motion, t, &dummy) {
                    Ok(d) => Some(d),
                    Err(e) => {
                        eprintln!("[fond image] \"{path}\" : {e:#}");
                        None
                    }
                }
            }
        });

        // Webcam PiP (mode 0) -- placee par plan_frame (`g.w_dst`, coins
        // `g.w_radius`). `g.shape_fade` ne regit que la bulle (coins, ombre) : il
        // vaut 0 pendant un palier Full Camera, ou la webcam remplit le cadre.
        // `webcam_planes` garde les vues en vie pendant le pass.
        // `lp.has_webcam` is the gate Windows (`compositor_windows.rs`) and macOS
        // (`compositor_macos.rs`) both apply and this backend did not. It is false
        // when the clip has no camera — and in that case the "webcam" decoder holds
        // the SCREEN video, because `open_and_seek_clip` falls back to it rather
        // than leave the pair half-open. Without this check a recording with no
        // camera drew its own screen picture inside the PiP box.
        let webcam_planes = if lp.has_webcam && !webcam.is_null() {
            self.nv12_srvs(webcam).ok()
        } else {
            None
        };
        // Effet d'arriere-plan : le mode vient de la scene, le masque par pixel de
        // l'inference. Les DEUX sont requis — un mode sans masque rendrait la
        // webcam invisible en detourage, donc tant que rien n'a ete segmente on
        // dessine la piste telle quelle. C'est aussi ce qui rend le premier
        // lancement gracieux, le temps que l'inference rende son premier masque.
        //
        // Calcule ICI, avant le draw comme avant l'ombre : les deux en dependent.
        let (effect_code, blur_intensity, webcam_bg) = {
            let has_mask = self.webcam_mask.borrow().is_some();
            let effect = scene_ref
                .as_ref()
                .and_then(|s| s.webcam_effect.as_ref())
                .filter(|_| has_mask)
                .map(|e| (e.shader_code(), e))
                .filter(|(code, _)| *code > 0.0);
            match effect {
                // Fond personnalise : on PEINT le fond dans la bulle, puis on y
                // decoupe la camera par-dessus — le melange alpha donne
                // `lerp(fond, camera, personne)`, soit exactement ce que la branche
                // « mode 3 » du shader calculait, mais pour les TROIS sortes de
                // fond. Le shader ne sait peindre qu'une couleur plate sous le
                // masque ; degrades et images y tombaient sur du noir, et le defaut
                // EST une image.
                Some((code, e)) if code > 2.5 => {
                    // Sans piste webcam le fond peindrait un rectangle seul dans le
                    // cadre : il ne se prepare que si la camera se dessine.
                    let bg = webcam_planes.is_some().then(|| {
                        self.webcam_bg_draw(
                            e.background.as_ref(),
                            g.w_dst,
                            g.w_px,
                            g.w_radius,
                            &dummy,
                        )
                    });
                    (1.0, 0.0, bg)
                }
                Some((code, e)) => (code, e.blur_intensity.clamp(0.0, 1.0), None),
                None => (0.0, 0.0, None),
            }
        };
        // L'ombre se juge sur le mode DE LA SCENE, pas sur `effect_code` : le fond
        // personnalise se compose desormais en detourage (code 1) tout en gardant
        // sa bulle, et tester le code compose la lui retirerait. Meme lecture que
        // `is_cutout` cote Windows.
        let is_cutout = matches!(
            scene_ref.as_ref().and_then(|s| s.webcam_effect.as_ref()),
            Some(e) if e.shader_code() == 1.0
        ) && self.webcam_mask.borrow().is_some();
        let webcam_draw = webcam_planes.as_ref().map(|(wy, wu, wv)| {
            // COVER-CROP. `src` etait cable a [0,0,1,1], donc la texture entiere
            // etait etiree sur la boite quelle que soit sa forme : le facteur de
            // deformation valait exactement `box_ar / cam_ar`. Invisible en PiP
            // rectangulaire (`compositeLayout.ts` y preserve deja le ratio),
            // spectaculaire des que le masque est un cercle ou un carre, ou la
            // boite est forcee carree et une camera 16:9 s'ecrase de 1,78x.
            //
            // `cover_crop_uv` est la primitive partagee que macOS et Windows
            // utilisent ; elle rend le rect inchange quand il a deja le bon
            // ratio, donc aucun placement correct ne bouge.
            let [cu0, cv0, cu1, cv1] = crate::frame_geometry::webcam_source_rect(
                [wcw, wch],
                [wtw as f32, wth as f32],
                scene_ref
                    .as_ref()
                    .and_then(|scene| scene.layout.webcam_crop),
                g.w_px[0] / g.w_px[1].max(0.0001),
            );
            // MIROIR : on inverse l'intervalle u. Le VS interpole `src`
            // lineairement et `fs_main` ne re-clampe pas `i.uv`, donc un
            // intervalle a l'envers suffit -- aucune retouche du WGSL. Apres le
            // cover-crop les deux bornes sont strictement a l'interieur de la
            // texture, donc le sampler ClampToEdge ne bave pas sur les bords.
            let (u0, u1) = if lp.webcam_mirror { (cu1, cu0) } else { (cu0, cu1) };
            // `src_prev` doit valoir EXACTEMENT le `src` de ce draw, miroir
            // compris : le shader s'en sert pour reconstruire l'UV de la frame
            // precedente, et un rect source qui ne correspond pas au calque
            // dessine ferait diverger la trainee vers une zone de la texture qui
            // n'a jamais ete affichee. Seul `dst_prev` porte le mouvement.
            let cb = LayerCB {
                dst: g.w_dst,
                src: [u0, cv0, u1, cv1],
                quad_px: g.w_px,
                radius_px: g.w_radius,
                mode: 0.0,
                // `color.a` porte l'alpha du decoupage (`color.a * personne`) ; le
                // RGB n'est plus lu, le fond ayant deja ete peint sous la camera.
                color: [0.0, 0.0, 0.0, 1.0],
                // `fx.xy` = etendue valide de la texture webcam, par quoi le
                // shader divise `uv` pour retomber dans l'espace du masque ;
                // `fx.z` = mode, `fx.w` = intensite du flou. Contrat commun aux
                // trois back-ends, cf. `layer.wgsl` et `webcam-segmentation.md`.
                fx: [w_valid[0], w_valid[1], effect_code, blur_intensity],
                src_prev: [u0, cv0, u1, cv1],
                dst_prev: g.w_dst_prev,
                mb: [g.mb_taps, g.mb_amount, 1.0, 0.0],
                ..Default::default()
            };
            // Le masque est lie par `make_bind` sur tous les draws, pas seulement
            // celui-ci : le layout l'exige (cf. `tex_entry(4)`).
            self.make_bind(&cb, Some((wy, wu, wv)), &dummy)
        });

        // OMBRE de la camera. Pas dans les presets « bloc » (dual-frame,
        // vertical-stack) : la camera y est collee a l'ecran comme une tuile,
        // et une ombre entre les deux dessinerait une couture. Meme condition
        // que macOS.
        //
        // Pas en detourage non plus : l'ombre appartient a la bulle PiP, et en
        // detourage il n'y a plus de bulle — une ombre portee par un rectangle
        // devenu invisible se lit comme un artefact.
        let webcam_shadow = (cfg.shadow
            && g.shape_fade > 0.0
            && webcam_draw.is_some()
            && !is_cutout
            && g.webcam_shadow > 0.0)
        .then(|| {
            let cb = self.shadow_cb(
                g.w_dst,
                g.w_px,
                g.w_radius,
                crate::frame_geometry::WEBCAM_SHADOW_SPREAD_FRAC * g.frame_min_px,
                [0.0, crate::frame_geometry::WEBCAM_SHADOW_OFFSET_FRAC * g.frame_min_px],
                crate::frame_geometry::WEBCAM_SHADOW_OPACITY * g.shape_fade * g.webcam_shadow,
            );
            self.make_bind(&cb, None, &dummy)
        });

        // ANNOTATIONS -- calque le plus haut, place relativement au rect ecran
        // (les coords x/y/w/h de l'annotation sont des fractions de ce rect, cf.
        // `scene.rs`). Le rect est `g.s_ann`, l'ecran SANS ZOOM, et surtout pas
        // `g.s_dst` : le contrat de `SceneAnnotation` dit « deliberately NOT
        // affected by the zoom crop », donc annotations et sous-titres tiennent
        // en place pendant que le contenu grossit dessous. `s_dst` a tenu ce role
        // gratuitement tant que le zoom vivait dans la coupe source ; depuis
        // l'issue #179 il vit dans la BOITE, et l'ancrer dessus fait zoomer les
        // sous-titres avec l'ecran. Windows et macOS ont ete corriges alors, ce
        // backend non. Le natif peignant AUSSI l'apercu, la derive se voyait des
        // l'edition, pas seulement a l'export.
        // Exception : le flou de confidentialite suit le contenu, via
        // `FrameGeometry::privacy_mask` -- un masque doit rester sur ce qu'il cache.
        // Port de `compositor_macos::draw_annotations` : memes modes, memes
        // replis, meme ordre. Seul le texte diverge, tinte cote shader (atlas R8)
        // au lieu d'une couleur bakee dans la texture.
        struct AnnDraw {
            layer: LayerBind,
            /// Gardent l'atlas / la texture image en vie jusqu'au submit. `None`
            /// pour les quads qui n'echantillonnent rien (plaque de fond, fleche).
            _glyphs: Option<crate::text::RasterizedGlyphs>,
            _tex: Option<wgpu::Texture>,
        }
        impl AnnDraw {
            fn plain(layer: LayerBind) -> AnnDraw {
                AnnDraw { layer, _glyphs: None, _tex: None }
            }
        }
        // FENETRE TEMPORELLE. Sans ce test, TOUTES les annotations du projet sont
        // peintes sur TOUTES les frames : cinq sous-titres s'empilent les uns sur
        // les autres du debut a la fin de l'export. C'est le defaut qui se lit
        // comme « le texte s'affiche bizarrement » avant meme de regarder les
        // glyphes. Mirroir de `visible()` dans compositor_macos.rs.
        let visible = |a: &crate::scene::SceneAnnotation| {
            g.source_t >= a.start_sec as f32 && g.source_t < a.end_sec as f32
        };
        // Un flou lit la frame composee ; il faut donc la figer AVANT de dessiner
        // la moindre annotation. On ne le fait que si un flou est reellement
        // visible : la pyramide coute une passe par niveau.
        let needs_ann_copy = scene_ref
            .as_ref()
            .is_some_and(|s| s.annotations.iter().any(|a| a.kind == "blur" && visible(a)));
        let mut ann_draws: Vec<AnnDraw> = Vec::new();
        // Les flous de confidentialite, dessines sur le metrage avant le curseur.
        let mut privacy_draws: Vec<AnnDraw> = Vec::new();
        if let Some(scene) = scene_ref.as_ref() {
            // La liste arrive deja triee par zIndex cote app : l'ordre d'iteration
            // EST l'ordre de peinture.
            for a in &scene.annotations {
                if !visible(a) {
                    continue;
                }
                // Le rect d'ancrage se CHOISIT ici, mais le choix n'est pas
                // revenu : `anchor_rect` ne rend que `s_ann` ou le cadre de
                // sortie -- un sous-titre (`space: "frame"`) se mesure sur le
                // cadre. `s_dst` reste inatteignable, ce que `annotation_dst`
                // garantissait en ne prenant aucun parametre. L'arithmetique
                // elle-meme reste partagee, et les trois backends font
                // desormais exactement ces deux lignes.
                let anchor = a.anchor_rect(g.s_ann);
                let dst = crate::frame_geometry::annotation_dst_in(anchor, a.x, a.y, a.w, a.h);
                let quad_px = [dst[2] * rw, dst[3] * rh];
                // Une boite degeneree ferait un atlas 0x0 et un draw invisible ;
                // macOS l'ecarte de la meme facon.
                if quad_px[0] <= 0.0 || quad_px[1] <= 0.0 {
                    continue;
                }
                match a.kind.as_str() {
                    "figure" => {
                        let Some(figure) = a.figure.as_ref() else { continue };
                        let (segments, half_stroke) = crate::regions::arrow_local_geometry(
                            &figure.direction,
                            figure.stroke_width,
                            quad_px,
                        );
                        let cb = LayerCB {
                            dst,
                            quad_px,
                            mode: 9.0,
                            color: parse_hex(&figure.color).unwrap_or([1.0, 1.0, 1.0, 1.0]),
                            fx: segments[0],
                            src_prev: segments[1],
                            dst_prev: segments[2],
                            mb: [1.0, half_stroke, 0.0, 0.0],
                            ..Default::default()
                        };
                        ann_draws.push(AnnDraw::plain(self.make_bind(&cb, None, &dummy)));
                    }
                    "blur" => {
                        let Some(blur) = a.blur.as_ref() else { continue };
                        let Some(mask) = g.privacy_mask(a, [rw, rh]) else { continue };
                        // Le masque en trace libre demanderait une liste de points
                        // cote GPU : on masque la BOITE ENGLOBANTE. Choix
                        // deliberement asymetrique -- ne rien dessiner laisserait
                        // passer en clair ce que l'utilisateur a designe comme a
                        // cacher, et un masque qui ne masque pas donne confiance a
                        // tort.
                        let freehand = blur.shape == "freehand";
                        let is_blur = if blur.style == "blur" { 1.0 } else { 0.0 };
                        let amount =
                            if is_blur > 0.5 { blur.intensity } else { blur.block_size };
                        // Le repli passe par le rectangle, pas l'ovale : un ovale
                        // inscrit retirerait les coins, donc une partie de ce qui
                        // est couvert.
                        // Masque elargi a la trace du flou de mouvement : l'ovale n'y couvrirait plus tout.
                        let is_oval =
                            if blur.shape == "oval" && !freehand && mask.oval_ok { 1.0 } else { 0.0 };
                        // La teinte n'a de sens qu'en mosaique : un flou teinte ne
                        // ressemble plus a un flou.
                        let tinted = if is_blur > 0.5 { 0.0 } else { 1.0 };
                        let tint = if blur.color == "black" {
                            [0.0, 0.0, 0.0, 1.0]
                        } else {
                            [1.0, 1.0, 1.0, 1.0]
                        };
                        let (dst_prev, src_prev, mb) = mask.warp_fields();
                        let cb = LayerCB {
                            dst: mask.dst,
                            quad_px: mask.quad_px,
                            mode: 10.0,
                            color: tint,
                            fx: [is_blur, amount.max(1.0) * mask.strength, is_oval, tinted],
                            src_prev,
                            dst_prev,
                            mb,
                            ..Default::default()
                        };
                        // La copie mipmappee au binding 1 (texY), la ou le mode 10
                        // la lit.
                        let layer = self.make_bind(
                            &cb,
                            Some((&self.ann_copy_view, &self.ann_copy_view, &self.ann_copy_view)),
                            &dummy,
                        );
                        privacy_draws.push(AnnDraw::plain(layer));
                    }
                    "image" => {
                        let Some(src) = a.image_path.as_ref().filter(|s| !s.is_empty()) else {
                            continue;
                        };
                        let cached = {
                            let c = self.ann_img_cache.borrow();
                            c.get(&a.id).filter(|(_, _, _, len)| *len == src.len()).cloned()
                        };
                        let Some((tex, iw, ih, _)) = cached.or_else(|| {
                            match self.load_image_texture(src) {
                                Ok((tex, w, h)) => {
                                    let e = (tex, w, h, src.len());
                                    self.ann_img_cache
                                        .borrow_mut()
                                        .insert(a.id.clone(), e.clone());
                                    Some(e)
                                }
                                Err(e) => {
                                    eprintln!("[annotation image] {}: {e:#}", a.id);
                                    None
                                }
                            }
                        }) else {
                            continue;
                        };
                        if iw == 0 || ih == 0 {
                            continue;
                        }
                        // CONTAIN, pas cover : l'image tient entiere dans la boite
                        // et se centre. Etirer au rect deformerait une capture ou
                        // un logo, ce que le rendu web ne fait pas non plus.
                        let box_aspect = quad_px[0] / quad_px[1];
                        let img_aspect = iw as f32 / ih as f32;
                        let (fit_w, fit_h) = if img_aspect > box_aspect {
                            (dst[2], dst[3] * (box_aspect / img_aspect))
                        } else {
                            (dst[2] * (img_aspect / box_aspect), dst[3])
                        };
                        let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
                        let cb = LayerCB {
                            dst: [
                                dst[0] + (dst[2] - fit_w) * 0.5,
                                dst[1] + (dst[3] - fit_h) * 0.5,
                                fit_w,
                                fit_h,
                            ],
                            src: [0.0, 0.0, 1.0, 1.0],
                            quad_px: [fit_w * rw, fit_h * rh],
                            mode: 7.0,
                            color: [1.0, 1.0, 1.0, 1.0],
                            // Mode 7 clippe sur `fx` : un rect qui couvre tout le
                            // cadre = pas de clip.
                            fx: [0.0, 0.0, 1.0, 1.0],
                            ..Default::default()
                        };
                        let layer = self.make_bind(&cb, Some((&view, &view, &view)), &dummy);
                        ann_draws.push(AnnDraw { layer, _glyphs: None, _tex: Some(tex) });
                    }
                    "text" => {
                        let Some(raster) = self.text_raster.as_ref() else { continue };
                        let Some(text) = a.text.as_ref() else { continue };
                        if text.content.trim().is_empty() {
                            continue;
                        }
                        let color = parse_hex(&text.color).unwrap_or([1.0, 1.0, 1.0, 1.0]);
                        let background =
                            parse_hex(&text.background_color).unwrap_or([0.0, 0.0, 0.0, 0.0]);
                        let spec = crate::text::TextSpec {
                            content: text.content.clone(),
                            color,
                            background,
                            font_size_px: text.font_size_rel * (anchor[3] * rh),
                            font_family: text.font_family.clone(),
                            bold: text.font_weight == "bold",
                            italic: text.font_style == "italic",
                            underline: text.text_decoration == "underline",
                            align: text.text_align.clone(),
                            // Absent = "center", le comportement historique : les
                            // annotations ne changent pas d'un pixel.
                            valign: text.vertical_align.clone().unwrap_or_default(),
                            box_px: [
                                quad_px[0].round().max(1.0) as u32,
                                quad_px[1].round().max(1.0) as u32,
                            ],
                        };
                        let glyphs = match raster.rasterize(&self.gpu, &spec) {
                            Ok(gl) => gl,
                            Err(e) => {
                                eprintln!("[annotation texte] {}: {e:#}", a.id);
                                continue;
                            }
                        };

                        // ANIMATION D'APPARITION (`text_anim`, partage avec macOS
                        // et Windows). Les decalages sont exprimes en px A 1080p
                        // et remis a l'echelle de la sortie, comme la taille de
                        // police : en px absolus la meme animation sauterait deux
                        // fois plus haut dans un rendu 4K que dans l'apercu.
                        let anim = crate::text_anim::text_animation_state(
                            text.animation.as_deref(),
                            (g.source_t - a.start_sec as f32) * 1000.0,
                            ((a.end_sec - a.start_sec) * 1000.0) as f32,
                        );
                        let anim_px = rh / crate::text_anim::ANIMATION_REFERENCE_HEIGHT;
                        let (mut ax, mut ay, mut aw, mut ah) = (
                            dst[0] + anim.translate_x * anim_px / rw,
                            dst[1] + anim.translate_y * anim_px / rh,
                            dst[2],
                            dst[3],
                        );
                        if (anim.scale - 1.0).abs() > 1e-4 {
                            let (cx, cy) = (ax + aw * 0.5, ay + ah * 0.5);
                            aw *= anim.scale;
                            ah *= anim.scale;
                            ax = cx - aw * 0.5;
                            ay = cy - ah * 0.5;
                        }
                        // Machine a ecrire : le quad ET son UV sont coupes a la
                        // meme fraction, donc la texture n'est pas etiree -- elle
                        // est revelee.
                        let reveal = anim.reveal.clamp(0.0, 1.0);
                        if reveal <= 0.0 {
                            continue;
                        }
                        let anim_dst = [ax, ay, aw * reveal, ah];

                        // PLAQUE DE FOND, dessinee AVANT les glyphes.
                        //
                        // macOS et Windows la peignent dans la texture de texte
                        // elle-meme ; ici c'est impossible : l'atlas est en R8, il
                        // ne porte qu'une couverture alpha et aucune couleur.
                        // Plutot que de convertir tout l'atlas en RGBA pour un
                        // aplat, on emet un quad mode 1 (couleur pleine + SDF de
                        // rect arrondi, cf. layer.wgsl) sous le quad de texte.
                        //
                        // Sans ca le fond n'existait tout simplement pas :
                        // `spec.background` arrivait jusqu'au rasteriseur et
                        // mourait dans `cache_key()`.
                        //
                        // LE RECT VIENT DU RASTERISEUR (`glyphs.plate`), pas de la
                        // boite : lui seul sait ou les lignes ont ete posees. Ici
                        // la plaque prenait toute la boite, ce qui sur un
                        // sous-titre — dont la boite est la bande de 22 % de
                        // hauteur — donnait un aplat bien plus haut que le texte,
                        // la ou Windows et macOS le serrent a `0.1em` pres.
                        if background[3] > 0.0 && glyphs.plate[2] > 0.0 && glyphs.plate[3] > 0.0 {
                            // Le rect est en px DANS la boite ; on le ramene en
                            // fractions pour le reporter sur le quad anime (que
                            // `anim.scale` a pu agrandir).
                            let (box_w, box_h) =
                                (spec.box_px[0].max(1) as f32, spec.box_px[1].max(1) as f32);
                            let px = ax + (glyphs.plate[0] / box_w) * aw;
                            let py = ay + (glyphs.plate[1] / box_h) * ah;
                            let ph = (glyphs.plate[3] / box_h) * ah;
                            // Machine a ecrire : la plaque se decouvre avec le
                            // texte, comme sur les backends qui la bakent dans la
                            // texture — sinon l'aplat entier precede les glyphes.
                            let pw = (((glyphs.plate[2] / box_w) * aw) + px)
                                .min(ax + aw * reveal)
                                - px;
                            if pw > 0.0 && ph > 0.0 {
                                let (pw_px, ph_px) = (pw * rw, ph * rh);
                                let plate = LayerCB {
                                    dst: [px, py, pw, ph],
                                    src: [0.0, 0.0, 1.0, 1.0],
                                    quad_px: [pw_px, ph_px],
                                    mode: 1.0,
                                    // La plaque suit l'opacite du texte : sinon un
                                    // fondu ferait apparaitre un aplat plein d'un
                                    // coup puis le texte dessus.
                                    color: [
                                        background[0],
                                        background[1],
                                        background[2],
                                        background[3] * anim.opacity,
                                    ],
                                    // Meme rayon que les deux autres backends —
                                    // en em de la police, borne par la plaque.
                                    radius_px: crate::text_plate::radius(
                                        spec.font_size_px,
                                        pw_px,
                                        ph_px,
                                    ),
                                    ..Default::default()
                                };
                                ann_draws.push(AnnDraw::plain(self.make_bind(&plate, None, &dummy)));
                            }
                        }

                        let cb = LayerCB {
                            dst: anim_dst,
                            src: [0.0, 0.0, reveal, 1.0],
                            quad_px: [anim_dst[2] * rw, anim_dst[3] * rh],
                            mode: 11.0,
                            color: [color[0], color[1], color[2], color[3] * anim.opacity],
                            ..Default::default()
                        };
                        // Atlas R8 au binding 1 (texY) que le mode 11 echantillonne.
                        let layer =
                            self.make_bind(&cb, Some((&glyphs.view, &glyphs.view, &glyphs.view)), &dummy);
                        ann_draws.push(AnnDraw { layer, _glyphs: Some(glyphs), _tex: None });
                    }
                    _ => {}
                }
            }
        }

        // Curseur thematise : sprite RGBA droit (mode 7), pose sur le plan
        // incline (mode 13) ou curseur modelise (mode 15) selon ce que
        // `plan_cursor` a resolu. `_tex`/`_bufs` gardent le sprite et les uniformes en vie
        // pendant le pass. Miroir de la branche curseur de `compositor_macos`.
        //
        // TRAINEE (`plan.taps > 1`) : `binds` porte une copie par echantillon,
        // interpolee entre `prev_placement` et le placement courant. Elles ne
        // sont PAS dessinees sur le RT mais dans `accum`, puis compositees en une
        // fois -- cf. le commentaire au point de dessin.
        struct CursorDraw {
            /// Le sprite, et pour le curseur modelise son champ de distance.
            _tex: Vec<(wgpu::Texture, wgpu::TextureView)>,
            /// Une copie par echantillon de la trainee, le sprite (modes 7 et 13) ou le curseur
            /// modelise (mode 15).
            binds: Vec<LayerBind>,
            /// L'union des quads de `binds` (x0, y0, x1, y1 en fractions de la sortie) : tout ce
            /// que la trainee peint dans `accum`, donc tout ce que sa recopie doit relire.
            bounds: [f32; 4],
            /// L'impact des clics (mode 16), dessine SOUS le curseur, sur le RT.
            impacts: Vec<LayerBind>,
            /// Le cristal de Prism Glow : il lit la copie de l'image composee (`CursorPlan::glass`).
            glass: bool,
        }
        // La pointe et les clics récents, tels que les effets shader les lisent : ceux de
        // l'enregistrement, que le curseur soit dessiné ou non (`effect_pointer`).
        let mut fx_pointer = crate::frame_geometry::EffectPointer::default();
        let cursor_draw: Option<CursorDraw> = (|| {
            let track = cursor_ref.as_ref()?;
            let input = CursorPlanInput {
                render_px: [rw, rh],
                u_max,
                v_max,
                cfg,
                live: lp,
                scene: scene_ref.as_ref(),
                track,
                t: self
                    .cursor_time
                    .borrow()
                    .unwrap_or(frame / crate::frame_geometry::FPS),
            };
            if scene_ref.as_ref().is_some_and(|s| !s.shader_effects.is_empty()) {
                fx_pointer = crate::frame_geometry::effect_pointer(&g, &input);
            }
            let plan = plan_cursor(&g, &input)?.for_backend(self.gpu.backend == crate::d3d::Backend::Cpu);

            // `taps == 1` : un seul placement, celui de l'instant rendu -- le
            // chemin net d'avant, inchange. Au-dela, on echelonne les copies
            // regulierement de `prev_placement` (inclus) au placement courant
            // (inclus) : c'est ce que font les deux autres backends, et inclure
            // les deux bornes est ce qui fait que la trainee touche a la fois
            // l'endroit d'ou le curseur vient et celui ou il est.
            //
            // On interpole des PLACEMENTS et non des centres : `lerp` sait
            // traiter le cas incline, si bien qu'une trainee sous zoom incline
            // reste dans le plan au lieu de repasser par un centre 2D qui
            // l'aplatirait.
            let placements: Vec<CursorPlacement> = if plan.taps <= 1 {
                vec![plan.placement]
            } else {
                (0..plan.taps)
                    .map(|k| {
                        let f = k as f32 / (plan.taps - 1) as f32;
                        plan.prev_placement.lerp(plan.placement, f)
                    })
                    .collect()
            };
            let mut binds = Vec::new();
            let mut bounds = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
            let mut grow = |dst: [f32; 4]| {
                bounds = [
                    bounds[0].min(dst[0]),
                    bounds[1].min(dst[1]),
                    bounds[2].max(dst[0] + dst[2]),
                    bounds[3].max(dst[1] + dst[3]),
                ];
            };
            let impacts: Vec<LayerBind> =
                plan.impacts.iter().map(|cb| self.make_bind(cb, None, &dummy)).collect();

            let sprites = scene_ref
                .as_ref()
                .map(|s| s.cursor.cursor_sprites.clone())
                .unwrap_or_default();
            let sprite = plan
                .cursor_type
                .as_deref()
                .and_then(|t| sprites.get(t))
                .or_else(|| sprites.get("arrow"))?;
            // Charge (ou recupere du cache) le sprite.
            let (tex, iw, ih) = match self.cached_image(&sprite.path) {
                Ok(v) => v,
                Err(e) => {
                    eprintln!("[curseur] sprite \"{}\" : {e:#}", sprite.path);
                    return None;
                }
            };
            // Ratio preserve : le sprite tient dans un carre de `size_px` de cote.
            let ar = iw as f32 / ih.max(1) as f32;
            let (pw, ph) = if ar >= 1.0 {
                (plan.size_px, plan.size_px / ar)
            } else {
                (plan.size_px * ar, plan.size_px)
            };
            let hotspot = [sprite.hotspot_x, sprite.hotspot_y];
            let view = tex.create_view(&wgpu::TextureViewDescriptor::default());

            // Curseur modelise (mode 15) : ce meme sprite extrude, `plan_cursor` en a tire la
            // pose. La copie de l'image composee au binding 1 (texY), que refracte le cristal de
            // Prism Glow, le champ au binding 4 (texMask), le sprite au binding 6 (texDof).
            // Parite Windows/macOS.
            if let Some(pose) = plan.model {
                match self.cursor_sdf(&sprite.path) {
                    Ok((sdf, shape)) => {
                        let shape = crate::frame_geometry::model_shape(sprite, shape);
                        let sdf_view = sdf.create_view(&wgpu::TextureViewDescriptor::default());
                        for placement in placements {
                            let Some(cb) = cursor_model_cb(
                                placement,
                                plan.size_px,
                                pose,
                                shape,
                                plan.alpha,
                                plan.clip,
                            ) else {
                                continue;
                            };
                            binds.push(self.make_bind_b4(
                                &cb,
                                Some((&self.ann_copy_view, &dummy, &dummy)),
                                &dummy,
                                Some(&sdf_view),
                                Some(&view),
                            ));
                            grow(cb.dst);
                        }
                        return (!binds.is_empty()).then_some(CursorDraw {
                            _tex: vec![(tex, view), (sdf, sdf_view)],
                            binds,
                            bounds,
                            impacts,
                            glass: plan.glass,
                        });
                    }
                    Err(e) => eprintln!("[curseur] champ de \"{}\" : {e:#}", sprite.path),
                }
            }

            // Le verre a plat de Glass Lens (mode 19) : la copie de l'image composee qu'il
            // refracte au binding 1 (texY), comme le cristal du mode 15. Parite Windows/macOS.
            if let Some(name) = sprite.glass.as_deref().filter(|_| plan.model.is_none()) {
                for placement in placements {
                    let Some(cb) =
                        cursor_glass_cb(placement, plan.size_px, name, plan.alpha, plan.clip, [rw, rh])
                    else {
                        continue;
                    };
                    binds.push(self.make_bind(&cb, Some((&self.ann_copy_view, &dummy, &dummy)), &dummy));
                    grow(cb.dst);
                }
                return (!binds.is_empty()).then_some(CursorDraw {
                    _tex: vec![(tex, view)],
                    binds,
                    bounds,
                    impacts,
                    glass: plan.glass,
                });
            }

            for placement in placements {
                // Geometrie partagee avec Windows et macOS (`cursor_sprite_cb`) :
                // mode 7 droit, ou mode 13 pose sur le plan -- le clip vit alors
                // dans `dst_prev`.
                let cb = cursor_sprite_cb(
                    placement,
                    [pw, ph],
                    hotspot,
                    plan.alpha,
                    plan.clip,
                    [rw, rh],
                );
                // Sprite RGBA au binding 1 (texY) que le mode 7 echantillonne.
                binds.push(self.make_bind(&cb, Some((&view, &view, &view)), &dummy));
                grow(cb.dst);
            }
            Some(CursorDraw {
                _tex: vec![(tex, view)],
                binds,
                bounds,
                impacts,
                glass: false,
            })
        })();
        // Bind group de la passe de composition d'`accum` (layout du blur :
        // uniform + texture + sampler). Construit hors de la pass, comme les
        // autres. L'uniforme n'est pas lu par `fs_copy` mais le layout l'exige.
        let accum_bind = cursor_draw
            .as_ref()
            .filter(|c| c.binds.len() > 1)
            .map(|_| {
                let cb = LayerCB::default();
                let uniform =
                    self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                        label: Some("accum-copy-uniform"),
                        contents: layer_bytes(&cb),
                        usage: wgpu::BufferUsages::UNIFORM,
                    });
                let bind = self.gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
                    label: Some("accum-copy"),
                    layout: &self.blur_bgl,
                    entries: &[
                        wgpu::BindGroupEntry {
                            binding: 0,
                            resource: uniform.as_entire_binding(),
                        },
                        wgpu::BindGroupEntry {
                            binding: 1,
                            resource: wgpu::BindingResource::TextureView(&self.accum_view),
                        },
                        wgpu::BindGroupEntry {
                            binding: 2,
                            resource: wgpu::BindingResource::Sampler(&self.sampler),
                        },
                    ],
                });
                (uniform, bind)
            });

        let mut encoder = self.gpu.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
            label: Some("compose"),
        });
        // Passe 0 : pyramide de profondeur de champ, niveau 0 vide d'abord (le « over »
        // rend alors la source telle quelle), puis ses mips.
        if let (Some(p), Some(fill)) = (dof_pyramid, &dof_fill) {
            {
                let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                    label: Some("dof-pyramid-pass"),
                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                        view: &p.mips[0],
                        resolve_target: None,
                        ops: wgpu::Operations {
                            load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
                            store: wgpu::StoreOp::Store,
                        },
                    })],
                    depth_stencil_attachment: None,
                    timestamp_writes: None,
                    occlusion_query_set: None,
                });
                rpass.set_pipeline(&self.pipeline);
                self.draw_layer(&mut rpass, fill, false);
            }
            self.generate_mips(&mut encoder, &p.mips);
        }
        // Passe 0 bis : l'ecran cadre, isole sur transparent, quand il est floute en bloc.
        if trail.is_some() {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("screen-trail-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &self.trail_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline);
            self.draw_screen_group(&mut rpass, &screen_shadow, &window_frame, &screen_bind, &device_frame);
        }
        // Passe 1 : fond (clear a `bg_clear` + gradient mode 5 eventuel) puis son flou -- ou, s'il
        // n'a pas change (`BackgroundKey`), la copie qu'en a gardee la frame d'avant.
        let extent = wgpu::Extent3d {
            width: self.render_w,
            height: self.render_h,
            depth_or_array_layers: 1,
        };
        if bg_cached {
            let cache = self.bg_cache.borrow();
            let tex = &cache.as_ref().expect("bg_cached").tex;
            encoder.copy_texture_to_texture(tex.as_image_copy(), self.rt.as_image_copy(), extent);
        } else {
            {
                let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                    label: Some("bg-pass"),
                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                        view: &self.rt_view,
                        resolve_target: None,
                        ops: wgpu::Operations {
                            load: wgpu::LoadOp::Clear(wgpu::Color {
                                r: bg_clear[0] as f64,
                                g: bg_clear[1] as f64,
                                b: bg_clear[2] as f64,
                                a: bg_clear[3] as f64,
                            }),
                            store: wgpu::StoreOp::Store,
                        },
                    })],
                    depth_stencil_attachment: None,
                    timestamp_writes: None,
                    occlusion_query_set: None,
                });
                if let Some(bg) = &bg_draw {
                    rpass.set_pipeline(&self.pipeline);
                    self.draw_layer(&mut rpass, &bg.layer, false);
                }
            }
            // Blur du fond (avant l'ecran), si active par la scene/l'inspector.
            self.blur_bg(&mut encoder, cfg.bg_blur);
            // Pas de cache pour un fond anime, ni pour un fond qui n'a pas pu se charger : la frame
            // suivante reessaie.
            let key = (bg_draw.is_some() == bg_wanted)
                .then(|| {
                    crate::frame_geometry::BackgroundKey::of(bg_desc, cfg.bg_blur, lp.bg_color, [rw, rh])
                })
                .flatten();
            if let Some(key) = key {
                let mut cache = self.bg_cache.borrow_mut();
                let tex = match cache.take() {
                    Some(c) if c.tex.size() == extent => c.tex,
                    _ => self.gpu.device.create_texture(&wgpu::TextureDescriptor {
                        label: Some("bg-cache"),
                        size: extent,
                        mip_level_count: 1,
                        sample_count: 1,
                        dimension: wgpu::TextureDimension::D2,
                        format: wgpu::TextureFormat::Rgba8Unorm,
                        usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST,
                        view_formats: &[],
                    }),
                };
                encoder.copy_texture_to_texture(self.rt.as_image_copy(), tex.as_image_copy(), extent);
                *cache = Some(BgCache { key, tex });
            }
        }
        // Passe 2 : l'ecran, compose par-dessus le fond (eventuellement floute) avec
        // `LoadOp::Load`. Puis les flous de confidentialite, le curseur, la camera et les autres
        // annotations, dans cet ordre : celui de Windows et macOS.
        {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("fg-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &self.rt_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Load,
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline);
            // Chaque ombre est dessinee JUSTE AVANT le calque qu'elle porte :
            // elle doit passer sous lui mais au-dessus du fond (et, pour la
            // camera, au-dessus de l'ecran).
            match &trail {
                Some(layer) => self.draw_layer(&mut rpass, layer, false),
                None => self.draw_screen_group(
                    &mut rpass,
                    &screen_shadow,
                    &window_frame,
                    &screen_bind,
                    &device_frame,
                ),
            }
        }
        // Fige la frame composee pour les annotations « flou ». ICI et nulle part
        // ailleurs : apres l'ecran (sinon un flou masquerait du vide)
        // et avant le premier flou (sinon deux flous qui se recouvrent
        // s'echantillonnent l'un l'autre). Une passe de rendu ne peut pas lire sa
        // propre cible, d'ou la copie -- et d'ou le fait que les annotations
        // doivent avoir leur propre passe.
        if needs_ann_copy {
            self.generate_ann_mips(&mut encoder);
        }
        // Passe 2 bis : les flous de confidentialite, sur le metrage, AVANT le curseur (parite
        // Windows et macOS). Le curseur reste net par-dessus, et le cristal de Prism Glow, qui
        // refracte l'image composee, n'y voit que des pixels deja floutes.
        if !privacy_draws.is_empty() {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("privacy-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &self.rt_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Load,
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline);
            for a in &privacy_draws {
                self.draw_layer(&mut rpass, &a.layer, false);
            }
        }
        // Le cristal de Prism Glow refracte l'image telle qu'elle est composee a cet instant,
        // flous compris : sa copie dans `ann_copy` (libre, les flous l'ont deja lue ; le mip 0
        // suffit), une fois pour toutes les copies de la trainee.
        if cursor_draw.as_ref().is_some_and(|c| c.glass) {
            encoder.copy_texture_to_texture(
                self.rt.as_image_copy(),
                self.ann_copy.as_image_copy(),
                wgpu::Extent3d { width: self.render_w, height: self.render_h, depth_or_array_layers: 1 },
            );
        }
        // Le curseur net, et l'impact des clics sous lui. La trainee, elle, a besoin de sa
        // propre cible : elle suit.
        {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("cursor-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &self.rt_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Load,
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline);
            // L'impact des clics, sous le curseur et sa trainee (dessinee plus bas).
            for layer in cursor_draw.iter().flat_map(|c| &c.impacts) {
                self.draw_layer(&mut rpass, layer, false);
            }
            if let Some(c) = cursor_draw.as_ref().filter(|c| c.binds.len() == 1) {
                self.draw_layer(&mut rpass, &c.binds[0], false);
            }
        }
        // TRAINEE DU CURSEUR : flou REEL, pas des copies discretes.
        //
        // Les N echantillons s'accumulent dans une cible ISOLEE partie de zero,
        // puis sont compositees « over » sur la scene. Les additionner
        // directement sur le RT reviendrait a AJOUTER la couleur du curseur
        // (souvent du blanc) a ce qui est deja dessous : sur un fond clair, deja
        // proche du blanc, ajouter du blanc*(1/taps) ne change presque rien --
        // curseur quasi invisible. Dans une cible a part la somme reste
        // correctement normalisee (alpha ~1 la ou les copies se recouvrent), et
        // la composition finale est un « over » ordinaire, correct quel que soit
        // le fond. Meme raisonnement, mot pour mot, cote macOS et Windows.
        if let (Some(c), Some((_ubuf, abind))) = (
            cursor_draw.as_ref().filter(|c| c.binds.len() > 1),
            accum_bind.as_ref(),
        ) {
            {
                let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                    label: Some("cursor-accum-pass"),
                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                        view: &self.accum_view,
                        resolve_target: None,
                        ops: wgpu::Operations {
                            // Le clear EST la raison d'etre de cette cible : elle
                            // doit partir vide a chaque frame, pas cumuler.
                            load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
                            store: wgpu::StoreOp::Store,
                        },
                    })],
                    depth_stencil_attachment: None,
                    timestamp_writes: None,
                    occlusion_query_set: None,
                });
                rpass.set_pipeline(&self.pipeline_add);
                for (k, layer) in c.binds.iter().enumerate() {
                    let w = crate::frame_geometry::cursor_tap_weight(k as u32, c.binds.len() as u32) as f64;
                    rpass.set_blend_constant(wgpu::Color { r: w, g: w, b: w, a: w });
                    self.draw_layer(&mut rpass, layer, true);
                }
            }
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("cursor-accum-composite"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &self.rt_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Load,
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            // Rien n'a ete peint dans `accum` hors des quads de la trainee : la recopie s'y borne
            // au lieu de repasser sur toute la sortie, ce qui coutait 0,5 ms par frame 1080p
            // (Radeon 610M) pour un curseur de quelques dizaines de pixels.
            let (w, h) = (self.render_w as f32, self.render_h as f32);
            let x0 = (c.bounds[0] * w).floor().clamp(0.0, w) as u32;
            let y0 = (c.bounds[1] * h).floor().clamp(0.0, h) as u32;
            let x1 = (c.bounds[2] * w).ceil().clamp(0.0, w) as u32;
            let y1 = (c.bounds[3] * h).ceil().clamp(0.0, h) as u32;
            if x1 > x0 && y1 > y0 {
                rpass.set_scissor_rect(x0, y0, x1 - x0, y1 - y0);
                rpass.set_pipeline(&self.pipeline_copy);
                rpass.set_bind_group(0, abind, &[]);
                rpass.draw(0..3, 0..1);
            }
        }
        // La camera, au-dessus de l'ecran et du curseur.
        {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("webcam-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &self.rt_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Load,
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline);
            if let Some(layer) = &webcam_shadow {
                self.draw_layer(&mut rpass, layer, false);
            }
            // Fond personnalise : ENTRE l'ombre et la camera. C'est ce sandwich qui
            // remplace la branche « mode 3 » du shader — la camera, decoupee, se
            // fond dessus par alpha ; l'ombre reste dessous, elle appartient a la
            // bulle et non a son contenu.
            if let Some(bg) = &webcam_bg {
                self.draw_layer(&mut rpass, &bg.layer, false);
            }
            if let Some(layer) = &webcam_draw {
                self.draw_layer(&mut rpass, layer, false);
            }
        }
        // Effets shader de l'agent, autour des textes selon leur cible (`docs/shader-effects.md`,
        // D.1) : `image` avant les annotations, `text` sur un calque des textes a part, `both` sur
        // l'image finale. Meme ordre que `compositor_windows.rs`.
        let fx_inputs = crate::shader_fx::FxFrameInputs {
            cursor: fx_pointer.cursor,
            clicks: fx_pointer.clicks,
            footage: g.footage_quad([rw, rh]),
            footage_aspect: g.footage_aspect([rw, rh]),
            camera: lp.has_webcam.then_some(g.w_dst),
        };
        let effects = scene_ref
            .as_ref()
            .map(|s| crate::shader_fx::active_effects(&s.shader_effects, g.source_t))
            .unwrap_or_default();
        let fx_context = |e: &SceneShaderEffect| {
            crate::shader_fx::context(e, g.source_t, g.programme_t, [rw, rh], &fx_inputs)
        };
        let with_target = |target: ShaderEffectTarget| -> Vec<&SceneShaderEffect> {
            effects.iter().copied().filter(|e| e.target == target).collect()
        };
        // L'enregistrement a sa resolution, peint une fois pour la frame si un effet le lit.
        let footage = effects
            .iter()
            .any(|e| crate::shader_fx::reads_footage(e))
            .then(|| self.encode_footage_copy(&mut encoder, (&sy, &su, &sv), g.content_cut, stw, sth));
        for e in with_target(ShaderEffectTarget::Image) {
            self.encode_shader_effect(&mut encoder, e, (&self.rt, &self.rt_view), &fx_context(e), footage.as_ref());
        }
        // Un effet `text` : les textes sur un calque transparent, l'effet sur ce calque seul, puis
        // le calque pose sur l'image (« over » premultiplie). L'image dessous reste intacte.
        let text_effects = with_target(ShaderEffectTarget::Text);
        let text_layer = (!text_effects.is_empty()).then(|| self.text_layer());
        // Passe 3 : les autres annotations, par-dessus tout le reste (les flous sont passes avant
        // le curseur). Elle existe meme sans annotation : deux passes consecutives sur la MEME
        // cible avec `LoadOp::Load` ne coutent rien de plus qu'une seule sur un GPU desktop, et un
        // seul chemin de code vaut mieux qu'un branchement qui ne serait exerce que dans un projet
        // sur dix.
        {
            let (view, load) = match &text_layer {
                Some((_, view)) => (view, wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT)),
                None => (&self.rt_view, wgpu::LoadOp::Load),
            };
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("ann-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view,
                    resolve_target: None,
                    ops: wgpu::Operations { load, store: wgpu::StoreOp::Store },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline);
            for a in &ann_draws {
                self.draw_layer(&mut rpass, &a.layer, false);
            }
        }
        if let Some((tex, view)) = &text_layer {
            for e in text_effects {
                self.encode_shader_effect(&mut encoder, e, (tex, view), &fx_context(e), footage.as_ref());
            }
            // Le calque pose sur le RT par la passe qui recopie `accum` : layout du blur, et un
            // uniforme que `fs_copy` ne lit pas.
            let uniform = self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                label: Some("text-layer-uniform"),
                contents: layer_bytes(&LayerCB::default()),
                usage: wgpu::BufferUsages::UNIFORM,
            });
            let bind = self.gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
                label: Some("text-layer"),
                layout: &self.blur_bgl,
                entries: &[
                    wgpu::BindGroupEntry { binding: 0, resource: uniform.as_entire_binding() },
                    wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(view) },
                    wgpu::BindGroupEntry {
                        binding: 2,
                        resource: wgpu::BindingResource::Sampler(&self.sampler),
                    },
                ],
            });
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("text-layer-composite"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &self.rt_view,
                    resolve_target: None,
                    ops: wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&self.pipeline_copy);
            rpass.set_bind_group(0, &bind, &[]);
            rpass.draw(0..3, 0..1);
        }
        for e in with_target(ShaderEffectTarget::Both) {
            self.encode_shader_effect(&mut encoder, e, (&self.rt, &self.rt_view), &fx_context(e), footage.as_ref());
        }
        self.gpu.context.submit(std::iter::once(encoder.finish()));
        Ok(())
    }

    /// Clear le RT a la couleur de fond (ecran absent).
    fn clear_rt(&self) -> Result<()> {
        let bg = self.live_params.borrow().bg_color;
        let mut encoder = self.gpu.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
            label: Some("clear"),
        });
        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            label: Some("clear-pass"),
            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                view: &self.rt_view,
                resolve_target: None,
                ops: wgpu::Operations {
                    load: wgpu::LoadOp::Clear(wgpu::Color {
                        r: bg[0] as f64,
                        g: bg[1] as f64,
                        b: bg[2] as f64,
                        a: bg[3] as f64,
                    }),
                    store: wgpu::StoreOp::Store,
                },
            })],
            depth_stencil_attachment: None,
            timestamp_writes: None,
            occlusion_query_set: None,
        });
        self.gpu.context.submit(std::iter::once(encoder.finish()));
        Ok(())
    }

    fn dummy_view(&self) -> wgpu::TextureView {
        let t = self.gpu.device.create_texture(&wgpu::TextureDescriptor {
            label: Some("dummy"),
            size: wgpu::Extent3d {
                width: 1,
                height: 1,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::R8Unorm,
            usage: wgpu::TextureUsages::TEXTURE_BINDING,
            view_formats: &[],
        });
        t.create_view(&wgpu::TextureViewDescriptor::default())
    }

    /// Regle la profondeur de la ring de staging. A appeler AVANT la premiere
    /// relecture (elle vide la ring, donc toute frame encore en vol serait
    /// perdue -- d'ou le drain explicite plutot qu'un silence).
    ///
    /// POLITIQUE PAR CHEMIN, et c'est volontaire :
    ///
    /// - **Export** (`pipeline_linux::run_composited_multi`) : profondeur 2. Il
    ///   ne veut que du DEBIT, la latence d'une frame ne se voit nulle part
    ///   puisque la sortie est un fichier. Il draine la ring a la fin, donc
    ///   aucune frame ne manque au montage.
    /// - **Preview live** (`live.rs`) : profondeur 1, inchangee. Une frame de
    ///   retard y est perceptible -- le canvas afficherait l'avant-derniere
    ///   frame composee, et surtout la boucle ne relit QUE quand elle a avance
    ///   (`stepped`) : au repos (fin d'un scrub, pause) la derniere frame
    ///   resterait coincee dans la ring et le canvas figerait sur la
    ///   precedente jusqu'au prochain evenement. Le pipeline demanderait donc
    ///   un drain sur inactivite pour n'etre que neutre visuellement, pour un
    ///   gain qui n'est pas le goulot mesure ici. On ne l'impose pas.
    ///
    /// A profondeur 1 le chemin est exactement l'ancien : soumettre, attendre,
    /// mapper, depadder.
    pub fn set_readback_depth(&self, depth: usize) -> Result<()> {
        let depth = depth.max(1);
        // Draine d'abord : les frames en vol appartiennent a l'appelant
        // precedent, les jeter en silence serait une perte de donnees muette.
        while unsafe { self.readback_take()? }.is_some() {}
        let mut ring = self.readback.borrow_mut();
        ring.depth = depth;
        while ring.free.len() > depth {
            ring.free.pop();
        }
        while ring.free.len() < depth {
            let buf = Self::make_staging(&self.gpu, self.readback_bpr, self.render_h);
            ring.free.push(buf);
        }
        Ok(())
    }

    /// Construit (ou reconstruit apres resize) les cibles et pipelines YUV.
    fn ensure_yuv(&self) -> Result<()> {
        // I420 par defaut : c'est le seul format que l'encodeur software sait
        // lire, donc le seul que l'export utilise aujourd'hui.
        self.ensure_yuv_fmt(YuvFormat::I420)
    }

    /// La disposition du buffer de staging pour un format donne, sans rien
    /// construire. Existe pour que le test puisse verifier l'arithmetique sans
    /// GPU — c'est elle qui doit correspondre a ce que VAAPI attend, et une
    /// erreur d'un octet y donnerait une image decalee plutot qu'une panne.
    pub fn yuv_layout_for(w: u32, h: u32, fmt: YuvFormat) -> (u32, u32, u64, u64) {
        let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));
        let bpr_y = w.div_ceil(256) * 256;
        let chroma_row_bytes = match fmt {
            YuvFormat::I420 => cw,
            YuvFormat::Nv12 => cw * 2,
        };
        let bpr_uv = chroma_row_bytes.div_ceil(256) * 256;
        let size_y = u64::from(bpr_y) * u64::from(h);
        let size_uv = u64::from(bpr_uv) * u64::from(ch);
        let total = match fmt {
            YuvFormat::I420 => size_y + 2 * size_uv,
            YuvFormat::Nv12 => size_y + size_uv,
        };
        (bpr_y, bpr_uv, size_y, total)
    }

    /// Comme `ensure_yuv`, pour un format donne. Reconstruit tout si le format
    /// change : les cibles, les pipelines et la disposition du buffer en
    /// dependent toutes.
    fn ensure_yuv_fmt(&self, fmt: YuvFormat) -> Result<()> {
        let (w, h) = (self.render_w, self.render_h);
        if let Some(t) = self.yuv.borrow().as_ref() {
            if t.w == w && t.h == h && t.fmt == fmt {
                return Ok(());
            }
        }
        // 4:2:0 : les plans de chrominance font la moitie, arrondie au superieur
        // pour ne jamais perdre la derniere colonne/ligne d'une dimension impaire.
        let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));
        let gpu = &self.gpu;

        let mk = |label: &str, tw: u32, th: u32, f: wgpu::TextureFormat| {
            gpu.device.create_texture(&wgpu::TextureDescriptor {
                label: Some(label),
                size: wgpu::Extent3d { width: tw, height: th, depth_or_array_layers: 1 },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: f,
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
                view_formats: &[],
            })
        };
        let r8 = wgpu::TextureFormat::R8Unorm;
        let y = mk("yuv-y", w, h, r8);
        let y_view = y.create_view(&wgpu::TextureViewDescriptor::default());

        let module = gpu.device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("yuv"),
            source: wgpu::ShaderSource::Wgsl(include_str!("vk_shaders/yuv.wgsl").into()),
        });
        let bgl = gpu.device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("yuv-bgl"),
            entries: &[
                wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Texture {
                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
                        view_dimension: wgpu::TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 1,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                    count: None,
                },
            ],
        });
        // Sampler LINEAIRE : c'est lui qui fait le sous-echantillonnage 2x2 des
        // plans de chrominance. Avec un `Nearest` on prendrait un pixel sur
        // quatre au lieu de leur moyenne, ce qui aliase visiblement les bords.
        let samp = gpu.device.create_sampler(&wgpu::SamplerDescriptor {
            label: Some("yuv-samp"),
            mag_filter: wgpu::FilterMode::Linear,
            min_filter: wgpu::FilterMode::Linear,
            ..Default::default()
        });
        let bind = gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("yuv-bg"),
            layout: &bgl,
            entries: &[
                wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&self.rt_view) },
                wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&samp) },
            ],
        });
        let layout = gpu.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("yuv-pl"),
            bind_group_layouts: &[&bgl],
            push_constant_ranges: &[],
        });
        let mk_pipe = |entry: &str, label: &str, target: wgpu::TextureFormat| {
            gpu.device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                label: Some(label),
                layout: Some(&layout),
                vertex: wgpu::VertexState {
                    module: &module,
                    entry_point: Some("vs_fullscreen"),
                    compilation_options: wgpu::PipelineCompilationOptions::default(),
                    buffers: &[],
                },
                fragment: Some(wgpu::FragmentState {
                    module: &module,
                    entry_point: Some(entry),
                    compilation_options: wgpu::PipelineCompilationOptions::default(),
                    targets: &[Some(wgpu::ColorTargetState {
                        format: target,
                        blend: None,
                        write_mask: wgpu::ColorWrites::ALL,
                    })],
                }),
                primitive: wgpu::PrimitiveState {
                    topology: wgpu::PrimitiveTopology::TriangleList,
                    ..Default::default()
                },
                depth_stencil: None,
                multisample: wgpu::MultisampleState::default(),
                multiview: None,
                cache: None,
            })
        };

        let bpr_y = w.div_ceil(256) * 256;
        // La LARGEUR EN OCTETS d'une ligne de chrominance, pas en texels : en NV12
        // le plan est `Rg8Unorm`, donc 2 octets par texel. En 1080p, I420 donne
        // 960 -> 1024 et NV12 1920 -> 2048.
        let chroma_row_bytes = match fmt {
            YuvFormat::I420 => cw,
            YuvFormat::Nv12 => cw * 2,
        };
        let bpr_uv = chroma_row_bytes.div_ceil(256) * 256;
        let size_y = u64::from(bpr_y) * u64::from(h);
        let size_uv = u64::from(bpr_uv) * u64::from(ch);
        let (chroma, off_v, total) = match fmt {
            YuvFormat::I420 => {
                let u = mk("yuv-u", cw, ch, r8);
                let v = mk("yuv-v", cw, ch, r8);
                let d = wgpu::TextureViewDescriptor::default();
                let (u_view, v_view) = (u.create_view(&d), v.create_view(&d));
                (
                    Chroma::Planar {
                        _u: u,
                        _v: v,
                        u_view,
                        v_view,
                        pipe_u: mk_pipe("fs_u", "yuv-u", r8),
                        pipe_v: mk_pipe("fs_v", "yuv-v", r8),
                    },
                    size_y + size_uv,
                    size_y + 2 * size_uv,
                )
            }
            YuvFormat::Nv12 => {
                let rg8 = wgpu::TextureFormat::Rg8Unorm;
                let uv = mk("yuv-uv", cw, ch, rg8);
                let uv_view = uv.create_view(&wgpu::TextureViewDescriptor::default());
                (
                    Chroma::Interleaved {
                        _uv: uv,
                        uv_view,
                        pipe_uv: mk_pipe("fs_uv", "yuv-uv", rg8),
                    },
                    // Un seul plan de chrominance : `off_v` duplique `off_u` et
                    // n'est jamais lu (cf. le commentaire du champ).
                    size_y,
                    size_y + size_uv,
                )
            }
        };
        let targets = YuvTargets {
            _y: y,
            y_view,
            chroma,
            fmt,
            bind,
            pipe_y: mk_pipe("fs_y", "yuv-y", r8),
            w,
            h,
            bpr_y,
            bpr_uv,
            off_u: size_y,
            off_v,
            total,
        };
        // Les buffers de l'ancienne taille ne conviennent plus.
        self.readback_yuv.borrow_mut().free.clear();
        *self.yuv.borrow_mut() = Some(targets);
        Ok(())
    }

    /// Pendant YUV de `readback_submit` : convertit le RT en Y/U/V sur le GPU,
    /// copie les trois plans dans UN buffer de staging, et recolte la frame
    /// precedente. Meme contrat de ring et de profondeur que la version RGBA.
    ///
    /// Rend les plans avec leur padding : `(w, h, buf)` ou `buf` contient Y a
    /// l'offset 0 (stride `align256(w)`), puis U et V (stride `align256(w/2)`).
    /// L'appelant recalcule ces strides depuis `w`/`h` — les depadder ici
    /// couterait une recopie de plus pour rien, l'encodeur sachant lire un
    /// `linesize`.
    pub unsafe fn readback_submit_yuv<F>(&self, f: F) -> Result<bool>
    where
        F: FnMut(u32, u32, &[u8]) -> Result<()>,
    {
        self.ensure_yuv()?;
        let (w, h, cw, ch, bpr_y, bpr_uv, off_u, off_v, total) = {
            let g = self.yuv.borrow();
            let t = g.as_ref().expect("ensure_yuv");
            (t.w, t.h, t.w.div_ceil(2), t.h.div_ceil(2), t.bpr_y, t.bpr_uv, t.off_u, t.off_v, t.total)
        };

        let buf = {
            let mut ring = self.readback_yuv.borrow_mut();
            match ring.free.pop() {
                Some(b) => b,
                None => self.gpu.device.create_buffer(&wgpu::BufferDescriptor {
                    label: Some("readback-yuv"),
                    size: total,
                    usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
                    mapped_at_creation: false,
                }),
            }
        };

        let mut encoder = self
            .gpu
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("yuv-convert") });
        {
            let g = self.yuv.borrow();
            let t = g.as_ref().expect("ensure_yuv");
            // Une passe par plan : Y toujours, puis U et V separement (I420) ou
            // un seul plan entrelace (NV12).
            let mut passes: Vec<(&wgpu::TextureView, &wgpu::RenderPipeline)> =
                vec![(&t.y_view, &t.pipe_y)];
            match &t.chroma {
                Chroma::Planar { u_view, v_view, pipe_u, pipe_v, .. } => {
                    passes.push((u_view, pipe_u));
                    passes.push((v_view, pipe_v));
                }
                Chroma::Interleaved { uv_view, pipe_uv, .. } => passes.push((uv_view, pipe_uv)),
            }
            for (view, pipe) in passes {
                let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                    label: Some("yuv-plane"),
                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                        view,
                        resolve_target: None,
                        ops: wgpu::Operations {
                            // Chaque passe reecrit chaque texel : `Load` ferait lire
                            // une cible dont on va ecraser le contenu.
                            load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
                            store: wgpu::StoreOp::Store,
                        },
                    })],
                    depth_stencil_attachment: None,
                    timestamp_writes: None,
                    occlusion_query_set: None,
                });
                pass.set_pipeline(pipe);
                pass.set_bind_group(0, &t.bind, &[]);
                pass.draw(0..3, 0..1);
            }
            // `pw` est en TEXELS (`copy_texture_to_buffer` veut une extent), et
            // `bpr` en octets : en NV12 le plan de chrominance fait `cw` texels de
            // 2 octets, d'ou le meme `cw` avec un `bpr_uv` deux fois plus grand.
            let mut copies: Vec<(&wgpu::Texture, u64, u32, u32, u32)> =
                vec![(&t._y, 0u64, bpr_y, w, h)];
            match &t.chroma {
                Chroma::Planar { _u, _v, .. } => {
                    copies.push((_u, off_u, bpr_uv, cw, ch));
                    copies.push((_v, off_v, bpr_uv, cw, ch));
                }
                Chroma::Interleaved { _uv, .. } => copies.push((_uv, off_u, bpr_uv, cw, ch)),
            }
            for (tex, off, bpr, pw, ph) in copies {
                encoder.copy_texture_to_buffer(
                    wgpu::TexelCopyTextureInfo {
                        texture: tex,
                        mip_level: 0,
                        origin: wgpu::Origin3d::ZERO,
                        aspect: wgpu::TextureAspect::All,
                    },
                    wgpu::TexelCopyBufferInfo {
                        buffer: &buf,
                        layout: wgpu::TexelCopyBufferLayout {
                            offset: off,
                            bytes_per_row: Some(bpr),
                            rows_per_image: Some(ph),
                        },
                    },
                    wgpu::Extent3d { width: pw, height: ph, depth_or_array_layers: 1 },
                );
            }
        }

        let idx = self.gpu.context.submit(std::iter::once(encoder.finish()));
        let (tx, rx) = std::sync::mpsc::channel();
        buf.slice(..).map_async(wgpu::MapMode::Read, move |r| {
            let _ = tx.send(r);
        });
        {
            let mut ring = self.readback_yuv.borrow_mut();
            ring.pending.push_back(PendingCopy { buf, idx, rx, w, h, bpr: bpr_y });
            if ring.pending.len() < ring.depth {
                return Ok(false); // amorcage, comme la ring RGBA
            }
        }
        self.readback_take_yuv_with(f)
    }

    /// Recolte la plus ancienne conversion en vol et la PRESENTE au lecteur sans
    /// la copier : `f` recoit la vue mappee telle quelle, lignes paddees a 256
    /// comprises. Rend `false` si la ring est vide. Pendant de `readback_take`.
    ///
    /// POURQUOI UNE CLOSURE, ET PAS UN `Vec` RENDU. La version precedente faisait
    /// `mapped.to_vec()` — 3,3 Mo alloues, copies puis liberes par frame, soit
    /// 11,9 Go de va-et-vient sur un export de 3600 frames — dans le seul but que
    /// la donnee survive a l'`unmap`. Or l'appelant la recopie immediatement dans
    /// l'AVFrame de l'encodeur : la copie intermediaire ne servait que la
    /// signature. Avec une closure, le lecteur travaille dans la fenetre ou le
    /// buffer est mappe et il n'y a plus qu'une seule copie sur le chemin.
    ///
    /// LE SLOT EST RENDU MEME SI `f` ECHOUE. Autrement une erreur d'encodage
    /// laisserait le buffer mappe et hors de la ring : la frame suivante en
    /// allouerait un neuf, et ainsi de suite jusqu'a epuisement de la memoire
    /// mappable — un mode de panne bien pire que l'erreur d'origine.
    pub unsafe fn readback_take_yuv_with<F>(&self, mut f: F) -> Result<bool>
    where
        F: FnMut(u32, u32, &[u8]) -> Result<()>,
    {
        let Some(p) = self.readback_yuv.borrow_mut().pending.pop_front() else {
            return Ok(false);
        };
        self.gpu.device.poll(wgpu::Maintain::WaitForSubmissionIndex(p.idx));
        p.rx
            .recv()
            .map_err(|_| anyhow::anyhow!("map_async channel (yuv)"))?
            .map_err(|e| anyhow::anyhow!("map_async yuv: {e:?}"))?;
        // `mapped` et `slice` meurent a la fin du bloc : `unmap` ne peut donc pas
        // etre appele pendant qu'une vue est encore accessible (wgpu l'assert).
        let r = {
            let slice = p.buf.slice(..);
            let mapped = slice.get_mapped_range();
            f(p.w, p.h, &mapped)
        };
        p.buf.unmap();
        self.readback_yuv.borrow_mut().free.push(p.buf);
        r.map(|()| true)
    }

    /// Profondeur de la ring YUV. Meme role et memes raisons que
    /// `set_readback_depth` pour la ring RGBA.
    pub fn set_readback_yuv_depth(&self, depth: usize) -> Result<()> {
        let depth = depth.max(1);
        // SAFETY : meme contrat que `set_readback_depth` — le drain ne touche que
        // des buffers dont la soumission est terminee.
        while unsafe { self.readback_take_yuv_with(|_, _, _| Ok(()))? } {}
        let mut ring = self.readback_yuv.borrow_mut();
        ring.depth = depth;
        while ring.free.len() > depth {
            ring.free.pop();
        }
        Ok(())
    }

    /// Soumet la copie RT -> staging de la frame COURANTE sans l'attendre, puis
    /// rend la frame la plus ancienne encore en vol des que la ring est pleine.
    ///
    /// PREMIERES FRAMES. Tant que moins de `depth` copies sont en vol, il n'y a
    /// rien a rendre et la reponse est `Ok(None)` : c'est l'amorcage du
    /// pipeline, et il coute exactement `depth - 1` frames de decalage (0 a
    /// profondeur 1). L'appelant ne doit donc PAS supposer une frame par appel,
    /// mais drainer a la fin (`readback_take`) -- sinon les `depth - 1`
    /// dernieres frames composees ne sortiraient jamais.
    pub unsafe fn readback_submit(&self) -> Result<Option<(u32, u32, Vec<u8>)>> {
        let (w, h) = (self.render_w, self.render_h);
        let bpr = self.readback_bpr;
        // Invariant : cette fonction recolte toujours des que `pending` atteint
        // `depth`, donc un buffer est libre a chaque entree. Un echec ici
        // signalerait une ring desynchronisee -- on le dit plutot que d'allouer
        // 8 Mo de plus en silence a chaque frame.
        let buf = self
            .readback
            .borrow_mut()
            .free
            .pop()
            .ok_or_else(|| anyhow::anyhow!("staging ring saturee (aucun buffer libre)"))?;

        let mut encoder = self.gpu.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
            label: Some("readback"),
        });
        encoder.copy_texture_to_buffer(
            wgpu::TexelCopyTextureInfo {
                texture: &self.rt,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            wgpu::TexelCopyBufferInfo {
                buffer: &buf,
                layout: wgpu::TexelCopyBufferLayout {
                    offset: 0,
                    bytes_per_row: Some(bpr),
                    rows_per_image: Some(h),
                },
            },
            wgpu::Extent3d {
                width: w,
                height: h,
                depth_or_array_layers: 1,
            },
        );
        // `submit` rend l'index de soumission : c'est LUI qui permet plus tard
        // de n'attendre que cette copie-ci, au lieu de `Maintain::Wait` qui
        // draine toute la file (donc la composition qui suit).
        let idx = self.gpu.context.submit(std::iter::once(encoder.finish()));
        // `map_async` juste apres la soumission : wgpu differe le mapping
        // jusqu'a la fin de la soumission qui ecrit le buffer, le callback
        // n'est tire que par un `poll`.
        let (tx, rx) = std::sync::mpsc::channel();
        buf.slice(..).map_async(wgpu::MapMode::Read, move |r| {
            let _ = tx.send(r);
        });
        {
            let mut ring = self.readback.borrow_mut();
            ring.pending.push_back(PendingCopy { buf, idx, rx, w, h, bpr });
            if ring.pending.len() < ring.depth {
                return Ok(None); // amorcage
            }
        }
        self.readback_take()
    }

    /// Recolte la frame la plus ancienne en vol (`None` si la ring est vide).
    /// C'est le drain de fin de session : l'appeler en boucle apres la derniere
    /// `readback_submit` rend les `depth - 1` frames encore en vol.
    pub unsafe fn readback_take(&self) -> Result<Option<(u32, u32, Vec<u8>)>> {
        let Some(p) = self.readback.borrow_mut().pending.pop_front() else {
            return Ok(None);
        };
        // N'attend QUE la soumission de cette copie. A profondeur >= 2 elle est
        // terminee depuis longtemps (l'encodage de la frame precedente lui a
        // laisse ~19 ms de CPU) et l'appel rend la main immediatement.
        self.gpu.device.poll(wgpu::Maintain::WaitForSubmissionIndex(p.idx));
        p.rx
            .recv()
            .map_err(|_| anyhow::anyhow!("map_async channel"))?
            .map_err(|e| anyhow::anyhow!("map_async: {e:?}"))?;
        let slice = p.buf.slice(..);
        let mapped = slice.get_mapped_range();

        let (w, h) = (p.w, p.h);
        let row = (w * 4) as usize;
        let bpr = p.bpr as usize;
        let total = row * h as usize;

        // `Vec::with_capacity` + `extend_from_slice`, PAS `vec![0u8; total]` : ce dernier
        // memset 8 Mo (en 1080p) qu'on écrase intégralement ligne suivante. Mesuré : la
        // relecture pèse 82 % de la frame de preview, et ce zero-fill en est une part
        // gratuite à rendre.
        let mut out = Vec::with_capacity(total);
        if bpr == row {
            // Cas courant, et il n'a rien d'exotique : wgpu aligne `bytes_per_row` sur 256
            // et une largeur RGBA multiple de 64 px l'est déjà (1280 et 1920 le sont).
            // Il n'y a alors AUCUN padding à retirer, et la boucle ligne à ligne recopiait
            // un tampon identique à l'octet près en `h` memcpy au lieu d'un seul.
            out.extend_from_slice(&mapped[..total]);
        } else {
            for y in 0..h as usize {
                out.extend_from_slice(&mapped[y * bpr..y * bpr + row]);
            }
        }
        drop(mapped);
        p.buf.unmap();
        // Buffer demappe -> reutilisable au prochain `readback_submit`.
        self.readback.borrow_mut().free.push(p.buf);
        Ok(Some((w, h, out)))
    }

    /// Lit le RT en RGBA8 tightly-packed `(render_w * render_h * 4)`. Depadde le
    /// `bytes_per_row` aligne a 256 exige par wgpu.
    ///
    /// Contrat SYNCHRONE : rend la frame que le RT contient MAINTENANT. A la
    /// profondeur par defaut (1) c'est litteralement soumettre-attendre-mapper,
    /// donc le chemin d'avant la ring. A profondeur > 1 elle vide le pipeline
    /// pour honorer ce contrat -- a n'utiliser que la ou la frame courante est
    /// exigee (preview, GIF, tests), pas dans une boucle d'export.
    pub unsafe fn readback_direct(&self) -> Result<(u32, u32, Vec<u8>)> {
        let mut last = self.readback_submit()?;
        while let Some(next) = self.readback_take()? {
            last = Some(next);
        }
        last.ok_or_else(|| anyhow::anyhow!("readback_direct: aucune frame recoltee"))
    }
}

// ---------------------------------------------------------------------------
// Tests
//
// Tous rendent de VRAIS pixels sur le device de la machine, et tous sauf un se
// lisent SANS ONNX Runtime : le masque y est pose a la main par
// `set_webcam_mask` et l'inference n'est pas ce qu'ils testent. C'est delibere —
// ce que ce portage ajoute cote GPU doit etre verifiable la ou la bibliotheque
// n'est pas installee, ce qui est le cas de la CI. Meme parti que
// `compositor_macos::tests`, dont ceci est le pendant.
//
// `poc-d3d` etant `cfg(windows)`, le banc `--cfg C8 --scene` qui a prouve le
// chemin Windows n'existe pas ici : ces tests en tiennent lieu, plus le harnais
// visuel opt-in en fin de fichier pour ce qu'une assertion ne peut pas dire.
// ---------------------------------------------------------------------------
#[cfg(test)]
mod tests {
    use super::*;
    use crate::d3d::Gpu;
    use crate::ffi::AVFrame;

    /// NV12 « limited range » (BT.709), les memes valeurs que `yuv709_limited`
    /// inverse : 16 rend du noir franc, 235 du blanc franc, 128 une chroma nulle.
    const Y_WHITE: u8 = 235;
    const Y_BLACK: u8 = 16;
    const UV_NEUTRAL: u8 = 128;

    /// `create_auto` et NON `create` : la CI (`rust-linux-compositor-check`,
    /// ubuntu-latest) n'a pas de GPU et rend sur lavapipe. Avec la creation
    /// hardware-stricte, tous ces tests s'y sauteraient en silence — c'est-a-dire
    /// que le seul endroit ou ils tournent automatiquement ne les executerait pas.
    /// Partage entre les tests, jamais un device par test : cf. `Gpu::shared_for_tests`.
    fn gpu() -> Option<&'static Gpu> {
        let gpu = Gpu::shared_for_tests();
        if gpu.is_none() {
            eprintln!("pas d'adaptateur Vulkan — test saute");
        }
        gpu
    }

    /// Deux `TextureView` NV12-split, comme `linux_frames::nv12_planes` en rend.
    ///
    /// Les textures ne sont pas retournees : en wgpu une `TextureView` garde la
    /// sienne en vie (c'est deja ce dont depend la pyramide de blur du
    /// compositeur, qui n'existe que sous forme de vues).
    fn nv12_views(
        gpu: &Gpu,
        w: u32,
        h: u32,
        luma: impl Fn(u32, u32) -> u8,
    ) -> (wgpu::TextureView, wgpu::TextureView, wgpu::TextureView) {
        let mut y = vec![0u8; (w * h) as usize];
        for row in 0..h {
            for col in 0..w {
                y[(row * w + col) as usize] = luma(col, row);
            }
        }
        let (ytex, utex, vtex) =
            nv12_textures(gpu, w, h, &y, &vec![UV_NEUTRAL; (w * (h / 2)) as usize]);
        let d = wgpu::TextureViewDescriptor::default();
        (ytex.create_view(&d), utex.create_view(&d), vtex.create_view(&d))
    }

    /// Le couple de textures NV12-split (Y `R8Unorm`, UV entrelacee `Rg8Unorm`)
    /// exactement comme `linux_frames::CpuFrames::ensure_textures` les alloue.
    fn nv12_textures(
        gpu: &Gpu,
        w: u32,
        h: u32,
        y: &[u8],
        uv: &[u8],
    ) -> (wgpu::Texture, wgpu::Texture, wgpu::Texture) {
        let mk = |label: &str, format, tw: u32, th: u32| {
            gpu.device.create_texture(&wgpu::TextureDescriptor {
                label: Some(label),
                size: wgpu::Extent3d { width: tw, height: th, depth_or_array_layers: 1 },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format,
                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
                view_formats: &[],
            })
        };
        let ytex = mk("test-nv12-y", wgpu::TextureFormat::R8Unorm, w, h);
        // Les helpers de test parlent encore NV12 entrelace parce que c'est la
        // forme lisible pour ecrire un cas ; le carrier, lui, veut deux plans.
        // On desentrelace ici plutot que de reecrire chaque test.
        let utex = mk("test-yuv-u", wgpu::TextureFormat::R8Unorm, w / 2, h / 2);
        let vtex = mk("test-yuv-v", wgpu::TextureFormat::R8Unorm, w / 2, h / 2);
        let u_plane: Vec<u8> = uv.iter().step_by(2).copied().collect();
        let v_plane: Vec<u8> = uv.iter().skip(1).step_by(2).copied().collect();
        let write = |tex: &wgpu::Texture, data: &[u8], bpr: u32, tw: u32, th: u32| {
            gpu.context.write_texture(
                wgpu::TexelCopyTextureInfo {
                    texture: tex,
                    mip_level: 0,
                    origin: wgpu::Origin3d::ZERO,
                    aspect: wgpu::TextureAspect::All,
                },
                data,
                wgpu::TexelCopyBufferLayout {
                    offset: 0,
                    bytes_per_row: Some(bpr),
                    rows_per_image: Some(th),
                },
                wgpu::Extent3d { width: tw, height: th, depth_or_array_layers: 1 },
            );
        };
        write(&ytex, y, w, w, h);
        write(&utex, &u_plane, w / 2, w / 2, h / 2);
        write(&vtex, &v_plane, w / 2, w / 2, h / 2);
        (ytex, utex, vtex)
    }

    /// Masque 0 sur la moitie gauche, 255 sur la droite. La frontiere tombe pile
    /// au milieu, donc un echantillon pris au quart et un aux trois quarts sont
    /// loin du degrade que le filtrage lineaire pose sur la couture.
    fn half_mask(w: u32, h: u32) -> Vec<u8> {
        (0..w * h).map(|i| if i % w < w / 2 { 0u8 } else { 255u8 }).collect()
    }

    /// Le buffer de staging exportable doit etre une VRAIE zone partagee : ce que
    /// wgpu y ecrit, notre propre mapping doit le relire a l'identique.
    ///
    /// C'est le seul point reellement incertain de l'export dmabuf, et il se
    /// verifie sans encodeur. Si ce test passe, la memoire qu'on remettra a VAAPI
    /// est bien celle que le compositeur remplit ; s'il echoue, tout ce qui est
    /// bati dessus produirait une image fausse plutot qu'une panne.
    #[test]
    fn exportable_staging_round_trips_through_wgpu() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        const N: u64 = 4096;
        let Some(st) = comp.create_exportable_staging(N) else {
            eprintln!("pas d'extensions de memoire externe — test saute");
            return;
        };
        assert!(st.fd >= 0, "descripteur dmabuf invalide");
        assert_eq!(st.size, N);

        // Un motif non trivial : un remplissage constant passerait meme si les
        // deux cotes regardaient deux zones differentes mais nulles.
        let pattern: Vec<u8> = (0..N as usize).map(|i| (i * 31 + 7) as u8).collect();
        gpu.context.write_buffer(st.buffer(), 0, &pattern);
        gpu.context.submit(std::iter::empty());
        gpu.device.poll(wgpu::Maintain::Wait);

        let got = st.read_back().expect("read_back");
        assert_eq!(got.len(), N as usize);
        assert_eq!(got, pattern, "la memoire exportee ne porte pas ce que wgpu y a ecrit");
    }

    /// Un cran de padding en format Auto change la taille de rendu de la preview. `resized`
    /// realloue les cibles et garde le reste : le masque webcam, et la boite aux lettres ou le
    /// worker de segmentation depose les suivants.
    #[test]
    fn resizing_keeps_the_segmentation_and_reads_back_at_the_new_size() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        let (w, h) = (crate::segmentation::MODEL_WIDTH, crate::segmentation::MODEL_HEIGHT);
        comp.set_webcam_mask(&vec![255u8; (w * h) as usize], w, h).expect("masque");
        let inbox = std::sync::Arc::clone(&comp.seg_inbox);

        let comp = comp.resized(181, 321).expect("resized");

        assert_eq!(comp.render_size(), (182, 322), "arrondi au pair, comme new_sized");
        assert!(comp.webcam_mask.borrow().is_some(), "le masque webcam s'est perdu");
        assert!(
            std::sync::Arc::ptr_eq(&inbox, &comp.seg_inbox),
            "le worker deposerait ses masques dans une boite que plus personne ne lit",
        );
        let (rw, rh, rgba) = unsafe { comp.readback_direct() }.expect("readback");
        assert_eq!((rw, rh, rgba.len()), (182, 322, 182 * 322 * 4));
    }

    /// La disposition NV12 doit etre EXACTEMENT celle que le pilote produit pour
    /// une image NV12 lineaire, parce que c'est elle qu'on decrira a VAAPI dans
    /// un `AVDRMFrameDescriptor`. Les valeurs ci-dessous ne sont pas devinees :
    /// elles ont ete relevees sur ce materiel via `vkGetImageSubresourceLayout`
    /// d'une `VkImage` NV12 en `DRM_FORMAT_MOD_LINEAR` (Y pitch 2048, UV a
    /// l'offset 2211840, pitch 2048, total 3317760). Un ecart d'un octet ici
    /// donnerait une image decalee et non une panne, d'ou le test.
    #[test]
    fn nv12_layout_matches_what_the_driver_produces() {
        let (bpr_y, bpr_uv, off_uv, total) =
            Compositor::yuv_layout_for(1920, 1080, YuvFormat::Nv12);
        assert_eq!(bpr_y, 2048, "pitch du plan Y");
        assert_eq!(bpr_uv, 2048, "pitch du plan UV entrelace (960 texels x 2 octets)");
        assert_eq!(off_uv, 2_211_840, "offset du plan UV");
        assert_eq!(total, 3_317_760, "taille totale");
    }

    /// I420 reste ce qu'il etait : c'est le format que l'encodeur software lit,
    /// et ce test est ce qui garantit qu'ajouter NV12 ne l'a pas deplace.
    #[test]
    fn i420_layout_is_unchanged() {
        let (bpr_y, bpr_uv, off_u, total) =
            Compositor::yuv_layout_for(1920, 1080, YuvFormat::I420);
        assert_eq!((bpr_y, bpr_uv), (2048, 1024));
        assert_eq!(off_u, 2_211_840);
        assert_eq!(total, 2_211_840 + 2 * 1024 * 540);
    }

    /// Dessine UN calque plein cadre sur le RT, par-dessus `clear`, et rend le
    /// RGBA relu.
    ///
    /// Court-circuite `compose_frame` a dessein : ces tests-ci isolent le shader
    /// et la liaison du masque, pas la geometrie que `plan_frame` decide.
    fn draw_one_layer(
        comp: &Compositor,
        clear: wgpu::Color,
        cb: &LayerCB,
        planes: (&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView),
    ) -> (u32, u32, Vec<u8>) {
        let dummy = comp.dummy_view();
        let layer = comp.make_bind(cb, Some(planes), &dummy);
        let mut encoder = comp.gpu.device.create_command_encoder(
            &wgpu::CommandEncoderDescriptor { label: Some("test-layer") },
        );
        {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("test-layer-pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &comp.rt_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(clear),
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            rpass.set_pipeline(&comp.pipeline);
            comp.draw_layer(&mut rpass, &layer, false);
        }
        comp.gpu.context.submit(std::iter::once(encoder.finish()));
        unsafe { comp.readback_direct().expect("readback_direct") }
    }

    // -----------------------------------------------------------------------
    // Le flou Kawase du fond
    // -----------------------------------------------------------------------

    /// Une passe Kawase du modele CPU, en 1D. L'image de test ne varie que le
    /// long d'un axe, donc les prises decalees sur l'autre lisent la meme valeur :
    /// seuls les decalages le long de l'axe comptent. `taps` = (decalage en
    /// texels SOURCE, poids). Bilineaire, clamp-to-edge, aux centres de texel,
    /// comme le sampler du compositeur.
    fn kawase_1d(src: &[f64], dst_len: usize, taps: &[(f64, f64)]) -> Vec<f64> {
        let n = src.len() as isize;
        let at = |i: isize| src[i.clamp(0, n - 1) as usize];
        (0..dst_len)
            .map(|j| {
                let x = (j as f64 + 0.5) * src.len() as f64 / dst_len as f64;
                taps.iter()
                    .map(|&(dx, w)| {
                        let p = x + dx - 0.5;
                        let i = p.floor();
                        let f = p - i;
                        w * (at(i as isize) * (1.0 - f) + at(i as isize + 1) * f)
                    })
                    .sum()
            })
            .collect()
    }

    /// Le flou du fond doit etre celui de Windows et macOS. La reference est le
    /// modele CPU des noyaux de `shaders.hlsl` (`ps_kawase_down/up`), projetes
    /// en 1D : demi-pas `hp` = 0.5 x 2.2 texels source, down 4 + 4 diagonales
    /// (/8), up 4 axiales a 2 hp (x1) + 4 diagonales (x2) (/12).
    ///
    /// Un test de comportement plutot qu'une comparaison de sources : il voit
    /// une derive des poids, des offsets OU de la convention `fx` cote Rust.
    /// L'ancien portage (offset 2.0 texels, autres noyaux) s'ecartait de ce
    /// modele de 21 niveaux sur cette marche ; la tolerance de 3 niveaux
    /// absorbe l'arrondi 8 bits entre passes.
    #[test]
    fn background_blur_matches_the_hlsl_kawase_kernels() {
        let Some(gpu) = gpu() else { return };
        check_kawase_step(&gpu, true);
    }

    /// Meme verification sur l'autre axe : une marche horizontale, lue sur une
    /// colonne. Sans elle, une derive de `fx.y` (le texel vertical) ou des
    /// seuls poids verticaux passerait inapercue, la marche verticale ne lisant
    /// que la projection en x des noyaux.
    #[test]
    fn background_blur_matches_the_hlsl_kawase_kernels_vertically() {
        let Some(gpu) = gpu() else { return };
        check_kawase_step(&gpu, false);
    }

    /// Meme verification sur une dimension non divisible par 8 (854 px, standard
    /// 480p 16:9), ou la pyramide subit la division entiere : les texels source
    /// doivent utiliser les dimensions reelles des textures de la pyramide et non
    /// des multiples fractionnaires.
    #[test]
    fn background_blur_matches_the_hlsl_kawase_kernels_non_multiple_of_8() {
        let Some(gpu) = gpu() else { return };
        check_kawase_step_dims(&gpu, 854, 64, true);
    }

    /// `vertical_edge` : marche noir -> blanc le long de x (lue sur une ligne),
    /// sinon le long de y (lue sur une colonne). Les noyaux HLSL sont
    /// symetriques, donc leur projection 1D est la meme sur les deux axes.
    fn check_kawase_step(gpu: &Gpu, vertical_edge: bool) {
        // Dimensions divisibles par 8 : la pyramide tombe juste.
        let (w, h) = if vertical_edge { (640u32, 64u32) } else { (64u32, 640u32) };
        check_kawase_step_dims(gpu, w, h, vertical_edge);
    }

    fn check_kawase_step_dims(gpu: &Gpu, w: u32, h: u32, vertical_edge: bool) {
        let comp = Compositor::new_sized(gpu, w, h).expect("Compositor::new_sized");

        // La marche, opaque, posee sur le RT par `fs_copy` (le RT n'a pas
        // COPY_DST).
        let src = gpu.device.create_texture(&wgpu::TextureDescriptor {
            label: Some("test-step"),
            size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba8Unorm,
            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
            view_formats: &[],
        });
        let step: Vec<u8> = (0..w * h)
            .flat_map(|i| {
                let dark = if vertical_edge { i % w < w / 2 } else { i / w < h / 2 };
                let v = if dark { 0 } else { 255 };
                [v, v, v, 255]
            })
            .collect();
        gpu.context.write_texture(
            wgpu::TexelCopyTextureInfo {
                texture: &src,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            &step,
            wgpu::TexelCopyBufferLayout {
                offset: 0,
                bytes_per_row: Some(w * 4),
                rows_per_image: Some(h),
            },
            wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
        );
        let src_view = src.create_view(&wgpu::TextureViewDescriptor::default());
        let mut encoder = gpu
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("test-blur") });
        comp.blur_pass(&mut encoder, &comp.pipeline_copy, &src_view, &comp.rt_view, [w as f32, h as f32], 0.0);
        // 0,5 = l'ancien interrupteur : trois niveaux, ecart 2,2 (`HP` ci-dessous).
        comp.blur_bg(&mut encoder, 0.5);
        gpu.context.submit(std::iter::once(encoder.finish()));
        let (_, _, px) = unsafe { comp.readback_direct().expect("readback_direct") };

        const HP: f64 = 0.5 * 2.2;
        let down = [(0.0, 4.0 / 8.0), (-HP, 2.0 / 8.0), (HP, 2.0 / 8.0)];
        let up = [
            (-2.0 * HP, 1.0 / 12.0),
            (2.0 * HP, 1.0 / 12.0),
            (0.0, 2.0 / 12.0),
            (-HP, 4.0 / 12.0),
            (HP, 4.0 / 12.0),
        ];
        let (w, h) = (w as usize, h as usize);
        let n = if vertical_edge { w } else { h };
        let mut model: Vec<f64> = (0..n).map(|k| if k < n / 2 { 0.0 } else { 1.0 }).collect();
        for d in [n / 2, n / 4, n / 8] {
            model = kawase_1d(&model, d, &down);
        }
        for d in [n / 4, n / 2, n] {
            model = kawase_1d(&model, d, &up);
        }

        // Octet RVBA du k-ieme echantillon de la ligne (ou colonne) mediane.
        let at = |k: usize| if vertical_edge { ((h / 2) * w + k) * 4 } else { (k * w + w / 2) * 4 };
        let worst = (0..n)
            .map(|k| ((px[at(k)] as f64 - model[k] * 255.0).abs(), k))
            .fold((0.0, 0), |a, b| if b.0 > a.0 { b } else { a });
        assert!(
            worst.0 <= 3.0,
            "flou Kawase hors parite HLSL ({}) : {:.1} niveaux d'ecart en {} (GPU {}, modele {:.1})",
            if vertical_edge { "axe x" } else { "axe y" },
            worst.0,
            worst.1,
            px[at(worst.1)],
            model[worst.1] * 255.0
        );
        // L'alpha echantillonne est conserve (fond opaque -> opaque), comme en HLSL.
        assert!((0..n).all(|k| px[at(k) + 3] == 255), "alpha du fond floute != 255");
    }

    // -----------------------------------------------------------------------
    // La capture
    // -----------------------------------------------------------------------

    #[test]
    fn the_webcam_capture_comes_back_as_interleaved_rgb_at_model_resolution() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        // Moitie gauche noire, moitie droite blanche : la capture doit rendre les
        // deux dans le bon sens. Une inversion d'axe passerait un test de taille
        // sans se voir.
        let (y, u, v) = nv12_views(&gpu, 64, 64, |col, _| if col < 32 { Y_BLACK } else { Y_WHITE });

        let mut out = Vec::new();
        unsafe {
            comp.capture_webcam_rgb(
                &y,
                &u,
                &v,
                [0.0, 0.0, 1.0, 1.0],
                crate::segmentation::MODEL_WIDTH,
                crate::segmentation::MODEL_HEIGHT,
                &mut out,
            )
            .expect("capture_webcam_rgb");
        }

        let (w, h) = (
            crate::segmentation::MODEL_WIDTH as usize,
            crate::segmentation::MODEL_HEIGHT as usize,
        );
        assert_eq!(out.len(), w * h * 3, "le modele veut du RGB8 entrelace, sans alpha");

        let px = |buf: &[u8], col: usize, row: usize| -> [u8; 3] {
            let i = (row * w + col) * 3;
            [buf[i], buf[i + 1], buf[i + 2]]
        };
        let left = px(&out, w / 4, h / 2);
        let right = px(&out, 3 * w / 4, h / 2);
        assert!(left.iter().all(|&c| c < 24), "moitie gauche pas noire : {left:?}");
        assert!(right.iter().all(|&c| c > 231), "moitie droite pas blanche : {right:?}");

        // Deuxieme capture sur le meme buffer : c'est le regime etabli (30 fois
        // par seconde), et il ne doit ni reallouer ni trainer les octets du tour
        // precedent.
        let capacity = out.capacity();
        unsafe {
            comp.capture_webcam_rgb(
                &y,
                &u,
                &v,
                [0.0, 0.0, 1.0, 1.0],
                crate::segmentation::MODEL_WIDTH,
                crate::segmentation::MODEL_HEIGHT,
                &mut out,
            )
            .expect("deuxieme capture");
        }
        assert_eq!(out.len(), w * h * 3);
        assert_eq!(out.capacity(), capacity, "le scratch se realloue d'une frame a l'autre");
        assert_eq!(px(&out, w / 4, h / 2), left);
        assert_eq!(px(&out, 3 * w / 4, h / 2), right);
    }

    /// Le piege PROPRE a ce backend : `copy_texture_to_buffer` exige un
    /// `bytes_per_row` multiple de 256, et le depadder est a la charge de
    /// l'appelant. A la resolution livree (256 px, 1024 octets) le padding est nul
    /// — donc la resolution livree n'exerce JAMAIS ce chemin. Il faut une largeur
    /// qui le fasse : 100 px = 400 octets utiles dans un pas de 512.
    ///
    /// Un depad rate ne rend pas du bruit, il rend un CISAILLEMENT : chaque ligne
    /// glisse de 28 px sur la precedente. D'ou l'echantillonnage sur plusieurs
    /// lignes plutot que sur une seule.
    #[test]
    fn a_capture_whose_rows_need_padding_is_depadded_correctly() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        let (y, u, v) = nv12_views(&gpu, 64, 64, |col, _| if col < 32 { Y_BLACK } else { Y_WHITE });

        let (w, h) = (100usize, 56usize);
        assert_ne!((w * 4) % 256, 0, "cette largeur doit justement ETRE mal alignee");
        let mut out = Vec::new();
        unsafe {
            comp.capture_webcam_rgb(&y, &u, &v, [0.0, 0.0, 1.0, 1.0], w as u32, h as u32, &mut out)
                .expect("capture_webcam_rgb");
        }
        assert_eq!(out.len(), w * h * 3, "le padding d'alignement a fuit dans la sortie");

        let px = |col: usize, row: usize| -> [u8; 3] {
            let i = (row * w + col) * 3;
            [out[i], out[i + 1], out[i + 2]]
        };
        for row in [0usize, h / 3, h / 2, h - 1] {
            let left = px(w / 4, row);
            let right = px(3 * w / 4, row);
            assert!(left.iter().all(|&c| c < 24), "ligne {row}, gauche pas noire : {left:?}");
            assert!(right.iter().all(|&c| c > 231), "ligne {row}, droite pas blanche : {right:?}");
        }
    }

    #[test]
    fn a_capture_of_zero_size_is_refused_rather_than_rendered() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        let (y, u, v) = nv12_views(&gpu, 16, 16, |_, _| Y_WHITE);
        let mut out = Vec::new();
        let r = unsafe { comp.capture_webcam_rgb(&y, &u, &v, [0.0, 0.0, 1.0, 1.0], 0, 144, &mut out) };
        assert!(r.is_err(), "une cible de largeur nulle doit etre refusee");
    }

    // -----------------------------------------------------------------------
    // Le masque
    // -----------------------------------------------------------------------

    #[test]
    fn the_mask_texture_is_allocated_once_and_a_short_buffer_is_refused() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        let (w, h) = (crate::segmentation::MODEL_WIDTH, crate::segmentation::MODEL_HEIGHT);
        let mask = vec![255u8; (w * h) as usize];

        comp.set_webcam_mask(&mask, w, h).expect("premier televersement");
        let first = comp.webcam_mask.borrow().as_ref().map(|m| m.tex.clone());
        comp.set_webcam_mask(&mask, w, h).expect("deuxieme televersement");
        let second = comp.webcam_mask.borrow().as_ref().map(|m| m.tex.clone());
        assert_eq!(
            first, second,
            "la texture est recreee a chaque frame alors que la resolution du modele est fixe"
        );

        // Un masque trop court doit etre refuse, pas lu hors bornes.
        assert!(comp.set_webcam_mask(&mask[..(w * h) as usize - 1], w, h).is_err());
        assert!(comp.set_webcam_mask(&mask, 0, h).is_err());
        comp.clear_webcam_mask();
        assert!(comp.webcam_mask.borrow().is_none());
    }

    /// Le test qui compte : le masque DECOUPE vraiment la camera.
    ///
    /// Il rend le calque webcam plein cadre avec `fx.z = 1` (detourage) et un
    /// masque mi-fond mi-sujet, puis relit les pixels. Il couvre d'un coup les
    /// trois choses que le portage ajoute et qu'aucune compilation ne verifie :
    /// le televersement R8, la liaison de la texture au binding 4, et la branche
    /// `fx.z` de `fs_main` sur un vrai device.
    #[test]
    fn the_mask_actually_cuts_the_camera_out() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 64, 64).expect("Compositor::new_sized");
        comp.set_webcam_mask(&half_mask(8, 8), 8, 8).expect("set_webcam_mask");
        let (y, u, v) = nv12_views(&gpu, 16, 16, |_, _| Y_WHITE);

        // Fond bleu franc : une couleur que la camera (blanche, chroma neutre) ne
        // peut pas produire, donc « il reste du bleu » signifie « la camera a ete
        // decoupee ici ».
        let (rw, _, rgba) = draw_one_layer(
            &comp,
            wgpu::Color { r: 0.0, g: 0.0, b: 1.0, a: 1.0 },
            &LayerCB {
                dst: [0.0, 0.0, 1.0, 1.0],
                src: [0.0, 0.0, 1.0, 1.0],
                quad_px: [64.0, 64.0],
                mode: 0.0,
                color: [0.0, 0.0, 0.0, 1.0],
                // fx.xy = etendue valide (toute la texture ici), fx.z = 1 -> detourage.
                fx: [1.0, 1.0, 1.0, 0.0],
                src_prev: [0.0, 0.0, 1.0, 1.0],
                dst_prev: [0.0, 0.0, 1.0, 1.0],
                mb: [1.0, 1.0, 1.0, 0.0],
                ..Default::default()
            },
            (&y, &u, &v),
        );

        let px = |col: usize, row: usize| -> [u8; 4] {
            let i = (row * rw as usize + col) * 4;
            [rgba[i], rgba[i + 1], rgba[i + 2], rgba[i + 3]]
        };
        assert_eq!(px(16, 32), [0, 0, 255, 255], "masque a 0 : le fond doit rester visible");
        assert_eq!(px(48, 32), [255, 255, 255, 255], "masque a 255 : la camera doit rester opaque");
    }

    /// Meme montage, mode fond personnalise (`fx.z = 3`) : la ou le masque dit
    /// « fond », le shader doit peindre `color` — c'est le seul mode ou
    /// `LayerCB::color` cesse d'etre du noir opaque decoratif et porte une valeur
    /// que le portage doit transmettre.
    #[test]
    fn the_custom_background_colour_replaces_the_masked_out_pixels() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 64, 64).expect("Compositor::new_sized");
        comp.set_webcam_mask(&half_mask(8, 8), 8, 8).expect("set_webcam_mask");
        let (y, u, v) = nv12_views(&gpu, 16, 16, |_, _| Y_WHITE);

        let (rw, _, rgba) = draw_one_layer(
            &comp,
            wgpu::Color::BLACK,
            &LayerCB {
                dst: [0.0, 0.0, 1.0, 1.0],
                src: [0.0, 0.0, 1.0, 1.0],
                quad_px: [64.0, 64.0],
                mode: 0.0,
                color: [1.0, 0.0, 0.0, 1.0],
                fx: [1.0, 1.0, 3.0, 0.0],
                src_prev: [0.0, 0.0, 1.0, 1.0],
                dst_prev: [0.0, 0.0, 1.0, 1.0],
                mb: [1.0, 1.0, 1.0, 0.0],
                ..Default::default()
            },
            (&y, &u, &v),
        );
        let px = |col: usize, row: usize| -> [u8; 4] {
            let i = (row * rw as usize + col) * 4;
            [rgba[i], rgba[i + 1], rgba[i + 2], rgba[i + 3]]
        };
        assert_eq!(px(16, 32), [255, 0, 0, 255], "fond masque : la couleur custom doit peindre");
        assert_eq!(px(48, 32), [255, 255, 255, 255], "sujet : la camera doit rester intacte");
    }

    // -----------------------------------------------------------------------
    // `compose_frame` de bout en bout
    //
    // Les tests ci-dessus prouvent les pieces ; ceux-ci prouvent le CABLAGE — que
    // `compose_frame` porte bien `fx`/`color` sur le calque webcam, qu'il lie le
    // masque, et qu'il ne leve `fx.z` qu'une fois un masque reellement televerse.
    // Ils passent par de vraies `AVFrame` porteuses d'un carrier `VkFrameTex`,
    // donc par le MEME `nv12_srvs` que le decodeur : aucun raccourci n'est pris
    // sur le seam de frame.
    // -----------------------------------------------------------------------

    /// Une `AVFrame` du backend Linux. `compose_frame` n'en lit que `format`,
    /// `data[0]`, `width` et `height` : le reste peut rester a zero.
    struct FakeFrame {
        frame: Box<AVFrame>,
    }

    impl FakeFrame {
        fn new(gpu: &Gpu, w: u32, h: u32, luma: impl Fn(u32, u32) -> u8) -> FakeFrame {
            let mut y = vec![0u8; (w * h) as usize];
            for row in 0..h {
                for col in 0..w {
                    y[(row * w + col) as usize] = luma(col, row);
                }
            }
            FakeFrame::from_planes(gpu, w, h, &y, &vec![UV_NEUTRAL; (w * (h / 2)) as usize])
        }

        fn from_planes(gpu: &Gpu, w: u32, h: u32, y: &[u8], uv: &[u8]) -> FakeFrame {
            let (ytex, utex, vtex) = nv12_textures(gpu, w, h, y, uv);
            // Le carrier que `linux_frames::nv12_planes` et `carrier_dims`
            // deballent. `Box::into_raw` ici, `Box::from_raw` dans `Drop` — c'est
            // exactement la mecanique de `CpuFrames::attach_carrier`.
            let carrier = Box::into_raw(Box::new(crate::linux_frames::VkFrameTex {
                y: ytex,
                u: utex,
                v: vtex,
                width: w,
                height: h,
            })) as *mut u8;
            let mut frame: Box<AVFrame> = Box::new(unsafe { std::mem::zeroed() });
            // Le sentinel « buffer GPU natif dans data[0] », le meme que pose
            // `CpuFrames::present`.
            frame.format = crate::ffi::AVPixelFormat::AV_PIX_FMT_D3D11 as i32;
            frame.data[0] = carrier;
            frame.width = w as i32;
            frame.height = h as i32;
            FakeFrame { frame }
        }

        fn as_ptr(&self) -> *const AVFrame {
            &*self.frame as *const AVFrame
        }
    }

    impl Drop for FakeFrame {
        fn drop(&mut self) {
            if !self.frame.data[0].is_null() {
                unsafe {
                    drop(Box::from_raw(
                        self.frame.data[0] as *mut crate::linux_frames::VkFrameTex,
                    ));
                }
                self.frame.data[0] = std::ptr::null_mut();
            }
        }
    }

    /// Scene PiP minimale. `effect` est le JSON de `webcamEffect` (`"null"` pour
    /// aucun).
    ///
    /// `effects.shadow` vaut 0 A DESSEIN : ce curseur ne pilote plus que l'ombre
    /// de l'ecran, alors que celle du PiP est fixe (`WEBCAM_SHADOW_OPACITY`) et ne
    /// depend que de `cfg.shadow`. Le mettre a zero est donc ce qui isole les
    /// deux — sinon un test sur `cfg.shadow` mesure les deux ombres a la fois et
    /// ne dit plus rien de la camera.
    fn pip_scene_json(effect: &str) -> String {
        format!(
            r##"{{"clips":[],
                "layout":{{"preset":"picture-in-picture","webcamSize":1,"webcamShape":"rectangle",
                           "webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},
                "effects":{{"padding":0.18,"blur":false,"shadow":0,"roundnessFrac":0.05,"motionBlur":0}},
                "background":{{"kind":"color","color":"#0080ff"}},
                "zoomRegions":[],"annotations":[],
                "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,
                           "clipToBounds":false,"theme":"default"}},
                "cropByClip":[],
                "webcamEffect":{effect},
                "output":{{"width":1920,"height":1080,"fps":30}}}}"##
        )
    }

    /// Compose une frame et rend le RGBA du RT. `screen` est gris moyen, `webcam`
    /// blanche : le blanc franc devient alors la SIGNATURE de la camera, une
    /// couleur qu'aucun autre calque de cette scene ne produit, donc comptable
    /// sans connaitre la geometrie du PiP.
    ///
    /// Le fond est un bleu franc et NON du noir : le PiP par defaut tombe dans la
    /// marge, hors de l'ecran, et une ombre noire sur un fond noir ne se voit
    /// pas — le controle du test d'ombre passerait alors pour une suppression
    /// reussie.
    ///
    /// `set_live_params(live_params_from_scene(..))` n'est PAS decoratif : padding,
    /// effets et forme de la webcam transitent par `LiveParams` et non par la
    /// scene brute. L'omettre laisse la scene parser correctement puis etre
    /// ignoree, et le rendu tombe sur les defauts.
    fn compose_pip(
        comp: &Compositor,
        gpu: &Gpu,
        effect: &str,
        shadow: bool,
    ) -> Vec<u8> {
        let scene = Scene::from_json(&pip_scene_json(effect)).expect("scene json");
        compose_pip_scene(comp, gpu, scene, shadow)
    }

    /// `compose_pip` sur une scene deja construite, pour les tests qui la retouchent.
    fn compose_pip_scene(comp: &Compositor, gpu: &Gpu, scene: Scene, shadow: bool) -> Vec<u8> {
        comp.set_live_params(live_params_from_scene(&scene));
        comp.set_has_webcam(true);
        comp.set_scene(Some(scene));

        let screen = FakeFrame::new(gpu, 128, 128, |_, _| 126);
        let webcam = FakeFrame::new(gpu, 64, 64, |_, _| Y_WHITE);
        let mut cfg = Cfg::c8();
        cfg.bg_blur = 0.0;
        cfg.zoom = false;
        cfg.layout_anim = false;
        cfg.cursor = false;
        cfg.mblur_n = 1;
        cfg.shadow = shadow;
        unsafe {
            comp.compose_frame(screen.as_ptr(), webcam.as_ptr(), 0.0, &cfg)
                .expect("compose_frame");
            let (_, _, rgba) = comp.readback_direct().expect("readback_direct");
            rgba
        }
    }

    /// Pixels quasi blancs = pixels de camera encore visibles.
    fn camera_pixels(rgba: &[u8]) -> usize {
        rgba.chunks_exact(4)
            .filter(|px| px[0] > 240 && px[1] > 240 && px[2] > 240)
            .count()
    }

    const NO_EFFECT: &str = "null";
    const CUTOUT: &str =
        r#"{"mode":"transparent","blurIntensity":0,"background":null,"modelPath":null}"#;

    /// Le piege que le brief nomme : un mode SANS masque ne doit rien changer.
    ///
    /// `effect_code` doit rester a 0 tant que rien n'a ete segmente, sinon le
    /// detourage rend une webcam invisible sur les premieres frames — le temps que
    /// l'inference rende son premier masque, c'est-a-dire a chaque ouverture de
    /// l'editeur. L'assertion est octet pour octet : « inchange » ne souffre pas
    /// d'a-peu-pres.
    #[test]
    fn a_mode_without_a_mask_composites_exactly_like_no_effect_at_all() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        let plain = compose_pip(&comp, &gpu, NO_EFFECT, true);
        let requested = compose_pip(&comp, &gpu, CUTOUT, true);
        assert!(
            comp.webcam_mask.borrow().is_none(),
            "aucun masque n'a ete televerse : `modelPath` est absent, donc rien ne segmente"
        );
        assert!(
            camera_pixels(&plain) > 200,
            "la camera n'est pas a l'ecran, le test ne prouve rien"
        );
        assert_eq!(plain, requested, "un mode sans masque a change des pixels");
    }

    /// Et une fois le masque la, le detourage doit VRAIMENT decouper — dans la
    /// bonne proportion. Le masque couvre la moitie de la camera, donc la moitie
    /// de ses pixels doit disparaitre. Compter plutot que d'echantillonner un
    /// point evite de coder en dur la geometrie du PiP, qui appartient a
    /// `plan_frame` et non a ce portage.
    #[test]
    fn compose_frame_cuts_the_camera_out_once_a_mask_exists() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        let whole = camera_pixels(&compose_pip(&comp, &gpu, NO_EFFECT, true));
        assert!(whole > 200, "la camera n'est pas a l'ecran, le test ne prouve rien");

        let (mw, mh) = (crate::segmentation::MODEL_WIDTH, crate::segmentation::MODEL_HEIGHT);
        comp.set_webcam_mask(&half_mask(mw, mh), mw, mh).expect("set_webcam_mask");
        let cut = camera_pixels(&compose_pip(&comp, &gpu, CUTOUT, true));

        let expected = whole as f32 / 2.0;
        assert!(
            (cut as f32 - expected).abs() < expected * 0.15,
            "detourage : {cut} pixels de camera restants pour ~{expected:.0} attendus \
             (entier : {whole})"
        );
    }

    /// L'ombre portee du PiP doit disparaitre en detourage : une ombre projetee
    /// par un rectangle devenu invisible se lit comme un artefact. Le test le
    /// prouve sans jamais localiser l'ombre — en detourage, `cfg.shadow` ne doit
    /// plus rien changer du tout.
    ///
    /// Le controle est ce qui empeche l'assertion d'etre vide : sans effet,
    /// `cfg.shadow` DOIT changer des pixels, sinon la premiere moitie passerait
    /// aussi pour une scene ou aucune ombre n'a jamais ete dessinee.
    #[test]
    fn the_pip_shadow_is_suppressed_in_cutout_mode() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        assert_ne!(
            compose_pip(&comp, &gpu, NO_EFFECT, true),
            compose_pip(&comp, &gpu, NO_EFFECT, false),
            "controle : sans effet, l'ombre du PiP doit bel et bien se voir"
        );

        let (mw, mh) = (crate::segmentation::MODEL_WIDTH, crate::segmentation::MODEL_HEIGHT);
        comp.set_webcam_mask(&half_mask(mw, mh), mw, mh).expect("set_webcam_mask");
        assert_eq!(
            compose_pip(&comp, &gpu, CUTOUT, true),
            compose_pip(&comp, &gpu, CUTOUT, false),
            "en detourage, l'ombre est encore dessinee"
        );
    }

    /// Pendant le palier d'une region Full Camera, la camera remplit le cadre.
    /// `shape_fade` y vaut 0, ce qui ne doit retirer que la bulle (coins, ombre) :
    /// le gate de `webcam_planes` le lisait aussi et ne dessinait plus la webcam
    /// du tout, si bien que le plein cadre montrait le fond et l'ecran.
    #[test]
    fn a_full_camera_hold_fills_the_frame_with_the_camera() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        let mut scene = Scene::from_json(&pip_scene_json(NO_EFFECT)).expect("scene json");
        scene.camera_fullscreen_regions.push(crate::scene::SceneCameraFullscreenRegion {
            clip_index: None,
            start_sec: 2.0,
            end_sec: 8.0,
            continues_before: false,
            continues_after: false,
        });
        // 5 s : la montee (~1 s) est finie, le retour (~1,5 s) n'a pas commence.
        comp.set_timeline_time(Some(5.0));
        let camera = camera_pixels(&compose_pip_scene(&comp, &gpu, scene, true));
        let frame = 320 * 180;
        assert!(
            camera > frame * 95 / 100,
            "palier Full Camera : {camera} pixels de camera sur {frame}"
        );
    }

    /// Le tour complet, celui qui a besoin d'ONNX Runtime : capture -> inference
    /// -> masque -> composite, entraine par `compose_frame` seul. Se saute
    /// proprement sans la bibliotheque, ce que fait la CI — cf.
    /// `segmentation::runtime_available`.
    #[test]
    fn the_whole_loop_produces_a_mask_from_compose_frame_alone() {
        if !crate::segmentation::runtime_available() {
            eprintln!("ONNX Runtime absent (ORT_DYLIB_PATH) — test saute");
            return;
        }
        let model = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("../../public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.onnx");
        if !model.is_file() {
            eprintln!("modele absent ({}) — test saute", model.display());
            return;
        }
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
        let effect = format!(
            r#"{{"mode":"transparent","blurIntensity":0,"background":null,"modelPath":{}}}"#,
            serde_json::to_string(&model.to_string_lossy()).expect("chemin serialisable")
        );

        // Le limiteur est a 30 Hz : une frame par tour ne suffirait pas, et
        // l'inference est asynchrone. On laisse au worker le temps de rendre un
        // masque, sans jamais l'attendre dans le rendu — ce qui est precisement le
        // contrat.
        let mut uploaded = false;
        for _ in 0..40 {
            let _ = compose_pip(&comp, &gpu, &effect, true);
            if comp.webcam_mask.borrow().is_some() {
                uploaded = true;
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(40));
        }
        assert!(
            uploaded,
            "aucun masque n'est remonte : la boucle capture -> inference -> upload est rompue"
        );
        assert!(!*comp.seg_failed.borrow(), "la segmentation s'est eteinte d'elle-meme");
    }

    // -----------------------------------------------------------------------
    // Harnais visuel (opt-in)
    //
    // Les tests ci-dessus prouvent le mecanisme sur des images synthetiques, ou le
    // masque est pose a la main et donc trivialement juste. Ils ne peuvent rien
    // dire de la QUALITE du masque que le modele produit sur une vraie camera — et
    // « un masque qui composite » n'est pas la meme affirmation que « un masque qui
    // est correct ».
    //
    // Meme forme d'opt-in que `tests/compose_linux.rs` (variable d'environnement +
    // skip propre), et pour la meme raison : ca rend sur GPU et ca lit un fichier
    // que le depot ne porte pas.
    //
    // ```
    // ORT_DYLIB_PATH=/chemin/libonnxruntime.so \
    // OPENSCREEN_SEG_CAM=camera.png \
    // OPENSCREEN_SEG_VISUAL=target/seg \
    //   cargo test -p openscreen-compositor --lib seg_visual -- --nocapture
    // ```
    // -----------------------------------------------------------------------

    /// RGB8 -> NV12 BT.709 limited. Inverse EXACT de `yuv709_limited` dans
    /// `layer.wgsl` : une autre matrice ferait deriver les couleurs du rendu et on
    /// croirait a un bug du compositeur la ou il n'y aurait qu'une conversion
    /// d'entree fausse.
    fn rgb_to_nv12(rgb: &[u8], w: u32, h: u32) -> (Vec<u8>, Vec<u8>) {
        let luma = |i: usize| -> (f32, f32, f32, f32) {
            let (r, g, b) = (
                rgb[i * 3] as f32 / 255.0,
                rgb[i * 3 + 1] as f32 / 255.0,
                rgb[i * 3 + 2] as f32 / 255.0,
            );
            (r, g, b, 0.2126 * r + 0.7152 * g + 0.0722 * b)
        };
        let mut y = vec![0u8; (w * h) as usize];
        for i in 0..(w * h) as usize {
            let (_, _, _, yl) = luma(i);
            y[i] = (16.0 + 219.0 * yl).round().clamp(0.0, 255.0) as u8;
        }
        // Chroma au plus proche voisin : l'echantillon en haut a gauche de chaque
        // bloc 2x2. Un vrai filtre ne changerait rien a ce que ce harnais donne a
        // voir.
        let mut uv = vec![0u8; (w * (h / 2)) as usize];
        for row in 0..h / 2 {
            for col in 0..w / 2 {
                let (r, _, b, yl) = luma(((row * 2) * w + col * 2) as usize);
                let cb = 128.0 + 224.0 * ((b - yl) / 1.8556);
                let cr = 128.0 + 224.0 * ((r - yl) / 1.5748);
                let o = (row * w + col * 2) as usize;
                uv[o] = cb.round().clamp(0.0, 255.0) as u8;
                uv[o + 1] = cr.round().clamp(0.0, 255.0) as u8;
            }
        }
        (y, uv)
    }

    fn frame_from_png(gpu: &Gpu, path: &std::path::Path) -> FakeFrame {
        let img = image::open(path)
            .unwrap_or_else(|e| panic!("{} : {e}", path.display()))
            .to_rgb8();
        // NV12 veut des dimensions paires ; on rogne d'un pixel plutot que de
        // reechantillonner.
        let (w, h) = (img.width() & !1, img.height() & !1);
        let src = img.as_raw();
        let mut rgb = vec![0u8; (w * h * 3) as usize];
        for row in 0..h {
            let (d, s) = ((row * w * 3) as usize, (row * img.width() * 3) as usize);
            rgb[d..d + (w * 3) as usize].copy_from_slice(&src[s..s + (w * 3) as usize]);
        }
        let (y, uv) = rgb_to_nv12(&rgb, w, h);
        FakeFrame::from_planes(gpu, w, h, &y, &uv)
    }

    #[test]
    fn seg_visual_renders_the_four_modes_from_a_real_photo() {
        let (Ok(out_dir), Ok(cam)) = (
            std::env::var("OPENSCREEN_SEG_VISUAL"),
            std::env::var("OPENSCREEN_SEG_CAM"),
        ) else {
            eprintln!(
                "harnais visuel : OPENSCREEN_SEG_VISUAL + OPENSCREEN_SEG_CAM absents — saute"
            );
            return;
        };
        if !crate::segmentation::runtime_available() {
            eprintln!("ONNX Runtime absent (ORT_DYLIB_PATH) — saute");
            return;
        }
        let model = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("../../public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.onnx");
        let Some(gpu) = gpu() else { return };
        std::fs::create_dir_all(&out_dir).expect("dossier de sortie");

        let (rw, rh) = (1280u32, 720u32);
        let comp = Compositor::new_sized(&gpu, rw, rh).expect("Compositor::new_sized");
        let webcam = frame_from_png(&gpu, std::path::Path::new(&cam));
        let screen = match std::env::var("OPENSCREEN_SEG_SCREEN") {
            Ok(p) => frame_from_png(&gpu, std::path::Path::new(&p)),
            // Sans capture d'ecran sous la main, un damier : il rend le detourage
            // lisible, la ou un aplat laisserait croire a un fond simplement peint.
            Err(_) => FakeFrame::new(&gpu, 640, 360, |col, row| {
                if (col / 40 + row / 40) % 2 == 0 { 180 } else { 60 }
            }),
        };
        let model_json = serde_json::to_string(&model.to_string_lossy()).expect("chemin");

        let mut wrote = Vec::new();
        for (name, effect) in [
            ("00-none", "null".to_string()),
            ("01-cutout", format!(r#"{{"mode":"transparent","blurIntensity":0,"background":null,"modelPath":{model_json}}}"#)),
            ("02-blur", format!(r#"{{"mode":"blur","blurIntensity":0.8,"background":null,"modelPath":{model_json}}}"#)),
            ("03-custom", format!(r##"{{"mode":"custom","blurIntensity":0,"background":{{"kind":"color","color":"#ff2d95"}},"modelPath":{model_json}}}"##)),
        ] {
            // Le masque arrive de facon asynchrone : on tourne jusqu'a ce qu'il
            // soit la, ce qui est aussi une verification en soi — la boucle du
            // rendu ne l'attend jamais.
            let mut rgba = Vec::new();
            for _ in 0..60 {
                rgba = compose_visual(&comp, &screen, &webcam, &effect);
                if effect == "null" || comp.webcam_mask.borrow().is_some() {
                    break;
                }
                std::thread::sleep(std::time::Duration::from_millis(30));
            }
            let path = format!("{out_dir}/seg-{name}.png");
            image::RgbaImage::from_raw(rw, rh, rgba)
                .expect("dimensions du readback")
                .save(&path)
                .unwrap_or_else(|e| panic!("ecriture {path} : {e}"));
            wrote.push(path);
        }
        for p in &wrote {
            println!("wrote {p}");
        }
        assert!(
            comp.webcam_mask.borrow().is_some(),
            "aucun masque n'a ete produit : les trois modes d'effet sont sans objet"
        );
    }

    /// Camera grand format (rect force via `webcamRect`), pour que le masque
    /// occupe une bonne part de l'image et se juge a taille reelle.
    fn compose_visual(
        comp: &Compositor,
        screen: &FakeFrame,
        webcam: &FakeFrame,
        effect: &str,
    ) -> Vec<u8> {
        let json = format!(
            r##"{{"clips":[],
                "layout":{{"preset":"picture-in-picture","webcamSize":1,"webcamShape":"rectangle",
                           "webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false,
                           "webcamRect":{{"x":0.06,"y":0.10,"width":0.55,"height":0.72}}}},
                "effects":{{"padding":0.10,"blur":false,"shadow":1,"roundnessFrac":0.02,"motionBlur":0}},
                "background":{{"kind":"gradient","angleDeg":45,"stops":["#1b2a4a","#0b0f1a"]}},
                "zoomRegions":[],"annotations":[],
                "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,
                           "clipToBounds":false,"theme":"default"}},
                "cropByClip":[],
                "webcamEffect":{effect},
                "output":{{"width":1280,"height":720,"fps":30}}}}"##
        );
        let scene = Scene::from_json(&json).expect("scene json");
        comp.set_live_params(live_params_from_scene(&scene));
        comp.set_has_webcam(true);
        comp.set_scene(Some(scene));
        let mut cfg = Cfg::c8();
        cfg.zoom = false;
        cfg.layout_anim = false;
        cfg.cursor = false;
        cfg.mblur_n = 1;
        unsafe {
            comp.compose_frame(screen.as_ptr(), webcam.as_ptr(), 0.0, &cfg)
                .expect("compose_frame");
            let (_, _, rgba) = comp.readback_direct().expect("readback_direct");
            rgba
        }
    }

    /// Ecran gris sur fond gris moyen, avec ou sans cadre de fenetre (`frame` est insere tel
    /// quel dans `effects`), droit ou incline (`rotation`, JSON).
    fn compose_framed(comp: &Compositor, gpu: &Gpu, frame: &str, rotation: &str) -> Vec<u8> {
        compose_framed_shadow(comp, gpu, frame, rotation, 0.6)
    }

    /// `compose_framed`, avec l'ombre de l'ecran `shadow` (0 l'eteint).
    fn compose_framed_shadow(
        comp: &Compositor,
        gpu: &Gpu,
        frame: &str,
        rotation: &str,
        shadow: f32,
    ) -> Vec<u8> {
        let json = 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":{shadow},"roundnessFrac":0.03,"motionBlur":0{frame}}},
                "background":{{"kind":"color","color":"#6070a0"}},
                "zoomRegions":[{{"clipIndex":0,"startSec":0,"endSec":10,"scale":1,"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":[null],
                "output":{{"width":1280,"height":720,"fps":30}}}}"##
        );
        let scene = Scene::from_json(&json).expect("scene json");
        comp.set_live_params(live_params_from_scene(&scene));
        comp.set_has_webcam(false);
        comp.set_scene(Some(scene));
        let screen = FakeFrame::new(gpu, 640, 360, |_, _| 60);
        let webcam = FakeFrame::new(gpu, 64, 64, |_, _| 60);
        let mut cfg = Cfg::c8();
        cfg.bg_blur = 0.0;
        cfg.zoom = false;
        cfg.layout_anim = false;
        cfg.cursor = false;
        cfg.mblur_n = 1;
        cfg.shadow = true;
        unsafe {
            comp.set_timeline_time(Some(2.0));
            comp.compose_frame(screen.as_ptr(), webcam.as_ptr(), 0.0, &cfg)
                .expect("compose_frame");
            let (_, _, rgba) = comp.readback_direct().expect("readback_direct");
            rgba
        }
    }

    /// Ecran sous chrome de fenetre clair, zoome x1,3 de 1 s a 6 s sous `rotation` (JSON), a
    /// l'instant `t` de la timeline, avec le flou de mouvement `blur` (0..1).
    fn compose_zooming_window(comp: &Compositor, gpu: &Gpu, rotation: &str, t: f32, blur: f32) -> Vec<u8> {
        let json = 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.3,"blur":false,"shadow":0.6,"roundnessFrac":0.03,"motionBlur":{blur},"frame":"window-light"}},
                "background":{{"kind":"color","color":"#6070a0"}},
                "zoomRegions":[{{"clipIndex":0,"startSec":1,"endSec":6,"scale":1.3,"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":[null],
                "output":{{"width":1280,"height":720,"fps":30}}}}"##
        );
        let scene = Scene::from_json(&json).expect("scene json");
        comp.set_live_params(live_params_from_scene(&scene));
        comp.set_has_webcam(false);
        comp.set_scene(Some(scene));
        let screen = FakeFrame::new(gpu, 640, 360, |_, _| 60);
        let webcam = FakeFrame::new(gpu, 64, 64, |_, _| 60);
        let mut cfg = Cfg::c8();
        cfg.bg_blur = 0.0;
        cfg.cursor = false;
        cfg.mblur_n = 1;
        cfg.shadow = true;
        unsafe {
            comp.set_timeline_time(Some(t));
            comp.compose_frame(screen.as_ptr(), webcam.as_ptr(), 0.0, &cfg)
                .expect("compose_frame");
            let (_, _, rgba) = comp.readback_direct().expect("readback_direct");
            rgba
        }
    }

    /// Le flou de mouvement prend l'ecran CADRE en bloc, droit comme incline : pendant la rampe
    /// du zoom, la barre de titre claire file avec le metrage au lieu de rester nette (elle perd
    /// des pixels francs, etales sur le fond et l'ecran). Immobile, au palier du zoom comme
    /// apres lui, le rendu flou est celui du rendu net, a l'octet.
    #[test]
    fn the_window_frame_trails_with_the_screen_under_motion_blur() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let bright = |rgba: &[u8]| {
            rgba.chunks_exact(4).filter(|p| p[0] > 215 && p[1] > 215 && p[2] > 215).count()
        };
        let out_dir = std::env::var("OPENSCREEN_FRAME_OUT").ok();
        for (label, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
            for still in [3.5, 9.0] {
                assert!(
                    compose_zooming_window(&comp, &gpu, rotation, still, 0.0)
                        == compose_zooming_window(&comp, &gpu, rotation, still, 1.0),
                    "{label} a t={still} : immobile, le flou ne doit rien changer"
                );
            }
            let mut best = (0.0f32, 0.0f32);
            // La rampe de sortie du zoom, ~6,0 s -> 6,8 s.
            for k in 0..=9 {
                let t = 5.9 + k as f32 * 0.1;
                let sharp = compose_zooming_window(&comp, &gpu, rotation, t, 0.0);
                let blurred = compose_zooming_window(&comp, &gpu, rotation, t, 1.0);
                // Encore zoome, la barre est hors champ : rien a mesurer a cet instant.
                if bright(&sharp) < 1000 {
                    continue;
                }
                let drop = 1.0 - bright(&blurred) as f32 / bright(&sharp) as f32;
                if drop > best.0 {
                    best = (drop, t);
                    if let Some(dir) = &out_dir {
                        for (name, rgba) in [("sharp", sharp), ("blurred", blurred)] {
                            let path = format!("{dir}/linux-trail-{label}-{name}.png");
                            image::RgbaImage::from_raw(1280, 720, rgba)
                                .expect("dimensions du readback")
                                .save(&path)
                                .unwrap_or_else(|e| panic!("ecriture {path} : {e}"));
                        }
                    }
                }
            }
            eprintln!("{label} : barre de titre -{:.1} % de pixels francs a t={}", best.0 * 100.0, best.1);
            let best = best.0;
            assert!(best > 0.05, "{label} : la barre de titre reste nette pendant le zoom (au mieux {best:.3})");
        }
    }

    /// Un seul ecran dans `rect` (fractions de la sortie `out`), zoome x`scale` sous `iso` de 2 a
    /// 6 s, fond uni sans ombre ni padding. Meme scene que `tests/screen_trail_render.rs` (D3D11).
    fn trail_scene_json(rect: [f32; 4], out: (u32, u32), scale: f32, blur: f32, dof: bool) -> String {
        let [x, y, w, h] = rect;
        let (ow, oh) = out;
        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":{x},"y":{y},"width":{w},"height":{h}}}}},
                "effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0.02,"motionBlur":{blur},"depthOfField":{dof}}},
                "background":{{"kind":"color","color":"#6070a0"}},
                "zoomRegions":[{{"clipIndex":0,"startSec":2,"endSec":6,"scale":{scale},"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":"iso"}}],
                "annotations":[],
                "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
                "cropByClip":[null],
                "output":{{"width":{ow},"height":{oh},"fps":30}}}}"##
        )
    }

    fn compose_trail(comp: &Compositor, screen: &FakeFrame, json: &str, t: f32) -> Vec<u8> {
        let scene = Scene::from_json(json).expect("scene json");
        comp.set_live_params(live_params_from_scene(&scene));
        comp.set_has_webcam(false);
        comp.set_scene(Some(scene));
        let mut cfg = Cfg::c8();
        cfg.bg_blur = 0.0;
        cfg.zoom = false;
        cfg.layout_anim = false;
        cfg.cursor = false;
        cfg.mblur_n = 1;
        cfg.shadow = false;
        unsafe {
            comp.set_timeline_time(Some(t));
            comp.compose_frame(screen.as_ptr(), screen.as_ptr(), 0.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback_direct").2
        }
    }

    /// Un tap du mode 18 dont le warp inverse n'a PAS de solution (au-dela du pli du warp
    /// bilineaire d'`iso`) est ecarte : il valait l'origine du plan, renvoyee sur le coin
    /// haut-gauche de l'ecran courant, et le fond loin de l'ecran prenait la couleur de ce coin
    /// (un repere masque par l'arrondi y reparaissait). Petit ecran centre (15 %), zoom x1,6 :
    /// loin de l'ecran, le rendu floute reste le fond, au bit pres. Pendant D3D11 :
    /// `tests/screen_trail_render.rs`.
    #[test]
    fn unsolvable_trail_taps_leave_the_background_alone() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        // Metrage rouge, repere vert dans son coin haut-gauche.
        let (w, h) = (640u32, 360u32);
        let marker = |col: u32, row: u32| col < 48 && row < 48;
        let y: Vec<u8> = (0..w * h).map(|i| if marker(i % w, i / w) { 173 } else { 63 }).collect();
        let uv: Vec<u8> = (0..w * (h / 2))
            .map(|i| {
                let [u, v] = if marker(i % w & !1, i / w * 2) { [42, 26] } else { [102, 240] };
                if i % 2 == 0 { u } else { v }
            })
            .collect();
        let screen = FakeFrame::from_planes(&gpu, w, h, &y, &uv);
        let json = |blur| trail_scene_json([0.425, 0.425, 0.15, 0.15], (1280, 720), 1.6, blur, false);
        let far = |x: u32, y: u32| !(320..960).contains(&x) || !(180..540).contains(&y);
        let mut leaks = 0;
        for t in [1.5, 1.7, 1.9, 6.1] {
            let sharp = compose_trail(&comp, &screen, &json(0.0), t);
            let blurred = compose_trail(&comp, &screen, &json(1.0), t);
            let n = (0..1280 * 720u32)
                .filter(|&i| far(i % 1280, i / 1280))
                .filter(|&i| sharp[i as usize * 4..][..3] != blurred[i as usize * 4..][..3])
                .count();
            eprintln!("t={t} : {n} px du fond changent avec le flou");
            leaks += n;
        }
        assert_eq!(leaks, 0, "le flou de mouvement a peint loin de l'ecran");
    }

    /// Hors de la sortie, le mode 18 relit le metrage comme le mode 8 l'a dessine, profondeur de
    /// champ comprise : le meme ecran physique, zoome x2 sous `iso`, rendu sur la sortie et au
    /// centre d'une sortie deux fois plus grande (ou rien ne sort du cadre), coincide aux bords de
    /// la sortie. Le repli lisait le metrage NET. Pendant D3D11 : `tests/screen_trail_render.rs`.
    #[test]
    fn off_canvas_trail_taps_keep_the_depth_of_field() {
        let Some(gpu) = gpu() else { return };
        let (w, h) = (640u32, 360u32);
        // Rayures noires et blanches de 2 px : la profondeur de champ les grise.
        let screen = FakeFrame::new(&gpu, w, h, |col, _| if col / 2 % 2 == 0 { Y_BLACK } else { Y_WHITE });
        let (ow, oh) = (1280u32, 720u32);
        let normal = Compositor::new_sized(&gpu, ow, oh).expect("Compositor::new_sized");
        let padded = Compositor::new_sized(&gpu, 2 * ow, 2 * oh).expect("Compositor::new_sized");
        let json = |k: f32, dof| {
            let r = [0.5 - 0.4 / k, 0.5 - 0.4 / k, 0.8 / k, 0.8 / k];
            trail_scene_json(r, ((ow as f32 * k) as u32, (oh as f32 * k) as u32), 2.0, 1.0, dof)
        };
        let edges: Vec<(u32, u32)> =
            (oh / 4..oh * 3 / 4).flat_map(|y| (0..24).chain(ow - 24..ow).map(move |x| (x, y))).collect();
        let at = |rgba: &[u8], w: u32, (x, y): (u32, u32)| rgba[((y * w + x) * 4) as usize];
        for t in [1.5, 1.7] {
            let a = compose_trail(&normal, &screen, &json(1.0, true), t);
            let b = compose_trail(&padded, &screen, &json(2.0, true), t);
            let net = compose_trail(&normal, &screen, &json(1.0, false), t);
            let crop = |(x, y): (u32, u32)| (x + ow / 2, y + oh / 2);
            let diffs: Vec<u8> = edges.iter().map(|&p| at(&a, ow, p).abs_diff(at(&b, 2 * ow, crop(p)))).collect();
            let mean = diffs.iter().map(|&d| d as f32).sum::<f32>() / diffs.len() as f32;
            let max = diffs.iter().copied().max().unwrap_or(0);
            let dof = edges.iter().map(|&p| at(&a, ow, p).abs_diff(at(&net, ow, p))).max().unwrap_or(0);
            // La pyramide est bien liee : elle grise les rayures sans les assombrir.
            let level = |rgba: &[u8]| edges.iter().map(|&p| at(rgba, ow, p) as f32).sum::<f32>() / edges.len() as f32;
            let (lit, flat) = (level(&a), level(&net));
            eprintln!("t={t} : bord de la sortie, ecart moyen {mean:.2}, max {max} (profondeur de champ : {dof}, niveau {lit:.1} / {flat:.1})");
            assert!(dof > 60, "t={t} : la profondeur de champ n'agit pas au bord, le test ne prouve rien");
            assert!((lit - flat).abs() < 4.0, "t={t} : la profondeur de champ assombrit le bord ({lit:.1} / {flat:.1})");
            assert!(mean < 1.0 && max <= 16, "t={t} : le bord perd la profondeur de champ ({mean:.2}, {max})");
        }
    }

    /// Un degrade de fond est opaque et montre chacun de ses stops, meme quand le premier est a
    /// 0. `gradient_layer` range la position du premier stop dans `color.a` ; la queue commune
    /// du WGSL la prenait pour une opacite, et le fond disparaissait sous la couleur de clear
    /// (#807). Rouge / vert / bleu a 0, 0.5, 1 de gauche a droite : chaque tiers doit porter sa
    /// couleur, pas le noir du clear.
    #[test]
    fn a_gradient_whose_first_stop_is_at_zero_stays_opaque() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let json = 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.3,"y":0.3,"width":0.4,"height":0.4}},
            "effects":{"padding":0.4,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0},
            "background":{"kind":"gradient","angleDeg":90,
                          "stops":["rgb(255, 0, 0)","rgb(0, 255, 0)","rgb(0, 0, 255)"],
                          "offsets":[0,0.5,1]},
            "zoomRegions":[],"annotations":[],
            "cursor":{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,
                      "clipToBounds":false,"theme":"default"},
            "cropByClip":[null],
            "output":{"width":1280,"height":720,"fps":30}}"##;
        let scene = Scene::from_json(json).expect("scene json");
        comp.set_live_params(live_params_from_scene(&scene));
        comp.set_has_webcam(false);
        comp.set_scene(Some(scene));
        let screen = FakeFrame::new(&gpu, 640, 360, |_, _| 60);
        let webcam = FakeFrame::new(&gpu, 64, 64, |_, _| 60);
        let mut cfg = Cfg::c8();
        cfg.bg_blur = 0.0;
        cfg.zoom = false;
        cfg.layout_anim = false;
        cfg.cursor = false;
        cfg.shadow = false;
        cfg.mblur_n = 1;
        let rgba = unsafe {
            comp.compose_frame(screen.as_ptr(), webcam.as_ptr(), 0.0, &cfg)
                .expect("compose_frame");
            comp.readback_direct().expect("readback_direct").2
        };
        // Rangee du haut, hors de l'ecran : que du fond.
        let px = |x: usize| {
            let i = (4 * 1280 + x) * 4;
            [rgba[i], rgba[i + 1], rgba[i + 2]]
        };
        let (left, mid, right) = (px(8), px(640), px(1271));
        assert!(left[0] > 200 && left[1] < 60 && left[2] < 60, "gauche {left:?} : rouge attendu");
        assert!(mid[1] > 200 && mid[0] < 60 && mid[2] < 60, "milieu {mid:?} : vert attendu");
        assert!(right[2] > 200 && right[0] < 60 && right[1] < 60, "droite {right:?} : bleu attendu");
    }

    /// Le fond fixe est recopie d'une frame a l'autre (`bg_cache`) au lieu d'etre redessine, et
    /// un fond qui change ne laisse rien du precedent : un compositeur qui a rendu A, A, B puis A
    /// rend chacun a l'octet comme un compositeur neuf. Un fond anime n'est jamais repris.
    #[test]
    fn a_static_background_is_reused_and_a_changed_one_redrawn() {
        let Some(gpu) = gpu() else { return };
        let screen = FakeFrame::new(&gpu, 640, 360, |_, _| 60);
        let webcam = FakeFrame::new(&gpu, 64, 64, |_, _| 60);
        let render = |comp: &Compositor, background: &str| {
            let json = 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.3,"y":0.3,"width":0.4,"height":0.4}}}},
                    "effects":{{"padding":0.4,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},
                    "background":{background},
                    "zoomRegions":[],"annotations":[],
                    "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,
                               "clipToBounds":false,"theme":"default"}},
                    "cropByClip":[null],
                    "output":{{"width":640,"height":360,"fps":30}}}}"##
            );
            let scene = Scene::from_json(&json).expect("scene json");
            comp.set_live_params(live_params_from_scene(&scene));
            comp.set_has_webcam(false);
            comp.set_scene(Some(scene));
            let mut cfg = Cfg::c8();
            cfg.bg_blur = 0.0;
            cfg.zoom = false;
            cfg.layout_anim = false;
            cfg.cursor = false;
            cfg.shadow = false;
            cfg.mblur_n = 1;
            unsafe {
                comp.compose_frame(screen.as_ptr(), webcam.as_ptr(), 0.0, &cfg)
                    .expect("compose_frame");
                comp.readback_direct().expect("readback_direct").2
            }
        };
        let fresh = || Compositor::new_sized(&gpu, 640, 360).expect("Compositor::new_sized");
        let a = r##"{"kind":"gradient","angleDeg":90,"stops":["rgb(255, 0, 0)","rgb(0, 0, 255)"],"offsets":[0,1]}"##;
        let b = r##"{"kind":"color","color":"#00ff00"}"##;

        let comp = fresh();
        let a1 = render(&comp, a);
        assert!(comp.bg_cache.borrow().is_some(), "un fond fixe doit etre garde");
        let a2 = render(&comp, a);
        let b1 = render(&comp, b);
        let a3 = render(&comp, a);
        assert!(a1 == a2, "le fond recopie doit etre celui qui a ete dessine");
        assert!(b1 == render(&fresh(), b), "un autre fond ne doit rien garder du precedent");
        assert!(a3 == a1, "revenir au premier fond doit le redessiner a l'identique");
        assert!(a1 != b1, "garde : les deux fonds different");

        let aurora = r##"{"kind":"gradient","angleDeg":90,"stops":["rgb(255, 0, 0)","rgb(0, 0, 255)"],"offsets":[0,1],"motion":"aurora"}"##;
        let comp = fresh();
        render(&comp, aurora);
        assert!(comp.bg_cache.borrow().is_none(), "un fond anime ne doit pas etre garde");
    }

    /// Le cadre de fenetre (mode 14) se dessine sur Linux comme ailleurs : `"none"` rend
    /// l'image d'avant a l'octet, le theme clair ajoute une barre claire, droite comme
    /// inclinee, et les deux themes different. `OPENSCREEN_FRAME_OUT` recoit les PNG.
    #[test]
    fn the_window_frame_draws_its_title_bar_flat_and_tilted() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let out_dir = std::env::var("OPENSCREEN_FRAME_OUT").ok();
        let bright = |rgba: &[u8]| {
            rgba.chunks_exact(4).filter(|p| p[0] > 215 && p[1] > 215 && p[2] > 215).count()
        };
        let differing = |a: &[u8], b: &[u8]| {
            a.chunks_exact(4)
                .zip(b.chunks_exact(4))
                .filter(|(p, q)| p.iter().zip(q.iter()).take(3).any(|(x, y)| x.abs_diff(*y) > 8))
                .count()
        };
        for (name, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
            let absent = compose_framed(&comp, &gpu, "", rotation);
            let none = compose_framed(&comp, &gpu, r#","frame":"none""#, rotation);
            let light = compose_framed(&comp, &gpu, r#","frame":"window-light""#, rotation);
            let dark = compose_framed(&comp, &gpu, r#","frame":"window-dark""#, rotation);
            if let Some(dir) = &out_dir {
                for (theme, rgba) in [("light", &light), ("dark", &dark)] {
                    let path = format!("{dir}/linux-{name}-{theme}.png");
                    image::RgbaImage::from_raw(1280, 720, rgba.clone())
                        .expect("dimensions du readback")
                        .save(&path)
                        .unwrap_or_else(|e| panic!("ecriture {path} : {e}"));
                }
            }
            assert_eq!(absent, none, "{name}: frame none a change des pixels");
            assert_eq!(bright(&none), 0, "{name}: le temoin a deja des pixels clairs");
            // Barre de titre : ~0.04 x 576 px de haut sur ~1000 px de large, moins l'inclinaison.
            assert!(bright(&light) > 10_000, "{name}: barre claire absente ({} px)", bright(&light));
            assert!(differing(&none, &dark) > 10_000, "{name}: cadre sombre absent");
            assert!(differing(&light, &dark) > 10_000, "{name}: les deux themes se confondent");
        }
    }

    /// Les cadres d'APPAREIL modeles (mode 17) se dessinent sur Linux comme ailleurs : chacun
    /// change beaucoup de pixels par rapport a « pas de cadre », aucun ne ressemble aux autres,
    /// et le metrage reste intact au centre de l'ouverture — c'est toute la these du mode : le
    /// modele s'arrete au plan du metrage, que le mode 8 continue de dessiner.
    /// `OPENSCREEN_FRAME_OUT` recoit les PNG.
    #[test]
    fn the_device_frames_draw_around_the_footage() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let out_dir = std::env::var("OPENSCREEN_FRAME_OUT").ok();
        let differing = |a: &[u8], b: &[u8]| {
            a.chunks_exact(4)
                .zip(b.chunks_exact(4))
                .filter(|(p, q)| p.iter().zip(q.iter()).take(3).any(|(x, y)| x.abs_diff(*y) > 8))
                .count()
        };
        // Le metrage de `compose_framed` est un aplat : compter ses pixels dit combien il en
        // reste sous le cadre, sans avoir a reprojeter l'ouverture — ce que fait, lui, le test
        // Windows (`tests/device_frame_render.rs`), point par point le long de la lunette.
        let footage = |rgba: &[u8], c: [u8; 3]| {
            rgba.chunks_exact(4).filter(|p| p[0] == c[0] && p[1] == c[1] && p[2] == c[2]).count()
        };
        let centre = |rgba: &[u8]| {
            let i = ((360 * 1280 + 640) * 4) as usize;
            [rgba[i], rgba[i + 1], rgba[i + 2]]
        };
        for (name, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
            let none = compose_framed(&comp, &gpu, r#","frame":"none""#, rotation);
            // Sans cadre, l'ecran est centre : le pixel du centre EST le metrage.
            let tone = centre(&none);
            let bare = footage(&none, tone);
            let mut shots = Vec::new();
            for device in ["window", "laptop", "phone", "monitor"] {
                let rgba =
                    compose_framed(&comp, &gpu, &format!(r#","frame":"{device}""#), rotation);
                let dark = compose_framed(
                    &comp,
                    &gpu,
                    &format!(r#","frame":"{device}","frameTheme":"dark""#),
                    rotation,
                );
                assert!(
                    differing(&rgba, &dark) > 2_000,
                    "{name} {device} : les deux themes se confondent"
                );
                if let Some(dir) = &out_dir {
                    let path = format!("{dir}/linux-{name}-{device}.png");
                    image::RgbaImage::from_raw(1280, 720, rgba.clone())
                        .expect("dimensions du readback")
                        .save(&path)
                        .unwrap_or_else(|e| panic!("ecriture {path} : {e}"));
                }
                let seen = differing(&none, &rgba);
                let kept = footage(&rgba, tone);
                println!("{name:<5} {device:<8} {seen:>7} px de cadre, {kept:>7} px de metrage");
                // Des lunettes fines autour d'un grand metrage : un anneau, plus l'ombre.
                assert!(seen > 15_000, "{name} {device} : cadre invisible ({seen} px)");
                // Le metrage garde sa boite sous tous les cadres (le cadre pousse vers
                // l'exterieur) : seul le recouvrement d'un pixel et quart de la lunette le mord.
                assert!(kept > bare * 9 / 10, "{name} {device} : metrage couvert ({kept} sur {bare})");
                shots.push((device, rgba));
            }
            for (i, (a, ra)) in shots.iter().enumerate() {
                for (b, rb) in &shots[i + 1..] {
                    assert!(differing(ra, rb) > 10_000, "{name} : {a} et {b} se confondent");
                }
            }
        }
    }

    /// L'ombre d'un appareil est un modele elle aussi (mode 17, `device_shadow_cb`) : comme
    /// l'appareil, elle n'existe que dans `pipeline_models`, et le pipeline plat n'en peindrait
    /// rien. Elle doit donc changer l'image, a plat comme incline.
    #[test]
    fn a_device_frame_casts_its_shadow() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let laptop = r#","frame":"laptop""#;
        for (name, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
            let lit = compose_framed_shadow(&comp, &gpu, laptop, rotation, 0.6);
            let bare = compose_framed_shadow(&comp, &gpu, laptop, rotation, 0.0);
            let shaded = lit.chunks_exact(4).zip(bare.chunks_exact(4)).filter(|(a, b)| a != b).count();
            assert!(shaded > 2_000, "{name} : l'ombre de l'appareil ne change que {shaded} px");
        }
    }

    // -----------------------------------------------------------------------
    // Curseur modélisé (mode 15) : pendant de `tests/cursor_model_render.rs` (Windows).
    // -----------------------------------------------------------------------

    /// Les états que le rendu passe en revue (hotspots de `DEFAULT_CURSOR_SPRITES`), et s'ils
    /// sont centrés : ni tangage ni lacet.
    const MODEL_STATES: [(&str, [f32; 2], bool); 6] = [
        ("arrow", [0.1205, 0.0881], false),
        ("pointer", [0.3874, 0.0032], false),
        ("text", [0.4355, 0.5369], true),
        ("open-hand", [0.4375, 0.1724], false),
        ("resize-ew", [0.485, 0.4706], true),
        ("not-allowed", [0.5, 0.5], true),
    ];

    /// Écran seul (strié) sous un zoom 1 porteur de `rotation`, curseur par défaut à la taille
    /// `size` avec les sprites livrés de `MODEL_STATES`. `model3d` : `None` = clé absente.
    fn model_scene_json(rotation: &str, model3d: Option<bool>, theme: &str, show: bool, size: f32) -> String {
        let model3d = model3d.map(|m| format!(r#","model3d":{m}"#)).unwrap_or_default();
        let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../public/cursors/default").replace('\\', "/");
        let sprites: Vec<String> = MODEL_STATES
            .iter()
            .map(|(key, [hx, hy], _)| format!(r#""{key}":{{"path":"{dir}/{key}.png","hotspotX":{hx},"hotspotY":{hy}}}"#))
            .collect();
        let sprites = sprites.join(",");
        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,"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}}}],
                "annotations":[],
                "cursor":{{"show":{show},"size":{size},"smoothing":0,"motionBlur":0,"clickBounce":2.5{model3d},"clipToBounds":false,"theme":"{theme}",
                           "cursorSprites":{{{sprites}}}}},
                "cropByClip":[null],
                "output":{{"width":1280,"height":720,"fps":30}}}}"##
        )
    }

    /// Une frame striée de barres sombres, bleue ou orangée : rien de NEUTRE, donc un pixel gris
    /// est le curseur et un pixel teinté assombri son ombre ; un pixel identique sur les deux
    /// teintes est du curseur opaque.
    fn model_screen_planes(orange: bool) -> (Vec<u8>, Vec<u8>) {
        let (w, h) = (640u32, 360u32);
        let (u, v) = if orange { (100, 170) } else { (150, 120) };
        let y = (0..w * h)
            .map(|i| {
                let (col, row) = (i % w, i / w);
                if row % 24 >= 8 && row % 24 < 12 && (col / 40) % 3 != 2 { 90 } else { 150 }
            })
            .collect();
        let uv = (0..w * (h / 2)).map(|i| if i % 2 == 0 { u } else { v }).collect();
        (y, uv)
    }

    /// Pendant de `stripes` (Windows) : des rayures verticales nettes, claires et sombres, de 7 px
    /// de source ; `inverse` les échange.
    fn model_stripe_planes(inverse: bool) -> (Vec<u8>, Vec<u8>) {
        let y = (0..640u32 * 360).map(|i| if (i % 640 / 7 % 2 == 0) != inverse { 200 } else { 60 }).collect();
        (y, vec![128; 640 * 180])
    }

    /// Pendant de `stripe_edges` (Windows) : les bords des rayures sur chaque ligne (x en px), où
    /// le signe de l'écart entre les rendus sur les rayures et sur leur inverse change entre deux
    /// pixels de `keep` à 3 px au plus. Un écart faible ne tranche pas.
    fn model_stripe_edges(on: &[u8], on_inverse: &[u8], keep: impl Fn(usize) -> bool) -> Vec<Vec<f32>> {
        (0..720)
            .map(|y| {
                let (mut edges, mut last) = (Vec::new(), None);
                for x in 0..1280 {
                    let i = y * 1280 + x;
                    if !keep(i) {
                        last = None;
                        continue;
                    }
                    let d = model_luma(&on[i * 4..i * 4 + 3]) - model_luma(&on_inverse[i * 4..i * 4 + 3]);
                    if d.abs() < 30.0 {
                        continue;
                    }
                    if let Some((lx, light)) = last {
                        if light != (d > 0.0) && x - lx <= 3 {
                            edges.push((lx + x) as f32 / 2.0);
                        }
                    }
                    last = Some((x, d > 0.0));
                }
                edges
            })
            .collect()
    }

    fn compose_model(
        comp: &Compositor,
        screen: &FakeFrame,
        json: &str,
        track: &crate::cursor::CursorTrack,
    ) -> Vec<u8> {
        let scene = crate::scene::Scene::from_json(json).expect("scene json");
        comp.set_live_params(live_params_from_scene(&scene));
        comp.set_has_webcam(false);
        comp.set_scene(Some(scene));
        comp.set_cursor(track.clone());
        comp.set_cursor_time(Some(2.0));
        comp.set_timeline_time(Some(2.0));
        let cfg = model_cfg();
        unsafe {
            comp.compose_frame(screen.as_ptr(), screen.as_ptr(), 0.0, &cfg).expect("compose_frame");
            comp.readback_direct().expect("readback_direct").2
        }
    }

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

    /// Le pixel du hotspot et l'unité du modèle (px) que `plan_cursor` donne à la scène que
    /// `compose_model` rend.
    fn model_tip(json: &str, track: &crate::cursor::CursorTrack) -> ([f32; 2], f32) {
        let scene = crate::scene::Scene::from_json(json).expect("scene json");
        let (cfg, live, render_px, src) = (model_cfg(), live_params_from_scene(&scene), [1280.0, 720.0], [640.0, 360.0]);
        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: 0.0,
            cfg: &cfg,
            live,
            scene: Some(&scene),
            cursor: Some(track),
            timeline_t_override: Some(2.0),
            programme_time: None,
        });
        let input = CursorPlanInput { render_px, u_max: 1.0, v_max: 1.0, cfg: &cfg, live, scene: Some(&scene), track, t: 2.0 };
        let plan = plan_cursor(&g, &input).expect("un curseur a dessiner");
        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], plan.size_px * quad.scale)
            }
            CursorPlacement::Upright { center } => ([center[0] * render_px[0], center[1] * render_px[1]], plan.size_px),
        }
    }

    /// Immobile en (`at`, `at`) dans l'état `kind`, avec un clic au creux de `tap` avant l'instant
    /// rendu si `click` : le modèle est alors posé.
    fn model_track(kind: &str, click: bool, at: f32) -> crate::cursor::CursorTrack {
        crate::cursor::CursorTrack::new(
            vec![(0.0, at, at), (9.0, at, at)],
            if click { vec![2.0 - 0.0495] } else { vec![] },
            vec![(0.0, kind.to_string())],
        )
    }

    fn model_save(name: &str, rgba: &[u8]) {
        let Ok(dir) = std::env::var("OPENSCREEN_CURSOR3D_OUT") else { return };
        let path = format!("{dir}/linux-{name}.png");
        image::RgbaImage::from_raw(1280, 720, rgba.to_vec())
            .expect("dimensions du readback")
            .save(&path)
            .unwrap_or_else(|e| panic!("ecriture {path} : {e}"));
    }

    fn model_neutral(p: &[u8]) -> bool {
        p[0].max(p[1]).max(p[2]) - p[0].min(p[1]).min(p[2]) < 12
    }

    fn model_luma(p: &[u8]) -> f32 {
        0.2126 * p[0] as f32 + 0.7152 * p[1] as f32 + 0.0722 * p[2] as f32
    }

    /// Ce qui distingue la frame avec flèche de la même sans : pixels de la flèche (neutres),
    /// d'ombre (le bleu assombri, hors frange antialiasée), leurs centroïdes, et la distance de
    /// l'ombre la plus proche de l'apex (le pixel de flèche le plus haut).
    struct ModelSplit {
        white: usize,
        black: usize,
        shadow: usize,
        body_c: [f32; 2],
        shadow_c: [f32; 2],
        near_apex: f32,
    }

    fn model_split(with: &[u8], without: &[u8]) -> ModelSplit {
        let (w, h) = (1280i32, 720i32);
        let at = |buf: &[u8], x: i32, y: i32| {
            let i = ((y * w + x) * 4) as usize;
            [buf[i], buf[i + 1], buf[i + 2]]
        };
        let body = |x: i32, y: i32| {
            x >= 0 && y >= 0 && x < w && y < h && at(with, x, y) != at(without, x, y) && model_neutral(&at(with, x, y))
        };
        let mut s = ModelSplit { white: 0, black: 0, shadow: 0, body_c: [0.0; 2], shadow_c: [0.0; 2], near_apex: f32::MAX };
        let (mut nb, mut apex) = (0usize, [0i32, i32::MAX]);
        let mut shadows = Vec::new();
        for y in 0..h {
            for x in 0..w {
                let (a, b) = (at(with, x, y), at(without, x, y));
                if a == b {
                    continue;
                }
                if model_neutral(&a) {
                    nb += 1;
                    s.white += a.iter().all(|&c| c > 200) as usize;
                    s.black += a.iter().all(|&c| c < 45) as usize;
                    s.body_c = [s.body_c[0] + x as f32, s.body_c[1] + y as f32];
                    if y < apex[1] {
                        apex = [x, y];
                    }
                } else if model_luma(&a) < model_luma(&b) - 6.0
                    && !(-2..=2).any(|dy| (-2..=2).any(|dx| body(x + dx, y + dy)))
                {
                    shadows.push([x as f32, y as f32]);
                }
            }
        }
        s.shadow = shadows.len();
        s.body_c = [s.body_c[0] / nb.max(1) as f32, s.body_c[1] / nb.max(1) as f32];
        for p in &shadows {
            s.shadow_c = [s.shadow_c[0] + p[0], s.shadow_c[1] + p[1]];
            s.near_apex = s.near_apex.min((p[0] - apex[0] as f32).hypot(p[1] - apex[1] as f32));
        }
        s.shadow_c = [s.shadow_c[0] / s.shadow.max(1) as f32, s.shadow_c[1] / s.shadow.max(1) as f32];
        s
    }

    /// Les pixels OPAQUES du curseur : identiques sur les deux teintes, différents du contenu nu.
    fn model_opaque(on_blue: &[u8], on_orange: &[u8], bare: &[u8]) -> Vec<bool> {
        (0..1280 * 720)
            .map(|i| {
                let px = |b: &[u8]| [b[i * 4], b[i * 4 + 1], b[i * 4 + 2]];
                px(on_blue) == px(on_orange) && px(on_blue) != px(bare)
            })
            .collect()
    }

    /// Les pixels que couvre un curseur de VERRE (le cristal de Prism Glow, qui laisse voir le
    /// contenu et le réfracte) : opaques, ou changés sur les deux teintes sans y être plus sombres
    /// (une ombre ne fait qu'assombrir ; le verre réfracte, reflète et luit).
    fn model_covered(on_blue: &[u8], on_orange: &[u8], bare: &[u8], bare_orange: &[u8]) -> Vec<bool> {
        let opaque = model_opaque(on_blue, on_orange, bare);
        (0..1280 * 720)
            .map(|i| {
                let lit = |on: &[u8], under: &[u8]| {
                    let (a, b) = (&on[i * 4..i * 4 + 3], &under[i * 4..i * 4 + 3]);
                    a != b && model_luma(a) >= model_luma(b) - 2.0
                };
                opaque[i] || (lit(on_blue, bare) && lit(on_orange, bare_orange))
            })
            .collect()
    }

    fn model_iou(a: &[bool], b: &[bool]) -> f32 {
        let inter = a.iter().zip(b).filter(|(x, y)| **x && **y).count();
        let union = a.iter().zip(b).filter(|(x, y)| **x || **y).count();
        inter as f32 / union.max(1) as f32
    }

    /// Part des pixels de `a` qui ont un pixel de `b` à `r` px au plus (norme max).
    fn model_within(a: &[bool], b: &[bool], r: i32) -> f32 {
        let near = |i: usize| {
            let (x, y) = ((i % 1280) as i32, (i / 1280) as i32);
            (-r..=r).any(|dy| {
                (-r..=r).any(|dx| {
                    let (x, y) = (x + dx, y + dy);
                    (0..1280).contains(&x) && (0..720).contains(&y) && b[(y * 1280 + x) as usize]
                })
            })
        };
        let hits: Vec<usize> = (0..a.len()).filter(|&i| a[i]).collect();
        hits.iter().filter(|&&i| near(i)).count() as f32 / hits.len().max(1) as f32
    }

    /// Parts des pixels sombres, clairs et rouges parmi ceux du masque qui tombent dans l'une
    /// des trois classes.
    fn model_palette(rgba: &[u8], mask: &[bool]) -> [f32; 3] {
        let mut c = [0usize; 3];
        for (i, _) in mask.iter().enumerate().filter(|(_, m)| **m) {
            let p = [rgba[i * 4] as i32, rgba[i * 4 + 1] as i32, rgba[i * 4 + 2] as i32];
            c[0] += (p.iter().max().unwrap() < &70) as usize;
            c[1] += (p.iter().min().unwrap() > &150) as usize;
            c[2] += (p[0] > p[1] + 60 && p[0] > p[2] + 60) as usize;
        }
        let n = c.iter().sum::<usize>().max(1) as f32;
        c.map(|k| k as f32 / n)
    }

    #[test]
    fn the_modelled_arrow_casts_its_shadow_and_touches_the_screen() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let (y, uv) = model_screen_planes(false);
        let screen = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let (still, clicked) = (model_track("arrow", false, 0.45), model_track("arrow", true, 0.45));
        for (name, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
            let json = |m: Option<bool>, theme: &str, show: bool| model_scene_json(rotation, m, theme, show, 3.0);
            let bare = compose_model(&comp, &screen, &json(Some(true), "default", false), &still);
            let absent = compose_model(&comp, &screen, &json(None, "default", true), &still);
            let off = compose_model(&comp, &screen, &json(Some(false), "default", true), &still);
            let other = compose_model(&comp, &screen, &json(Some(true), "other", true), &still);
            let hover = compose_model(&comp, &screen, &json(Some(true), "default", true), &still);
            let touch = compose_model(&comp, &screen, &json(Some(true), "default", true), &clicked);
            model_save(&format!("{name}-hover"), &hover);
            model_save(&format!("{name}-touch"), &touch);
            assert!(absent == off, "{name}: le chemin plat a change");
            assert!(absent != hover, "{name}: le reglage allume ne change rien");
            assert!(other == hover, "{name}: le libelle du theme a change le rendu natif");
            let (a, b) = (model_split(&hover, &bare), model_split(&touch, &bare));
            println!(
                "{name} : blanc {}, noir {}, ombre {} (apex a {:.1} px, posee {:.1} px), centroides {:?} / {:?}",
                a.white, a.black, a.shadow, a.near_apex, b.near_apex, a.body_c, a.shadow_c
            );
            // Taille 3 en 1280x720 : ~50 a 60 px de haut, ~1000 px de silhouette.
            assert!(a.white > 150 && a.black > 250, "{name}: matieres absentes");
            assert!(a.shadow > 300, "{name}: pas d'ombre");
            assert!(a.shadow_c[0] > a.body_c[0] && a.shadow_c[1] > a.body_c[1], "{name}: ombre pas en bas a droite");
            assert!(b.near_apex < 8.0, "{name}: posee, l'ombre est a {:.1} px de l'apex", b.near_apex);
            assert!(a.near_apex > 12.0, "{name}: en l'air, l'ombre touche l'apex ({:.1} px)", a.near_apex);
        }
    }

    /// La trainee du curseur modelise s'accumule par `pipeline_add_models` : le pipeline plat ne
    /// compile pas le mode 15 et n'en peindrait rien. En mouvement, flou du curseur au maximum,
    /// le modele doit donc bien apparaitre.
    #[test]
    fn the_modelled_cursor_draws_its_trail() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let (y, uv) = model_screen_planes(false);
        let screen = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        // Traverse 60 % de la largeur en une seconde autour de t = 2 s : ~13 px par frame, donc
        // plusieurs copies dans `accum`.
        let moving = crate::cursor::CursorTrack::new(
            vec![(1.5, 0.2, 0.45), (2.5, 0.8, 0.45)],
            vec![],
            vec![(0.0, "arrow".to_string())],
        );
        let json = |show: bool| {
            model_scene_json("null", Some(true), "default", show, 3.0)
                .replace(r#""motionBlur":0,"clickBounce""#, r#""motionBlur":1,"clickBounce""#)
        };
        assert!(json(true).contains(r#""motionBlur":1,"clickBounce""#), "garde : le flou du curseur");
        let bare = compose_model(&comp, &screen, &json(false), &moving);
        let trail = compose_model(&comp, &screen, &json(true), &moving);
        let drawn = bare.chunks_exact(4).zip(trail.chunks_exact(4)).filter(|(a, b)| a != b).count();
        // Taille 3 : ~1000 px de silhouette a l'arret, etales ici par la trainee.
        assert!(drawn > 1000, "trainee du curseur modelise : {drawn} px dessines");
    }

    /// Chaque état garde son art et sa silhouette : posé au centre de l'écran (vu de face), le
    /// modèle couvre ce que couvre le sprite plat, avec ses couleurs ; il porte une ombre en
    /// l'air et suit l'inclinaison du plan. Le réglage éteint garde le sprite plat.
    #[test]
    fn every_modelled_state_keeps_its_art_footprint_and_shadow() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let (y, uv) = model_screen_planes(false);
        let blue = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let (y, uv) = model_screen_planes(true);
        let orange = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let json = |rotation: &str, m: Option<bool>, theme: &str, show: bool| model_scene_json(rotation, m, theme, show, 5.0);
        let bare = compose_model(&comp, &blue, &json("null", Some(true), "default", false), &model_track("arrow", false, 0.5));
        let mut failures = Vec::new();
        for (key, _, centred) in MODEL_STATES {
            let (still, clicked) = (model_track(key, false, 0.5), model_track(key, true, 0.5));
            let on = json("null", Some(true), "default", true);
            let flat = json("null", Some(false), "default", true);
            let touch = compose_model(&comp, &blue, &on, &clicked);
            let touch_b = compose_model(&comp, &orange, &on, &clicked);
            let hover = compose_model(&comp, &blue, &on, &still);
            let iso = json(r#""iso""#, Some(true), "default", true);
            let tilted = compose_model(&comp, &blue, &iso, &still);
            // Le modèle incliné posé en `x` sur la ligne du focus : le préset iso (`left`) amène le
            // bord droit du plan vers la caméra.
            let across = |x: f32| {
                let track = crate::cursor::CursorTrack::new(vec![(0.0, x, 0.5), (9.0, x, 0.5)], vec![], vec![(0.0, key.to_string())]);
                compose_model(&comp, &blue, &iso, &track)
            };
            let (near, far) = (across(0.8), across(0.2));
            let sprite = compose_model(&comp, &blue, &flat, &still);
            let sprite_b = compose_model(&comp, &orange, &flat, &still);
            let absent = compose_model(&comp, &blue, &json("null", None, "default", true), &still);
            let other = compose_model(&comp, &blue, &json("null", Some(true), "other", true), &still);
            model_save(&format!("art-{key}-touch"), &touch);
            model_save(&format!("art-{key}-iso"), &tilted);
            if absent != sprite {
                failures.push(format!("{key}: le sprite plat a change"));
            }
            if other != hover {
                failures.push(format!("{key}: le libelle du theme a change le rendu natif"));
            }

            let (m3d, m2d) = (model_opaque(&touch, &touch_b, &bare), model_opaque(&sprite, &sprite_b, &bare));
            let overlap = model_iou(&m3d, &m2d);
            let (near3d, near2d) = (model_within(&m3d, &m2d, 2), model_within(&m2d, &m3d, 2));
            let (pal3d, pal2d) = (model_palette(&touch, &m3d), model_palette(&sprite, &m2d));
            let area = m2d.iter().filter(|m| **m).count() as f32;
            let differs = |a: &[u8], i: usize| a[i * 4..i * 4 + 3] != bare[i * 4..i * 4 + 3];
            let shadow = (0..1280 * 720)
                .filter(|&i| {
                    let (a, b) = (&hover[i * 4..i * 4 + 3], &bare[i * 4..i * 4 + 3]);
                    differs(&hover, i) && !model_neutral(a) && model_luma(a) < model_luma(b) - 6.0
                })
                .count() as f32;
            let body = |rgba: &[u8]| (0..1280 * 720).filter(|&i| model_neutral(&rgba[i * 4..i * 4 + 3]) && differs(rgba, i)).count() as f32;
            let (flat_body, tilted_body) = (body(&hover), body(&tilted));
            let (near_body, far_body) = (body(&near), body(&far));
            println!(
                "{key} : IoU {overlap:.3}, a 2 px pres {near3d:.3} / {near2d:.3}, sprite {area} px, palette 3D {pal3d:?} / sprite {pal2d:?}, \
                 ombre {shadow} px, corps a plat {flat_body} / incline {tilted_body}, proche {near_body} / lointain {far_body}"
            );
            let (min_iou, min_near, palette_tol) = if centred { (0.75, 0.98, 0.07) } else { (0.6, 0.9, 0.2) };
            if overlap <= min_iou || near3d < min_near || near2d < min_near {
                failures.push(format!("{key}: la silhouette s'ecarte du sprite (IoU {overlap}, {near3d} / {near2d})"));
            }
            for (c, (a, b)) in ["sombre", "clair", "rouge"].iter().zip(pal3d.iter().zip(pal2d.iter())) {
                if (a - b).abs() >= palette_tol {
                    failures.push(format!("{key}: part {c} {a} contre {b} dans le sprite"));
                }
            }
            if shadow <= 0.3 * area {
                failures.push(format!("{key}: pas d'ombre en l'air ({shadow} px)"));
            }
            // Au focus du zoom, l'angle fixe garde au modèle sa taille à plat (`plan_cursor`) ;
            // ailleurs, le plan l'emporte avec lui : sa perspective le grossit du côté proche et le
            // réduit du côté lointain. Mesuré : ×1,5 de l'un à l'autre ; un modèle resté de face sur
            // le même plan n'y gagne que ×1,0 à 1,1.
            if !((0.85..1.15).contains(&(tilted_body / flat_body)) && near_body > 1.25 * far_body) {
                failures.push(format!(
                    "{key}: le modele ne suit pas le plan ({tilted_body} / {flat_body}, proche {near_body} / lointain {far_body})"
                ));
            }
        }
        assert!(failures.is_empty(), "{failures:#?}");
    }

    /// Pendant de `the_sculpted_cursors_stand_at_the_hotspot` (Windows) : la flèche et la main
    /// sculptées des thèmes d'origine (`sculpt.rs`) passent par le WGSL, tiennent au hotspot, en
    /// bas à droite de lui, et portent leur ombre en l'air. Le cristal de Prism Glow est de verre :
    /// son corps compte ce qu'il couvre, et une bonne part de lui change avec la teinte de l'écran.
    #[test]
    fn the_sculpted_cursors_stand_at_the_hotspot() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let (y, uv) = model_screen_planes(false);
        let blue = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let (y, uv) = model_screen_planes(true);
        let orange = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let extruded = model_scene_json("null", Some(true), "default", true, 5.0);
        let hidden = model_scene_json("null", Some(true), "default", false, 5.0);
        let bare = compose_model(&comp, &blue, &hidden, &model_track("arrow", false, 0.5));
        let bare_orange = compose_model(&comp, &orange, &hidden, &model_track("arrow", false, 0.5));
        let mut failures = Vec::new();
        for state in ["arrow", "pointer"] {
            let still = model_track(state, false, 0.5);
            let sprite = compose_model(&comp, &blue, &extruded, &still);
            for theme in ["studio-ink", "prism-glow", "pop-coral", "pixel-candy", "star-sprout", "glass-lens"] {
                // Le sprite reste celui du theme par defaut : seul le nom pose le modele.
                let json = extruded
                    .replace(&format!(r#"/{state}.png","#), &format!(r#"/{state}.png","sculpt":"{theme}/{state}","#));
                let (hover, hover_b) = (compose_model(&comp, &blue, &json, &still), compose_model(&comp, &orange, &json, &still));
                model_save(&format!("sculpt-{theme}-{state}"), &hover);
                if hover == sprite {
                    failures.push(format!("{theme}/{state}: le sprite extrude au lieu du modele"));
                }
                let (tip, u) = model_tip(&json, &still);
                let glass = matches!(theme, "prism-glow" | "glass-lens");
                let mask = if glass {
                    model_covered(&hover, &hover_b, &bare, &bare_orange)
                } else {
                    model_opaque(&hover, &hover_b, &bare)
                };
                let (mut body, mut c, mut near) = (0usize, [0.0f32; 2], f32::MAX);
                for (i, _) in mask.iter().enumerate().filter(|(_, m)| **m) {
                    let (x, y) = ((i % 1280) as f32, (i / 1280) as f32);
                    body += 1;
                    c = [c[0] + x, c[1] + y];
                    near = near.min((x - tip[0]).hypot(y - tip[1]));
                }
                let c = [c[0] / body.max(1) as f32, c[1] / body.max(1) as f32];
                let shadow = (0..1280 * 720)
                    .filter(|&i| {
                        let (a, b) = (&hover[i * 4..i * 4 + 3], &bare[i * 4..i * 4 + 3]);
                        !mask[i] && a != b && model_luma(a) < model_luma(b) - 6.0
                    })
                    .count();
                println!("{theme}/{state} : unite {u:.1} px, corps {body} px, a {near:.1} px du hotspot {tip:?}, centroide {c:?}, ombre {shadow} px");
                if (body as f32) < 0.12 * u * u {
                    failures.push(format!("{theme}/{state}: {body} px de corps pour {u:.0} px d'unite"));
                }
                if near > 0.08 * u {
                    failures.push(format!("{theme}/{state}: le modele est a {near:.1} px du hotspot"));
                }
                if !(c[0] > tip[0] && c[1] > tip[1] + 0.2 * u) {
                    failures.push(format!("{theme}/{state}: corps en {c:?}, pas en bas a droite de {tip:?}"));
                }
                if shadow * 10 < body * 3 {
                    failures.push(format!("{theme}/{state}: pas d'ombre en l'air ({shadow} px)"));
                }
                if glass {
                    let through = (0..1280 * 720).filter(|&i| mask[i] && hover[i * 4..i * 4 + 3] != hover_b[i * 4..i * 4 + 3]).count();
                    println!("{theme}/{state} : {through} px du corps laissent voir l'ecran");
                    if through * 10 < body * 3 {
                        failures.push(format!("{theme}/{state}: le cristal ne laisse voir l'ecran que sur {through} px"));
                    }
                }
            }
        }
        assert!(failures.is_empty(), "{failures:#?}");
    }

    /// Pendant de `the_flat_glass_lens_refracts_the_picture` (Windows) : Glass Lens, 3D éteinte,
    /// passe par le verre à plat du WGSL (mode 19), sans ombre, si bien que tout pixel changé est
    /// le sien. Il tient au hotspot, en bas à droite de lui ; l'écran se voit au travers ; le trait
    /// le cerne ; et le verre réfracte : sur des rayures, des bords vus au travers de la lentille
    /// sont à plusieurs pixels de tout bord de la même ligne sans elle.
    #[test]
    fn the_flat_glass_lens_refracts_the_picture() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let (y, uv) = model_screen_planes(false);
        let blue = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let (y, uv) = model_screen_planes(true);
        let orange = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let (y, uv) = model_stripe_planes(false);
        let light = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let (y, uv) = model_stripe_planes(true);
        let dark = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let flat = model_scene_json("null", Some(false), "glass-lens", true, 5.0);
        let hidden = model_scene_json("null", Some(false), "glass-lens", false, 5.0);
        let bare = compose_model(&comp, &blue, &hidden, &model_track("arrow", false, 0.5));
        let bare_orange = compose_model(&comp, &orange, &hidden, &model_track("arrow", false, 0.5));
        let bare_light = compose_model(&comp, &light, &hidden, &model_track("arrow", false, 0.5));
        let bare_dark = compose_model(&comp, &dark, &hidden, &model_track("arrow", false, 0.5));
        let bare_edges = model_stripe_edges(&bare_light, &bare_dark, |_| true);
        let mut failures = Vec::new();
        for state in ["arrow", "pointer"] {
            let still = model_track(state, false, 0.5);
            let sprite = compose_model(&comp, &blue, &flat, &still);
            let json = flat.replace(&format!(r#"/{state}.png","#), &format!(r#"/{state}.png","glass":"glass-lens/{state}","#));
            let (on_blue, on_orange) = (compose_model(&comp, &blue, &json, &still), compose_model(&comp, &orange, &json, &still));
            let (on_light, on_dark) = (compose_model(&comp, &light, &json, &still), compose_model(&comp, &dark, &json, &still));
            model_save(&format!("glass-flat-{state}"), &on_blue);
            model_save(&format!("glass-flat-{state}-stripes"), &on_light);
            if on_blue == sprite {
                failures.push(format!("glass-lens/{state}: le sprite plat au lieu du verre"));
            }
            let (tip, u) = model_tip(&json, &still);
            let rgb = |img: &[u8], i: usize| [img[i * 4], img[i * 4 + 1], img[i * 4 + 2]];
            let (mut body, mut c, mut near) = (0usize, [0.0f32; 2], f32::MAX);
            let (mut through, mut line) = (0usize, 0usize);
            for i in 0..1280 * 720 {
                let (a, b) = (rgb(&on_blue, i), rgb(&on_orange, i));
                if a == rgb(&bare, i) && b == rgb(&bare_orange, i) {
                    continue;
                }
                let (x, y) = ((i % 1280) as f32, (i / 1280) as f32);
                body += 1;
                c = [c[0] + x, c[1] + y];
                near = near.min((x - tip[0]).hypot(y - tip[1]));
                if a != b {
                    through += 1;
                } else if model_luma(&a) < 60.0 {
                    line += 1;
                }
            }
            let c = [c[0] / body.max(1) as f32, c[1] / body.max(1) as f32];
            // Les bords vus au travers du verre, chacun à sa distance du bord le plus proche de la
            // même ligne sans lui.
            let in_glass = |i: usize| rgb(&on_light, i) != rgb(&bare_light, i) || rgb(&on_dark, i) != rgb(&bare_dark, i);
            let shifts: Vec<f32> = model_stripe_edges(&on_light, &on_dark, in_glass)
                .iter()
                .zip(&bare_edges)
                .flat_map(|(seen, under)| seen.iter().map(|e| under.iter().map(|b| (e - b).abs()).fold(f32::MAX, f32::min)))
                .collect();
            let shifted = shifts.iter().filter(|s| **s >= 3.0).count();
            let widest = shifts.iter().copied().fold(0.0, f32::max);
            println!(
                "glass-lens/{state} a plat : unite {u:.1} px, corps {body} px, a {near:.1} px du hotspot {tip:?}, \
                 centroide {c:?}, {through} px laissent voir l'ecran, {line} px de trait, {} bords vus au travers, \
                 {shifted} decales de 3 px ou plus, jusqu'a {widest:.1} px",
                shifts.len()
            );
            if (body as f32) < 0.12 * u * u {
                failures.push(format!("glass-lens/{state}: {body} px de corps pour {u:.0} px d'unite"));
            }
            if near > 0.08 * u {
                failures.push(format!("glass-lens/{state}: le verre est a {near:.1} px du hotspot"));
            }
            if !(c[0] > tip[0] && c[1] > tip[1] + 0.2 * u) {
                failures.push(format!("glass-lens/{state}: corps en {c:?}, pas en bas a droite de {tip:?}"));
            }
            if through * 10 < body * 5 {
                failures.push(format!("glass-lens/{state}: l'ecran ne se voit que sur {through} px"));
            }
            if line * 20 < body {
                failures.push(format!("glass-lens/{state}: {line} px de trait seulement"));
            }
            if shifted < 10 {
                failures.push(format!(
                    "glass-lens/{state}: le verre ne decale que {shifted} bords de 3 px ou plus, au plus de {widest:.1} px"
                ));
            }
        }
        assert!(failures.is_empty(), "{failures:#?}");
    }

    /// Le métrage, puis ses flous de confidentialité, puis le curseur, net par-dessus (parité
    /// Windows et macOS) : le cristal de Prism Glow réfracte l'image déjà floutée. Sous le flou,
    /// des rayures fines décalées d'une colonne donnent la même image floutée ; si le verre lisait
    /// la vidéo brute, il montrerait les rayures, et les deux rendus différeraient à travers lui.
    #[test]
    fn the_crystal_refracts_the_blurred_picture() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        // Moitié gauche grise, moitié droite (la zone floutée) rayée une colonne sur deux.
        let (w, h) = (640u32, 360u32);
        let stripes = |phase: u32| {
            let y: Vec<u8> = (0..w * h)
                .map(|i| if i % w < w / 2 { 150 } else if (i % w + phase) % 2 == 0 { 40 } else { 220 })
                .collect();
            FakeFrame::from_planes(&gpu, w, h, &y, &vec![128; (w * (h / 2)) as usize])
        };
        let (a, b) = (stripes(0), stripes(1));
        let blur = r#""annotations":[{"id":"b","startSec":0,"endSec":10,"kind":"blur","x":0.5,"y":0.0,"w":0.5,"h":1.0,"blur":{"style":"blur","shape":"rectangle","color":"white","intensity":24,"blockSize":16}}]"#;
        let json = |show: bool| {
            model_scene_json("null", Some(true), "default", show, 5.0)
                .replace(r#"/arrow.png","#, r#"/arrow.png","sculpt":"prism-glow/arrow","#)
                .replace(r#""annotations":[]"#, blur)
        };
        let mut failures = Vec::new();
        // Tout entier dans la zone, puis à cheval sur son bord.
        for x in [0.7f32, 0.48] {
            let track = crate::cursor::CursorTrack::new(vec![(0.0, x, 0.45), (9.0, x, 0.45)], vec![], vec![(0.0, "arrow".to_string())]);
            let (ra, rb) = (compose_model(&comp, &a, &json(true), &track), compose_model(&comp, &b, &json(true), &track));
            let bare = compose_model(&comp, &a, &json(false), &track);
            model_save(&format!("glass-over-blur-{x}"), &ra);
            let px = |img: &[u8], i: usize, c: usize| img[i * 4 + c] as i32;
            let hidden = (0..1280 * 720).filter(|&i| (0..3).any(|c| (px(&ra, i, c) - px(&rb, i, c)).abs() > 24)).count();
            // Le serti net du curseur : des sauts francs, entre voisins, de ce qu'il change.
            let d = |i: usize, c: usize| px(&ra, i, c) - px(&bare, i, c);
            let sharp = (0..1280 * 720 - 1)
                .filter(|&i| i % 1280 < 1279 && (0..3).any(|c| (d(i, c) - d(i + 1, c)).abs() > 60))
                .count();
            println!("cristal en x = {x} : {sharp} bords francs, {hidden} px qui suivent les rayures cachées");
            if sharp < 50 {
                failures.push(format!("x = {x} : {sharp} bords francs, le curseur n'est pas net par-dessus le flou"));
            }
            if hidden > 0 {
                failures.push(format!("x = {x} : {hidden} px montrent les rayures cachées sous le flou"));
            }
        }
        assert!(failures.is_empty(), "{failures:#?}");
    }

    /// Les thèmes cerclés gardent le trait de leur dessin (`design/cursors/<thème>`) : sur la
    /// fleche comme sur la main, le modele est pour une bonne part de la couleur du trait (le
    /// plateau, le jonc, les rainures entre les doigts), autour de la couleur du corps, et montre
    /// ce qu'il porte devant : l'etoile jaune de Star Sprout, le calque et les tirets jaunes de la
    /// fleche de Pop Coral, les tirets corail de sa main. Les parts comptent les pixels francs :
    /// ceux que l'antialiasing mêle aux bords n'entrent dans aucune.
    #[test]
    fn the_rimmed_models_keep_the_outline_of_their_art() {
        type Rgb = [i32; 3];
        let navy = |[r, g, b]: Rgb| b > r + 20 && r < 110 && g < 130;
        let black = |[r, g, b]: Rgb| r.max(g).max(b) < 70;
        let mint = |[r, g, b]: Rgb| g > 200 && g > r + 15 && b > 150;
        let ivory = |[r, g, b]: Rgb| r > 200 && g > 190 && b > 160 && r - b < 70;
        let coral = |[r, g, b]: Rgb| r > 200 && g < 150 && b < 140;
        let yellow = |[r, g, b]: Rgb| r > 200 && g > 150 && b < 120;
        // (thème, état, trait, corps, ornement, parts minimales du trait, du corps, de l'ornement)
        let cases: [(&str, &str, &dyn Fn(Rgb) -> bool, &dyn Fn(Rgb) -> bool, &dyn Fn(Rgb) -> bool, [f32; 3]); 6] = [
            ("studio-ink", "arrow", &black, &ivory, &|_| false, [0.3, 0.15, 0.0]),
            ("studio-ink", "pointer", &black, &ivory, &|_| false, [0.2, 0.3, 0.0]),
            ("pop-coral", "arrow", &navy, &coral, &yellow, [0.2, 0.2, 0.05]),
            ("pop-coral", "pointer", &navy, &yellow, &coral, [0.18, 0.3, 0.02]),
            ("star-sprout", "arrow", &navy, &mint, &yellow, [0.25, 0.2, 0.03]),
            ("star-sprout", "pointer", &navy, &ivory, &yellow, [0.25, 0.2, 0.03]),
        ];
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let (y, uv) = model_screen_planes(false);
        let blue = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let (y, uv) = model_screen_planes(true);
        let orange = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);
        let extruded = model_scene_json("null", Some(true), "default", true, 5.0);
        let hidden = model_scene_json("null", Some(true), "default", false, 5.0);
        let bare = compose_model(&comp, &blue, &hidden, &model_track("arrow", false, 0.5));
        let mut failures = Vec::new();
        for (theme, state, rim, body, extra, [min_rim, min_body, min_extra]) in cases {
            let still = model_track(state, false, 0.5);
            let json = extruded
                .replace(&format!(r#"/{state}.png","#), &format!(r#"/{state}.png","sculpt":"{theme}/{state}","#));
            let (hover, hover_b) = (compose_model(&comp, &blue, &json, &still), compose_model(&comp, &orange, &json, &still));
            let mask = model_opaque(&hover, &hover_b, &bare);
            let (mut total, mut counts) = (0usize, [0usize; 3]);
            for (i, _) in mask.iter().enumerate().filter(|(_, m)| **m) {
                let p = [hover[i * 4] as i32, hover[i * 4 + 1] as i32, hover[i * 4 + 2] as i32];
                total += 1;
                for (k, class) in [rim, body, extra].iter().enumerate() {
                    counts[k] += usize::from(class(p));
                }
            }
            let [rim_share, body_share, extra_share] = counts.map(|k| k as f32 / total.max(1) as f32);
            println!("{theme}/{state} : {total} px, trait {rim_share:.3}, corps {body_share:.3}, ornement {extra_share:.3}");
            if !(min_rim..0.7).contains(&rim_share) {
                failures.push(format!("{theme}/{state}: {rim_share:.3} de trait, il a disparu ou tout mange"));
            }
            if body_share < min_body {
                failures.push(format!("{theme}/{state}: {body_share:.3} de couleur du corps"));
            }
            if extra_share < min_extra {
                failures.push(format!("{theme}/{state}: {extra_share:.3} d'ornement"));
            }
        }
        assert!(failures.is_empty(), "{failures:#?}");
    }

    /// Pendant de `tests/cursor_tap_render.rs` (Windows) : sous un lissage qui traine loin
    /// derriere la souris, la pointe du modele se pose sur la pastille rouge du clic, et l'anneau
    /// de l'impact (mode 16) l'entoure, a plat et incline.
    #[test]
    fn the_modelled_tip_taps_the_marked_click_target() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let (w, h) = (640u32, 360u32);
        // Pastille de 5 texels au centre d'un bloc de chroma : symetrique, chroma comprise.
        let (tx, ty) = (193.0f32, 129.0f32);
        let red = |x: f32, y: f32| (x - tx).hypot(y - ty) <= 5.0;
        let (mut yp, mut uvp) = model_screen_planes(false);
        for row in 0..h {
            for col in 0..w {
                // Un carre uni autour de la cible : l'anneau s'y mesure sans les barres.
                if (col as f32 - tx).abs() < 45.0 && (row as f32 - ty).abs() < 45.0 {
                    yp[(row * w + col) as usize] = 150;
                }
                if red(col as f32 + 0.5, row as f32 + 0.5) {
                    yp[(row * w + col) as usize] = 63;
                }
            }
        }
        for row in 0..h / 2 {
            for col in 0..w / 2 {
                if red(2.0 * col as f32 + 1.0, 2.0 * row as f32 + 1.0) {
                    let i = (row * w + 2 * col) as usize;
                    uvp[i] = 102;
                    uvp[i + 1] = 240;
                }
            }
        }
        let screen = FakeFrame::from_planes(&gpu, w, h, &yp, &uvp);
        // Arrivee sur la cible a 1,7 s, depart a 2,1 s, clic a `tc` entre les deux ; lisse a 0,5.
        let target = (tx / w as f32, ty / h as f32);
        let gesture = |tc: f32| {
            let samples = (0..=240)
                .map(|k| {
                    let t = k as f32 / 60.0;
                    let (x, y) = if t < 1.7 {
                        let f = t / 1.7;
                        (0.1 + (target.0 - 0.1) * f, 0.8 + (target.1 - 0.8) * f)
                    } else if t < 2.1 {
                        target
                    } else {
                        let f = ((t - 2.1) / 0.5).min(1.0);
                        (target.0 + 0.3 * f, target.1 + 0.2 * f)
                    };
                    (t, x, y)
                })
                .collect();
            crate::cursor::CursorTrack::new(samples, vec![tc], vec![(0.0, "arrow".to_string())]).smoothed(0.5)
        };
        let (contact, ring) = (gesture(2.0 - 0.0495), gesture(2.0 - 0.16));
        let px = |b: &[u8], x: i32, y: i32| {
            let i = ((y * 1280 + x) * 4) as usize;
            [b[i] as i32, b[i + 1] as i32, b[i + 2] as i32]
        };
        let is_red = |p: [i32; 3]| p[0] > p[1] + 60 && p[0] > p[2] + 60;
        for rotation in ["null", r#""iso""#] {
            let json = model_scene_json(rotation, Some(true), "default", true, 3.0);
            let hidden = json.replace(r#""rotation":"#, r#""hideCursor":true,"rotation":"#);
            let quiet = json.replace(r#""clickBounce":2.5"#, r#""clickBounce":0"#);
            let bare = compose_model(&comp, &screen, &hidden, &contact);
            let (mut sx, mut sy, mut n) = (0.0f32, 0.0f32, 0.0f32);
            for y in 0..720 {
                for x in 0..1280 {
                    if is_red(px(&bare, x, y)) {
                        (sx, sy, n) = (sx + x as f32 + 0.5, sy + y as f32 + 0.5, n + 1.0);
                    }
                }
            }
            assert!(n > 10.0, "{rotation}: pastille introuvable");
            let m = [sx / n, sy / n];
            let touch = compose_model(&comp, &screen, &json, &contact);
            model_save(&format!("tap-{}", if rotation == "null" { "flat" } else { "iso" }), &touch);
            assert!(!is_red(px(&touch, m[0] as i32, (m[1] + 2.0) as i32)), "{rotation}: la pointe manque la pastille");
            // Au-dela du bord de la pointe, que le geste du clic deplace ('quiet' reste au repos).
            // L'ecart du a l'impact, le long de deux demi-droites (haut, gauche) : meme rayon, a la
            // perspective pres sous `iso` (l'anneau y est une ellipse).
            let (on, off) = (compose_model(&comp, &screen, &json, &ring), compose_model(&comp, &screen, &quiet, &ring));
            let peak = |dx: i32, dy: i32| {
                (8..45)
                    .map(|r| {
                        let (a, b) = (px(&on, m[0] as i32 + dx * r, m[1] as i32 + dy * r), px(&off, m[0] as i32 + dx * r, m[1] as i32 + dy * r));
                        ((0..3).map(|c| (a[c] - b[c]).abs()).sum::<i32>(), r)
                    })
                    .max()
                    .unwrap()
            };
            let (up, left) = (peak(0, -1), peak(-1, 0));
            println!("{rotation} : pastille en {m:?}, anneau haut {up:?}, gauche {left:?}");
            // Le preset incliné projette le trait plus obliquement sur un bord; son contraste
            // mesuré est inférieur à celui du cas plat, sans que l'anneau disparaisse.
            let min_delta = if rotation == "null" { 60 } else { 40 };
            assert!(
                up.0 > min_delta && left.0 > min_delta,
                "{rotation}: anneau absent ({up:?} {left:?})"
            );
            let tol = if rotation == "null" { 1 } else { 2 };
            assert!((up.1 - left.1).abs() <= tol, "{rotation}: anneau decentre ({up:?} {left:?})");
        }
    }

    // -----------------------------------------------------------------------
    // Camera reelle (`orbit`, focus auto) : pendant de `tests/follow_camera_render.rs` (Windows).
    // -----------------------------------------------------------------------

    /// Le warp projectif du WGSL pose chaque ligne verticale d'une grille la ou la camera la
    /// projette (`TiltedQuad::point_px`), a un quart de pixel pres, camera tournee a fond.
    #[test]
    fn the_follow_camera_warp_lands_every_grid_line_where_projected() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
        let (w, h, grid) = (640u32, 360u32, 32u32);
        let y: Vec<u8> = (0..w * h)
            .map(|i| if (i % w) % grid < 2 || (i / w) % grid < 2 { 30 } else { 220 })
            .collect();
        let uv = vec![128u8; (w * (h / 2)) as usize];
        let screen = FakeFrame::from_planes(&gpu, w, h, &y, &uv);
        // Profondeur de champ coupee (allumee par defaut) : l'orbite a une vraie profondeur, et un
        // trait floute ne se mesure plus a +-8 px.
        let json = model_scene_json(r#""orbit","focusMode":"auto""#, None, "none", true, 0.05)
            .replace(r#""scale":1,"#, r#""scale":2.2,"#)
            .replace(r#""roundnessFrac":0.03"#, r#""roundnessFrac":0,"depthOfField":false"#);
        let scene = crate::scene::Scene::from_json(&json).expect("scene json");
        let track = crate::cursor::CursorTrack::new(vec![(0.0, 0.93, 0.08), (9.0, 0.93, 0.08)], vec![], vec![]);
        let rgba = compose_model(&comp, &screen, &json, &track);
        let cfg = {
            let mut c = crate::config::Cfg::c8();
            c.cursor = true;
            c
        };
        let g = plan_frame(&FrameGeometryInput {
            render_px: [1280.0, 720.0],
            screen_tex_px: [w as f32, h as f32],
            screen_visible_px: [w as f32, h as f32],
            webcam_visible_px: [w as f32, h as f32],
            u_max: 1.0,
            v_max: 1.0,
            frame: 0.0,
            cfg: &cfg,
            live: live_params_from_scene(&scene),
            scene: Some(&scene),
            cursor: Some(&track),
            timeline_t_override: Some(2.0),
            programme_time: None,
        });
        assert!(g.camera.is_some(), "la camera reelle doit etre posee");
        let s_px = [g.s_dst[2] * 1280.0, g.s_dst[3] * 720.0];
        let center = [(g.s_dst[0] + g.s_dst[2] * 0.5) * 1280.0, (g.s_dst[1] + g.s_dst[3] * 0.5) * 720.0];
        let quad = g.screen_tilt(s_px).expect("quad de la camera");
        let luma = |x: i32, y: i32| {
            let i = ((y * 1280 + x) * 4) as usize;
            0.2126 * rgba[i] as f32 + 0.7152 * rgba[i + 1] as f32 + 0.0722 * rgba[i + 2] as f32
        };
        let (mut worst, mut n) = (0.0f32, 0);
        for k in 0..w / grid {
            let u = (k * grid + 1) as f32 / w as f32;
            for j in 0..h / grid {
                let v = ((j * grid) as f32 + grid as f32 * 0.5 + 1.0) / h as f32;
                let p = quad.point_px(u, v);
                let (x, yy) = (center[0] + p.0, center[1] + p.1);
                if !(40.0..1240.0).contains(&x) || !(40.0..680.0).contains(&yy) {
                    continue;
                }
                // Barycentre de l'assombrissement sur la rangee, a +-8 px de la prevision.
                let (mut sum, mut wsum) = (0.0f32, 0.0f32);
                for dx in -8..=8 {
                    let xi = x.round() as i32 + dx;
                    let wgt = (200.0 - luma(xi, yy.floor() as i32)).max(0.0);
                    (sum, wsum) = (sum + wgt * (xi as f32 + 0.5), wsum + wgt);
                }
                if wsum > 200.0 {
                    worst = worst.max((sum / wsum - x).abs());
                    n += 1;
                }
            }
        }
        println!("camera reelle : {n} points de grille, ecart au rendu {worst:.2} px");
        assert!(n > 50, "trop peu de points visibles : {n}");
        assert!(worst <= 0.25, "le rendu s'ecarte de la projection de {worst:.2} px");
    }

    // -----------------------------------------------------------------------
    // Effets shader (`shader_fx`) : les tests de `compositor_windows.rs`, sur lavapipe.
    // -----------------------------------------------------------------------

    /// Une scène à fond rouge plein, l'écran rétréci par le padding : les coins sont du fond.
    fn shader_fx_scene(effects: serde_json::Value) -> Scene {
        let json = serde_json::json!({
            "clips": [],
            "layout": {"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false},
            "effects": {"padding":0.5,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0},
            "background": {"kind":"color","color":"#ff0000"},
            "zoomRegions": [],
            "cursor": {"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"},
            "cropByClip": [],
            "output": {"width":320,"height":180,"fps":null},
            "shaderEffects": effects,
        });
        Scene::from_json(&json.to_string()).expect("scène")
    }

    /// Un fragment d'effet de 1 s à 3 s, tel que l'app l'envoie.
    fn fx(code: &str, target: &str) -> serde_json::Value {
        serde_json::json!({
            "clipIndex": 0, "startSec": 1.0, "endSec": 3.0, "target": target,
            "contract": 1, "code": code,
            "params": [{"name": "level", "type": "number"}, {"name": "tint", "type": "color"}],
            "values": {"level": 1.0, "tint": [0.0, 1.0, 0.0, 1.0]},
        })
    }

    const INVERT: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> {\n    let c = frame(uv);\n    return vec4<f32>(vec3<f32>(params.level) - c.rgb, 1.0);\n}\n";
    const BLUE: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return vec4<f32>(0.0, 0.0, 1.0, 1.0); }";
    const TINT: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return params.tint; }";
    const SAME: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return frame(uv); }";

    fn fx_cfg() -> Cfg {
        let mut cfg = Cfg::c8();
        cfg.bg_blur = 0.0;
        cfg.mblur_n = 1;
        cfg
    }

    fn fx_compositor(gpu: &Gpu, w: u32, h: u32, effects: serde_json::Value) -> Compositor {
        let comp = Compositor::new_sized(gpu, w, h).expect("compositeur");
        let scene = shader_fx_scene(effects);
        comp.set_live_params(live_params_from_scene(&scene));
        comp.set_scene(Some(scene));
        comp
    }

    /// Le pixel du coin haut-gauche (du fond) après une frame composée au temps source `t`.
    fn corner_at(comp: &Compositor, gpu: &Gpu, t: f32) -> [u8; 3] {
        let screen = FakeFrame::new(gpu, 64, 64, |_, _| 126);
        comp.set_timeline_time(Some(t));
        comp.set_programme_time(Some(t));
        unsafe { comp.compose_frame(screen.as_ptr(), std::ptr::null(), 0.0, &fx_cfg()) }.expect("compose");
        let (_, _, rgba) = unsafe { comp.readback_direct() }.expect("readback");
        [rgba[0], rgba[1], rgba[2]]
    }

    /// Le coin à 2 s, dans la région, sous les effets donnés.
    fn corner_under(effects: serde_json::Value) -> Option<[u8; 3]> {
        let gpu = gpu()?;
        Some(corner_at(&fx_compositor(&gpu, 320, 180, effects), &gpu, 2.0))
    }

    /// `footage()` lit l'enregistrement à sa résolution, pas l'image composée : la source de 512 px
    /// en colonnes d'un pixel est réduite à ~90 px sous le padding, où l'image composée ne les sépare
    /// plus, mais chacune se lit blanche ou noire. Hors de 0..1, rien. Cf. compositor_windows.
    #[test]
    fn footage_reads_the_recording_at_its_own_resolution() {
        let Some(gpu) = gpu() else { return };
        let pixel = |code: &str| {
            let comp = fx_compositor(&gpu, 320, 180, serde_json::json!([fx(code, "image")]));
            let screen = FakeFrame::new(&gpu, 512, 512, |x, _| if x % 2 == 0 { 235 } else { 16 });
            comp.set_timeline_time(Some(2.0));
            comp.set_programme_time(Some(2.0));
            unsafe { comp.compose_frame(screen.as_ptr(), std::ptr::null(), 0.0, &fx_cfg()) }.expect("compose");
            let (_, _, rgba) = unsafe { comp.readback_direct() }.expect("readback");
            [rgba[0], rgba[1], rgba[2], rgba[3]]
        };
        let at = |x: &str| format!("fn effect(uv: vec2<f32>) -> vec4<f32> {{ return footage(vec2<f32>({x}, 0.5)); }}");
        let near = |got: [u8; 4], want: [u8; 4]| got.iter().zip(want).all(|(g, w)| g.abs_diff(w) <= 2);
        let white = pixel(&at("10.5 / 512.0"));
        let black = pixel(&at("11.5 / 512.0"));
        assert!(near(white, [255, 255, 255, 255]), "colonne 10 : {white:?}");
        assert!(near(black, [0, 0, 0, 255]), "colonne 11 : {black:?}");
        assert_eq!(pixel(&at("1.5")), [0, 0, 0, 0], "hors de l'enregistrement");
        let composed = |x: &str| {
            pixel(&format!("fn effect(uv: vec2<f32>) -> vec4<f32> {{ return frame(fx_from_footage(vec2<f32>({x}, 0.5))); }}"))
        };
        let (left, right) = (composed("10.5 / 512.0"), composed("11.5 / 512.0"));
        assert!(left[0].abs_diff(right[0]) < 128, "l'image composée sépare les colonnes : {left:?} {right:?}");
    }

    /// La copie de l'enregistrement coûte une passe : un effet qui ne lit pas `footage()` ne la
    /// fait jamais faire.
    #[test]
    fn an_effect_that_does_not_read_the_footage_never_paints_it() {
        let Some(gpu) = gpu() else { return };
        let comp = fx_compositor(&gpu, 320, 180, serde_json::json!([fx(INVERT, "image")]));
        corner_at(&comp, &gpu, 2.0);
        assert!(comp.footage_copy.borrow().is_none());
    }

    /// La passe de l'agent repeint l'image composée, dans sa région et nulle part ailleurs. Le
    /// compositeur par défaut est celui de l'export : il attend le pipeline, jamais de frame sans.
    #[test]
    fn a_shader_effect_repaints_the_composed_frame_inside_its_region() {
        let Some(gpu) = gpu() else { return };
        let comp = fx_compositor(&gpu, 320, 180, serde_json::json!([fx(INVERT, "image")]));
        assert_eq!(corner_at(&comp, &gpu, 0.5), [255, 0, 0], "avant la région : le fond rouge");
        assert_eq!(corner_at(&comp, &gpu, 2.0), [0, 255, 255], "dans la région : rouge inversé");
        assert_eq!(corner_at(&comp, &gpu, 3.5), [255, 0, 0], "après la région : le fond rouge");
    }

    /// La preview ne bloque pas : elle saute l'effet tant qu'il compile, et `shader_fx_landed`
    /// lui dit quand recomposer. Ensuite la frame est celle de l'export, au pixel.
    #[test]
    fn the_preview_shows_the_effect_once_it_landed() {
        let Some(gpu) = gpu() else { return };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("compositeur");
        comp.set_shader_fx_blocking(false);
        let scene = shader_fx_scene(serde_json::json!([fx(INVERT, "image")]));
        comp.set_live_params(live_params_from_scene(&scene));
        let start = std::time::Instant::now();
        comp.set_scene(Some(scene));
        while !comp.shader_fx_landed() {
            assert!(start.elapsed().as_secs() < 30, "la compilation n'a jamais abouti");
            std::thread::sleep(std::time::Duration::from_millis(1));
        }
        eprintln!("effet prêt en {:.1} ms", start.elapsed().as_secs_f64() * 1000.0);
        assert_eq!(corner_at(&comp, &gpu, 2.0), [0, 255, 255]);
    }

    /// Un WGSL invalide, une binding de plus ou un contrat inconnu ne cassent pas le rendu :
    /// l'effet ne se dessine pas, la frame reste celle de la composition. Aucun n'atteint wgpu,
    /// qui paniquerait sur une erreur de validation.
    #[test]
    fn a_broken_or_unknown_effect_leaves_the_frame_untouched() {
        let broken = fx("fn effect(uv: vec2<f32>) -> vec4<f32> { nope }", "image");
        let extra = fx(
            "@group(0) @binding(4) var<uniform> extra: vec4<f32>;\nfn effect(uv: vec2<f32>) -> vec4<f32> { return extra; }",
            "image",
        );
        let mut future = fx(BLUE, "image");
        future["contract"] = serde_json::json!(2);
        for effect in [broken, extra, future] {
            let Some(corner) = corner_under(serde_json::json!([effect])) else { return };
            assert_eq!(corner, [255, 0, 0]);
        }
    }

    /// Les paramètres arrivent dans `params` au layout de la struct générée : la couleur `tint`
    /// suit le nombre `level` dans le buffer, et se lit telle que l'app l'a écrite.
    #[test]
    fn a_color_parameter_reaches_the_shader() {
        let Some(corner) = corner_under(serde_json::json!([fx(TINT, "image")])) else { return };
        assert_eq!(corner, [0, 255, 0]);
    }

    /// La scène de ces tests masque le curseur (`cursor.show` faux) : rien n'est dessiné, mais un
    /// effet voit toujours la pointe et le clic de l'enregistrement (`effect_pointer`). Il peint
    /// `ctx.cursor.z` en rouge et `ctx.clicks[0].w` en vert : jaune, il a vu les deux.
    #[test]
    fn a_hidden_cursor_still_hands_the_effect_its_pointer_and_clicks() {
        let Some(gpu) = gpu() else { return };
        const SEES: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return vec4<f32>(ctx.cursor.z, ctx.clicks[0].w, 0.0, 1.0); }";
        let comp = fx_compositor(&gpu, 320, 180, serde_json::json!([fx(SEES, "image")]));
        comp.set_cursor(crate::cursor::CursorTrack::new_with_visibility(
            vec![(0.0, 0.5, 0.5), (4.0, 0.5, 0.5)],
            vec![1.5],
            vec![],
            vec![(0.0, true)],
        ));
        comp.set_cursor_time(Some(2.0));
        assert_eq!(corner_at(&comp, &gpu, 2.0), [255, 255, 0]);
    }

    /// `text` ne touche que le calque des textes, posé ensuite sur l'image ; `image` et `both`
    /// repeignent l'image. Sans annotation, le calque est transparent : un effet `text` qui le
    /// rend tel quel laisse l'image intacte, un effet `text` opaque la recouvre.
    #[test]
    fn the_three_targets_keep_to_their_layer() {
        let Some(image_only) = corner_under(serde_json::json!([fx(BLUE, "image")])) else { return };
        assert_eq!(image_only, [0, 0, 255]);
        let text_untouched = corner_under(serde_json::json!([fx(SAME, "text")])).unwrap();
        assert_eq!(text_untouched, [255, 0, 0], "un calque transparent ne change pas l'image");
        let text_opaque = corner_under(serde_json::json!([fx(TINT, "text")])).unwrap();
        assert_eq!(text_opaque, [0, 255, 0], "le calque des textes, opaque, posé sur l'image");
        let both = corner_under(serde_json::json!([fx(INVERT, "both")])).unwrap();
        assert_eq!(both, [0, 255, 255], "`both` repeint l'image finale");
    }

    /// Calibre les paliers de coût : le surcoût par frame d'un effet qui lit `frame()` N fois,
    /// à 1080p et en 4K, sur le GPU de la machine. Opt-in, comme les autres mesures :
    ///
    ///     OPENSCREEN_FX_BENCH=1 cargo test -p openscreen-compositor --release --lib
    ///         shader_fx_tier_calibration -- --nocapture
    ///
    /// 200 frames par mesure ; `OPENSCREEN_FX_BENCH_FRAMES=5` sur lavapipe, où 512 lectures en 4K
    /// prennent 5 s par frame.
    #[test]
    fn shader_fx_tier_calibration() {
        if std::env::var_os("OPENSCREEN_FX_BENCH").is_none() {
            eprintln!("OPENSCREEN_FX_BENCH absent — saute");
            return;
        }
        let gpu = gpu().expect("device Vulkan");
        eprintln!("backend : {:?}", gpu.backend);
        let screen = FakeFrame::new(&gpu, 1920, 1080, |x, y| ((x ^ y) & 0xff) as u8);
        let cfg = fx_cfg();
        let reads_effect = |n: u32| {
            format!(
                "fn effect(uv: vec2<f32>) -> vec4<f32> {{\n    var acc = vec4<f32>(0.0);\n    for (var i = 0; i < {n}; i++) {{\n        let a = f32(i) * 2.399;\n        acc += frame(uv + vec2<f32>(cos(a), sin(a)) * fx_px(f32(i)));\n    }}\n    return acc / {n}.0;\n}}\n"
            )
        };
        let frames: u32 = std::env::var("OPENSCREEN_FX_BENCH_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(200);
        let per_frame = |w: u32, h: u32, effects: serde_json::Value| -> f64 {
            let comp = fx_compositor(&gpu, w, h, effects);
            comp.set_timeline_time(Some(2.0));
            comp.set_programme_time(Some(2.0));
            unsafe { comp.compose_frame(screen.as_ptr(), std::ptr::null(), 0.0, &cfg) }.unwrap();
            unsafe { comp.readback_direct() }.unwrap();
            let t0 = std::time::Instant::now();
            for f in 0..frames {
                unsafe { comp.compose_frame(screen.as_ptr(), std::ptr::null(), f as f32, &cfg) }.unwrap();
            }
            unsafe { comp.readback_direct() }.unwrap();
            t0.elapsed().as_secs_f64() * 1000.0 / frames as f64
        };
        for (w, h) in [(1920u32, 1080u32), (3840, 2160)] {
            let base = (0..3).map(|_| per_frame(w, h, serde_json::json!([]))).fold(f64::MAX, f64::min);
            eprintln!("{w}x{h} : sans effet {base:.3} ms/frame");
            for reads in [1u32, 8, 32, 128, 512] {
                let code = reads_effect(reads);
                let report = crate::shader_fx::analyze(&code, &[]).expect("analyse").report;
                let with = (0..3)
                    .map(|_| per_frame(w, h, serde_json::json!([fx(&code, "image")])))
                    .fold(f64::MAX, f64::min);
                eprintln!(
                    "{w}x{h} : {reads:>3} lectures ({:>10}) : +{:.3} ms/frame",
                    report.tier.name(),
                    with - base
                );
            }
        }
    }
}

// ---------------------------------------------------------------------------
// Staging exportable en dmabuf
// ---------------------------------------------------------------------------

/// Un buffer de staging dont la MEMOIRE est exportable en dmabuf, pour qu'un
/// encodeur materiel puisse la lire sans repasser par le CPU.
///
/// POURQUOI IL EN FAUT UN DEUXIEME, ET PAS UN DRAPEAU SUR L'EXISTANT. wgpu
/// n'expose aucun moyen de demander une allocation exportable : il faut la
/// fabriquer soi-meme et la lui confier. Or `buffer_from_raw` construit un
/// `Buffer { block: None }` -- wgpu accepte d'y ECRIRE (c'est une cible de
/// `copy_texture_to_buffer` comme une autre) mais ne peut pas le faire lire par
/// le CPU, sa mecanique de mapping passant par ce bloc qu'il ne possede pas.
/// Le chemin logiciel, lui, DOIT le lire. Les deux ne peuvent donc pas partager
/// un buffer, et l'export choisit lequel il alloue selon l'encodeur retenu.
///
/// La memoire est demandee HOST_VISIBLE et HOST_COHERENT pour que la
/// verification puisse la relire directement et sans invalidation ; un chemin
/// purement GPU pourrait se passer des deux.
pub struct ExportableStaging {
    /// Vue wgpu, utilisable comme destination de copie. En `Option` UNIQUEMENT
    /// pour pouvoir la relacher explicitement avant la memoire dans `Drop`, cf.
    /// l'ordre impose la-bas.
    buffer: Option<wgpu::Buffer>,
    /// Le descripteur a passer au consommateur. Possede : ferme dans `Drop`.
    pub fd: i32,
    pub size: u64,
    device: ash::Device,
    memory: ash::vk::DeviceMemory,
}

impl ExportableStaging {
    /// La cible de copie a passer a wgpu.
    pub fn buffer(&self) -> &wgpu::Buffer {
        self.buffer.as_ref().expect("buffer relache")
    }
}

impl ExportableStaging {
    /// Relit la memoire exportee telle que le GPU l'a laissee.
    ///
    /// Passe par `vkMapMemory` et NON par wgpu, pour la raison ci-dessus. C'est
    /// ce qui permet de verifier le contenu sans encodeur : si ces octets sont
    /// ceux du chemin de relecture normal, la memoire exportee porte bien
    /// l'image composee.
    pub fn read_back(&self) -> Result<Vec<u8>> {
        unsafe {
            let p = self
                .device
                .map_memory(self.memory, 0, self.size, ash::vk::MemoryMapFlags::empty())
                .map_err(|e| anyhow::anyhow!("vkMapMemory: {e}"))?;
            let out = std::slice::from_raw_parts(p as *const u8, self.size as usize).to_vec();
            self.device.unmap_memory(self.memory);
            Ok(out)
        }
    }
}

impl Drop for ExportableStaging {
    fn drop(&mut self) {
        // L'ORDRE EST LE FOND DU SUJET, et le premier jet le faisait a l'envers :
        // il detruisait le `VkBuffer` puis liberait la memoire, alors que wgpu
        // detruit DEJA le buffer quand son wrapper tombe -- double liberation,
        // et par-dessus, memoire liberee alors qu'un buffer y etait encore lie.
        //
        // Le partage est donc : wgpu possede le HANDLE (il l'a recu par
        // `buffer_from_raw` et le detruira), nous possedons la MEMOIRE (son
        // `block` est `None`, personne d'autre ne la liberera). D'ou : relacher
        // le wrapper d'abord, liberer la memoire ensuite.
        drop(self.buffer.take());
        unsafe {
            self.device.free_memory(self.memory, None);
        }
        // Le fd est un handle a part : l'exporter duplique la propriete, donc le
        // fermer ne libere pas la memoire -- mais l'oublier fuirait un
        // descripteur par frame.
        if self.fd >= 0 {
            let _ = nix_close(self.fd);
        }
    }
}

fn nix_close(fd: i32) -> std::io::Result<()> {
    // `libc::close` sans dependance supplementaire : la libc est deja liee.
    extern "C" {
        fn close(fd: i32) -> i32;
    }
    if unsafe { close(fd) } == 0 {
        Ok(())
    } else {
        Err(std::io::Error::last_os_error())
    }
}

impl Compositor {
    /// Alloue un buffer de staging exportable de `size` octets, ou `None` si le
    /// device n'a pas ete ouvert avec les extensions de memoire externe (cf.
    /// `d3d_linux::open_device_with_dmabuf_export`).
    pub fn create_exportable_staging(&self, size: u64) -> Option<ExportableStaging> {
        use ash::vk;
        unsafe {
            self.gpu.device.as_hal::<wgpu_hal::api::Vulkan, _, _>(|hal| {
                let hal = hal?;
                let dev = hal.raw_device().clone();
                let phys = hal.raw_physical_device();
                let instance = hal.shared_instance().raw_instance();

                let mut ext_info = vk::ExternalMemoryBufferCreateInfo::default()
                    .handle_types(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
                let bci = vk::BufferCreateInfo::default()
                    .push_next(&mut ext_info)
                    .size(size)
                    .usage(vk::BufferUsageFlags::TRANSFER_DST)
                    .sharing_mode(vk::SharingMode::EXCLUSIVE);
                let raw = dev.create_buffer(&bci, None).ok()?;

                let req = dev.get_buffer_memory_requirements(raw);
                let props = instance.get_physical_device_memory_properties(phys);
                // HOST_VISIBLE pour que `read_back` puisse verifier le contenu,
                // et COHERENT parce qu'il lit SANS invalider : sur une memoire
                // seulement visible, le mapping peut rendre des octets perimes et
                // le test passerait ou echouerait selon le cache, pas selon le
                // code. Exiger les deux est plus simple qu'un
                // `vkInvalidateMappedMemoryRanges` correct a chaque lecture.
                let want = vk::MemoryPropertyFlags::HOST_VISIBLE
                    | vk::MemoryPropertyFlags::HOST_COHERENT;
                let mt = (0..props.memory_type_count).find(|i| {
                    req.memory_type_bits & (1 << i) != 0
                        && props.memory_types[*i as usize].property_flags.contains(want)
                })?;

                let mut export = vk::ExportMemoryAllocateInfo::default()
                    .handle_types(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
                let mai = vk::MemoryAllocateInfo::default()
                    .push_next(&mut export)
                    .allocation_size(req.size)
                    .memory_type_index(mt);
                let memory = dev.allocate_memory(&mai, None).ok()?;
                dev.bind_buffer_memory(raw, memory, 0).ok()?;

                let getter = ash::khr::external_memory_fd::Device::new(instance, &dev);
                let fd = getter
                    .get_memory_fd(
                        &vk::MemoryGetFdInfoKHR::default()
                            .memory(memory)
                            .handle_type(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT),
                    )
                    .ok()?;

                let hal_buf = wgpu_hal::vulkan::Device::buffer_from_raw(raw);
                let buffer = self.gpu.device.create_buffer_from_hal::<wgpu_hal::api::Vulkan>(
                    hal_buf,
                    &wgpu::BufferDescriptor {
                        label: Some("staging-exportable"),
                        size,
                        usage: wgpu::BufferUsages::COPY_DST,
                        mapped_at_creation: false,
                    },
                );
                Some(ExportableStaging { buffer: Some(buffer), fd, size, device: dev, memory })
            })
        }
    }
}

impl Compositor {
    /// Compose la frame courante en NV12 et la depose dans `staging`, dont la
    /// memoire est exportable en dmabuf. Rend la main quand le GPU a fini.
    ///
    /// PAS DE RING, PAS DE `map_async`, CONTRAIREMENT A `readback_submit_yuv`.
    /// Cette variante-ci n'a rien a faire relire par le CPU : le consommateur est
    /// l'encodeur materiel, qui lit la meme memoire par son fd. Toute la
    /// mecanique de staging mappe et de recolte differee n'aurait donc personne a
    /// servir.
    ///
    /// NE BLOQUE PAS. Rend l'index de soumission ; l'appelant attend dessus juste
    /// avant de donner le fd a l'encodeur, ce qui lui laisse la fenetre pour
    /// composer la frame suivante pendant que celle-ci finit. C'est le meme
    /// pipelining que la ring de relecture software, avec des tampons
    /// exportables a la place des buffers mappes.
    pub unsafe fn compose_into_dmabuf(
        &self,
        staging: &ExportableStaging,
    ) -> Result<wgpu::SubmissionIndex> {
        self.ensure_yuv_fmt(YuvFormat::Nv12)?;
        let (bpr_y, bpr_uv, off_uv, total) = {
            let g = self.yuv.borrow();
            let t = g.as_ref().expect("ensure_yuv");
            (t.bpr_y, t.bpr_uv, t.off_u, t.total)
        };
        if staging.size < total {
            anyhow::bail!("staging de {} octets pour {total} attendus", staging.size);
        }
        let (w, h) = (self.render_w, self.render_h);
        let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));

        let mut encoder = self
            .gpu
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("yuv-dmabuf") });
        {
            let g = self.yuv.borrow();
            let t = g.as_ref().expect("ensure_yuv");
            let (uv_view, pipe_uv, _uv) = match &t.chroma {
                Chroma::Interleaved { uv_view, pipe_uv, _uv } => (uv_view, pipe_uv, _uv),
                Chroma::Planar { .. } => {
                    anyhow::bail!("compose_into_dmabuf attend des cibles NV12")
                }
            };
            for (view, pipe) in [(&t.y_view, &t.pipe_y), (uv_view, pipe_uv)] {
                let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                    label: Some("yuv-dmabuf-plane"),
                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                        view,
                        resolve_target: None,
                        ops: wgpu::Operations {
                            load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
                            store: wgpu::StoreOp::Store,
                        },
                    })],
                    depth_stencil_attachment: None,
                    timestamp_writes: None,
                    occlusion_query_set: None,
                });
                pass.set_pipeline(pipe);
                pass.set_bind_group(0, &t.bind, &[]);
                pass.draw(0..3, 0..1);
            }
            for (tex, off, bpr, pw, ph) in
                [(&t._y, 0u64, bpr_y, w, h), (_uv, off_uv, bpr_uv, cw, ch)]
            {
                encoder.copy_texture_to_buffer(
                    wgpu::TexelCopyTextureInfo {
                        texture: tex,
                        mip_level: 0,
                        origin: wgpu::Origin3d::ZERO,
                        aspect: wgpu::TextureAspect::All,
                    },
                    wgpu::TexelCopyBufferInfo {
                        buffer: staging.buffer(),
                        layout: wgpu::TexelCopyBufferLayout {
                            offset: off,
                            bytes_per_row: Some(bpr),
                            rows_per_image: Some(ph),
                        },
                    },
                    wgpu::Extent3d { width: pw, height: ph, depth_or_array_layers: 1 },
                );
            }
        }
        Ok(self.gpu.context.submit(std::iter::once(encoder.finish())))
    }

    /// Attend qu'une soumission soit terminee.
    ///
    /// INDISPENSABLE AVANT DE PASSER LE FD. L'encodeur lit cette memoire par un
    /// chemin que wgpu ignore : rien d'autre ne garantirait que la copie a bien
    /// atterri.
    pub fn wait_submission(&self, idx: wgpu::SubmissionIndex) {
        self.gpu.device.poll(wgpu::Maintain::WaitForSubmissionIndex(idx));
    }

    /// La geometrie NV12 courante, pour decrire le dmabuf au consommateur.
    pub fn nv12_geometry(&self) -> (u32, u32, u64, u64) {
        Compositor::yuv_layout_for(self.render_w, self.render_h, YuvFormat::Nv12)
    }
}