compositor_windows.rs

//! Compositeur D3D11 : rend les calques dans un render target RGBA8, un draw par quad.
//! NV12 échantillonné depuis les textures décodeur (SRV par plan), effets en HLSL (§7).

use crate::config::Cfg;
// La géométrie de composition vit dans `frame_geometry` — voir l'en-tête de ce module
// pour le pourquoi. `pub use` sur les constantes : `pipeline_windows.rs`, `live.rs` et
// `crates/poc-d3d/src/app.rs` les lisent via `crate::compositor::…`, et ce chemin doit
// rester valable.
pub use crate::frame_geometry::{live_params_from_scene, webcam_shape_code, LayerCB,
    LiveParams, FIXTURE_FRAMES, HALF_H, HALF_W, OUT_H, OUT_W};
use crate::frame_geometry::{
    cover_crop_uv, cover_uv_rect, decode_data_uri, ease_in_out_cubic, lerp,
    lerp4, parse_hex, preset_placements, remap_box, screen_source_rect, timeline, CursorPlacement,
    FrameParams, Placement, ShadowCaster, SpriteShape, CURSOR_BASE_SIZE_FRAC, FPS,
    SCREEN_SHADOW_SPREAD_FRAC, SHADOW_TUNING_REF_PX, WEBCAM_SHADOW_OFFSET_FRAC,
    WEBCAM_SHADOW_OPACITY, WEBCAM_SHADOW_SPREAD_FRAC,
};
use crate::cursor::CursorTrack;
use crate::scene::{Scene, SceneBackground, SceneCrop, SceneCursorSprite, WallpaperMotion};
use crate::d3d::Gpu;
use crate::ffi::AVFrame;
use anyhow::{bail, Result};
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::ffi::c_void;
use windows::core::Interface;
use windows::Win32::Foundation::RECT;
use windows::Win32::Graphics::Direct3D::{
    D3D11_SRV_DIMENSION_TEXTURE2D, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
};
use windows::Win32::Graphics::Direct3D11::*;
use windows::Win32::Graphics::Dxgi::Common::*;

/// Budget du cache de textures image (`img_cache`), en octets.
///
/// Doit tenir le JEU ACTIF d'une frame — au pire un wallpaper d'écran ET un fond de caméra, que
/// rien n'empêche d'être deux 7680x7680 à 225 Mo pièce. Sous ce seuil l'éviction ne peut plus
/// rendre de mémoire sans toucher au jeu actif, ce qu'elle refuse de faire. 512 Mo borne la fuite
/// (1 774 Mo mesurés en parcourant les 18 wallpapers livrés) en laissant le jeu actif résident.
const IMG_CACHE_BUDGET_BYTES: u64 = 512 * 1024 * 1024;
















/// Cadence de l'inférence. Pas 60 : une silhouette ne bouge pas de façon perceptible en
/// 16 ms, et c'est le seul levier mesuré qui divise le coût par deux sans toucher au modèle.
const SEGMENTATION_HZ: u32 = 30;

/// Cible RGBA + staging CPU pour l'extraction de la frame webcam qui alimente le modèle.
struct SegCapture {
    rtv: ID3D11RenderTargetView,
    rt: ID3D11Texture2D,
    staging: ID3D11Texture2D,
    width: u32,
    height: u32,
}

/// Texture du masque de segmentation, recréée seulement quand la résolution du modèle change.
struct WebcamMask {
    tex: ID3D11Texture2D,
    srv: ID3D11ShaderResourceView,
    width: u32,
    height: u32,
}

/// Pyramide de la profondeur de champ (modes 8 et 18, en t5) : la vidéo en RGBA8 à
/// demi-résolution de la texture DÉCODEUR, avec sa chaîne de mips. Dimensionnée sur la texture
/// décodeur et remplie en UV plein (0..1) : ses UV sont ceux de t0/t1, et le calcul d'UV du
/// mode 8 ne change pas.
/// Le fond tel que la passe de fond (et son flou) l'a laissé dans le RT, et la clé qui le décrit.
struct BgCache {
    key: crate::frame_geometry::BackgroundKey,
    tex: ID3D11Texture2D,
}

struct DofPyramid {
    rtv: ID3D11RenderTargetView,
    srv: ID3D11ShaderResourceView,
    width: u32,
    height: u32,
}

pub struct Compositor {
    dev: ID3D11Device,
    ctx: ID3D11DeviceContext,
    rt: ID3D11Texture2D,
    rtv: ID3D11RenderTargetView,
    rt_srv: ID3D11ShaderResourceView,
    staging: ID3D11Texture2D,
    vs: ID3D11VertexShader,
    /// Le pixel shader des calques, SANS les modèles 3D (modes 15 à 17) : ils passent par
    /// `ps_models`, et `draw_layer` choisit d'après le mode (le haut de `shaders.hlsl`).
    ps: ID3D11PixelShader,
    ps_models: ID3D11PixelShader,
    vs_fs: ID3D11VertexShader,
    ps_y: ID3D11PixelShader,
    ps_uv: ID3D11PixelShader,
    sampler: ID3D11SamplerState,
    cbuf: ID3D11Buffer,
    blend: ID3D11BlendState,
    blend_none: ID3D11BlendState,
    nv12: ID3D11Texture2D, // notre NV12 simple (RT), source de la copie vers le pool encodeur
    rtv_y: ID3D11RenderTargetView,
    rtv_uv: ID3D11RenderTargetView,
    // ping-pong demi-résolution pour le flou séparable (§7 E3)
    ps_blur: ID3D11PixelShader,
    ps_tex: ID3D11PixelShader,
    half_a_rtv: ID3D11RenderTargetView,
    half_a_srv: ID3D11ShaderResourceView,
    half_b_rtv: ID3D11RenderTargetView,
    half_b_srv: ID3D11ShaderResourceView,
    // dual-Kawase : chaîne quart (480x270) + huitième (240x135)
    ps_kdown: ID3D11PixelShader,
    ps_kup: ID3D11PixelShader,
    q_rtv: ID3D11RenderTargetView,
    q_srv: ID3D11ShaderResourceView,
    e_rtv: ID3D11RenderTargetView,
    e_srv: ID3D11ShaderResourceView,
    /// Copie pleine réso de l'image composée, pour les annotations de type flou : on ne peut pas
    /// échantillonner le render target sur lequel on dessine, donc on le recopie ici d'abord.
    /// Distincte de `accum` à dessein — `accum` sert au motion blur, qui appelle `compose_frame`
    /// plusieurs fois par frame et dont l'accumulation serait écrasée.
    ann_copy: ID3D11Texture2D,
    ann_copy_srv: ID3D11ShaderResourceView,
    // accumulateur pour le flou de mouvement (supersampling temporel)
    accum: ID3D11Texture2D,
    accum_rtv: ID3D11RenderTargetView,
    accum_srv: ID3D11ShaderResourceView,
    blend_add: ID3D11BlendState,
    /// Rastérisation avec scissor, pour la seule recopie de la traînée du curseur.
    rs_scissor: ID3D11RasterizerState,
    /// Rendu isolé de l'écran cadré (ombre, cadre, métrage, appareil), transparent autour, que le
    /// mode 18 recompose le long de sa trajectoire (`FrameGeometry::screen_trail`). Distinct de
    /// `accum`, que le curseur et `compose_frame_mb` remplissent dans la même frame.
    trail_rtv: ID3D11RenderTargetView,
    trail_srv: ID3D11ShaderResourceView,
    /// Le dernier fond fixe composé et sa clé (`BackgroundKey`) : recopié dans le RT tant
    /// que la clé tient, au lieu d'être redessiné.
    bg_cache: RefCell<Option<BgCache>>,
    /// RefCell (pas un simple champ) pour que `set_cursor` reste `&self`, comme `set_scene` /
    /// `set_live_params` — nécessaire pour le rebrancher par clip dans l'export multiclip, qui
    /// n'a qu'une référence partagée au `Compositor`.
    cursor: RefCell<Option<CursorTrack>>,
    /// Override du temps d'échantillonnage curseur (secondes) — `None` = comportement fixture
    /// (`frame / FPS`). L'export multiclip et le live le positionnent au PTS écran courant,
    /// c'est-à-dire au temps source absolu du clip actif.
    cursor_t_override: 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>>,
    /// Override du temps des zoom/full-camera regions (secondes source du clip actif). Le nom
    /// `timeline_t_override` est conservé pour l'API existante, mais ce temps n'est plus cumulé
    /// entre clips : les régions projetées par l'app portent elles aussi des temps source.
    /// Séparé de l'override curseur pour préserver les chemins fixture sans télémétrie.
    timeline_t_override: RefCell<Option<f32>>,
    /// Temps programme (secondes de sortie) — cf. `FrameGeometryInput::programme_time`.
    programme_time: RefCell<Option<f32>>,
    /// A private copy of a decoder surface, with its two plane views (Y, UV).
    /// Keyed by the decoder texture's pointer, which pins nothing: `nv12_srvs` re-checks
    /// the copy's size and format on every hit, so a new texture landing on an old address
    /// is never handed a copy sized for the old one. `clear_srv_cache` frees stale entries.
    srv_cache: RefCell<HashMap<usize, (ID3D11Texture2D, ID3D11ShaderResourceView, ID3D11ShaderResourceView)>>,
    live_params: RefCell<LiveParams>,
    /// Scène pilotée par l'app (contrat) : quand présente, remplace le layout fixture de
    /// `timeline()`. Voir `scene.rs` / `SceneDescription` (TS).
    scene: RefCell<Option<Scene>>,
    /// Rastériseur de texte (Direct2D/DirectWrite). `Option` parce qu'un échec d'init des
    /// fabriques ne doit pas empêcher tout le compositeur de tourner : sans lui, les annotations
    /// texte sont simplement absentes, comme avant.
    text_raster: Option<crate::text::TextRasterizer>,
    /// Cache des textures de texte, indexé sur l'ID d'annotation. La `u64` est la clé de contenu
    /// (`TextSpec::cache_key`) : on ne re-rastérise que si elle change, donc jamais pour un
    /// déplacement ou une animation.
    text_cache: RefCell<HashMap<String, (ID3D11ShaderResourceView, u64)>>,
    /// Cache des textures d'annotation image, indexé sur l'ID d'annotation (SRV, w, h, longueur
    /// de la source). Séparé de `img_cache` : les wallpapers sont des chemins disque, ces images
    /// des data URL de plusieurs Mo qu'on ne veut pas utiliser comme clés de hachage.
    ann_img_cache: RefCell<HashMap<String, (ID3D11ShaderResourceView, u32, u32, usize)>>,
    /// Cache des textures wallpaper image (clé = chemin absolu) : décodé et uploadé une fois,
    /// puis réutilisé par frame. (SRV, largeur, hauteur, tick d'usage).
    ///
    /// « Une fois » et non « une fois pour la session » : l'entrée est évinçable dès qu'elle
    /// sort du jeu actif d'une frame, et un retour dessus la rechargera — cf. `cached_image`.
    img_cache: RefCell<HashMap<String, (ID3D11ShaderResourceView, u32, u32, u64)>>,
    /// Compteur d'accès de `img_cache`, pour l'ordre LRU. Un compteur plutôt que l'index de
    /// frame : une frame touche plusieurs entrées, et il faut pouvoir les ordonner entre elles.
    img_tick: std::cell::Cell<u64>,
    /// Valeur de `img_tick` au début de la frame en cours. Tout ce qui a été touché depuis
    /// appartient au jeu actif et ne peut pas être évincé — voir `cached_image`.
    img_frame_start: std::cell::Cell<u64>,
    /// Champs de distance des sprites de curseur (mode 15), R16F, par chemin, avec leur forme.
    /// Pas d'éviction : seuls les sprites du thème en cours y passent (~2,6 Mo pour les seize).
    sdf_cache: RefCell<HashMap<String, (ID3D11ShaderResourceView, SpriteShape)>>,
    /// Masque de segmentation du sujet webcam, R8 à la résolution du modèle. Écrit par
    /// `set_webcam_mask` depuis le thread d'inférence, lu au moment de dessiner la webcam.
    /// `None` tant qu'aucune frame n'a été segmentée — l'effet reste alors éteint plutôt que
    /// de rendre une webcam invisible en mode détourage.
    webcam_mask: RefCell<Option<WebcamMask>>,
    /// Dimensions du RENDER TARGET en pixels — la taille à laquelle `compose_frame`
    /// rastérise réellement, et donc le dénominateur de TOUTE conversion
    /// normalisé↔px de ce fichier.
    ///
    /// Historiquement c'était la constante `OUT_W`×`OUT_H` : un canvas 16:9 figé,
    /// étiré en fin de pipeline vers la vraie sortie. Cette constante produisait
    /// deux défauts distincts, tous deux issus d'elle seule :
    ///   - une **forme** fausse dès que la sortie n'est pas 16:9 → rattrapée à
    ///     l'époque en aval par `apply_undistort` (9 correctifs successifs sur
    ///     l'écran, la webcam, le curseur, les ombres, les coins, le crop, le fond) ;
    ///   - une **résolution** plafonnée → jamais rattrapée, parce qu'aucun
    ///     correctif au niveau du calque ne peut recréer des pixels qui n'ont pas
    ///     été rastérisés (un export 4K était du 1080p agrandi).
    ///
    /// Rendre cette taille variable a retiré la cause commune, et `apply_undistort`
    /// avec elle : le RT porte la géométrie de sortie. L'export le crée à la taille de
    /// sortie, la preview à cette géométrie ramenée au panneau (`preview_render_size`).
    /// `OUT_W`/`OUT_H` ne sont plus qu'une valeur par défaut : la taille du RT de
    /// `Compositor::new`, et la référence en px des placements de repli
    /// (`preset_placements`, la fixture `timeline`) quand la scène n'apporte pas ses
    /// rects. Une scène de l'app, qui fournit ses rects, ne s'y réfère pas.
    render_size: Cell<(u32, u32)>,
    /// Ressources de resize, allouées paresseusement à la première cible qui diffère de la
    /// taille de rendu. Le RT suivant la sortie, le cas nominal n'y passe pas et ne paie rien.
    /// Voir `rgb_to_nv12_scaled`.
    resize_target: RefCell<Option<ResizeTarget>>,
    /// Cache de la staging texture de `readback_resized`, dimensionnée à la dernière taille
    /// demandée (le `staging` principal, lui, suit la taille de rendu). Recréée quand la taille
    /// change. La preview n'y passe plus : elle relit le RT tel quel (`readback_direct`).
    live_readback_staging: RefCell<Option<(u32, u32, ID3D11Texture2D)>>,
    /// Cible + staging pour extraire la frame webcam à la résolution du modèle de
    /// segmentation. Créée à la première capture, jamais redimensionnée : le modèle a une
    /// entrée fixe.
    seg_capture: RefCell<Option<SegCapture>>,
    /// Worker d'inférence, absent tant que `enable_segmentation` n'a pas été appelé.
    seg_worker: RefCell<Option<crate::segmentation::SegmentationWorker>>,
    /// Segmenteur tenu SUR LE THREAD DE RENDU, utilisé à la place du worker en mode
    /// déterministe. Voir `set_segmentation_deterministic`.
    seg_sync: RefCell<Option<crate::segmentation::Segmenter>>,
    /// Export : cadence par frame et inférence synchrone, au lieu de l'horloge et du worker.
    seg_deterministic: std::cell::Cell<bool>,
    /// Boîte aux lettres du worker. Le masque est déposé depuis le thread d'inférence et
    /// téléversé depuis le thread de rendu : aucun appel D3D ne traverse de thread, malgré
    /// le device multithread-protected qui l'autoriserait.
    seg_inbox: std::sync::Arc<std::sync::Mutex<Option<Vec<u8>>>>,
    seg_rate: RefCell<crate::segmentation::RateLimiter>,
    /// Frame RGB réutilisée d'une capture à l'autre.
    seg_scratch: RefCell<Vec<u8>>,
    /// Le chargement du modèle a échoué : ne pas réessayer à chaque frame.
    seg_failed: RefCell<bool>,
    /// Staging NV12 du readback d'ENCODAGE (backend CPU) — même motif de cache par taille
    /// que `live_readback_staging`, mais en NV12 et non en RGBA : l'encodeur logiciel veut
    /// les plans Y/UV, pas des pixels RGBA. Voir `read_nv12_scaled`.
    nv12_readback_staging: RefCell<Option<(u32, u32, ID3D11Texture2D)>>,
    /// Pyramide de profondeur de champ, allouée au premier écran incliné et recréée quand la
    /// texture décodeur change de taille. Rien n'est alloué tant qu'aucun tilt n'est rendu.
    dof_pyramid: RefCell<Option<DofPyramid>>,
    /// Device WARP : la profondeur de champ y obéit à `DOF_ON_CPU_BACKEND`.
    cpu_backend: bool,
}

/// Ressources d'un resize à une taille cible : RGBA intermédiaire (le RT composé, rendu à la
/// taille de rendu, redimensionné en bilinéaire) + sa propre texture NV12 à cette même taille
/// cible (le NV12 principal du `Compositor` reste à la taille de rendu).
struct ResizeTarget {
    w: u32,
    h: u32,
    rgba_rtv: ID3D11RenderTargetView,
    rgba_srv: ID3D11ShaderResourceView,
    nv12: ID3D11Texture2D,
    nv12_rtv_y: ID3D11RenderTargetView,
    nv12_rtv_uv: ID3D11RenderTargetView,
}

/// Tout ce qui a la taille du rendu, et rien d'autre : ce que `new_inner` alloue et que
/// `resized` réalloue. Le reste du compositeur ne dépend pas de la taille et la traverse.
struct Targets {
    rt: ID3D11Texture2D,
    rtv: ID3D11RenderTargetView,
    rt_srv: ID3D11ShaderResourceView,
    staging: ID3D11Texture2D,
    nv12: ID3D11Texture2D,
    rtv_y: ID3D11RenderTargetView,
    rtv_uv: ID3D11RenderTargetView,
    half_a_rtv: ID3D11RenderTargetView,
    half_a_srv: ID3D11ShaderResourceView,
    half_b_rtv: ID3D11RenderTargetView,
    half_b_srv: ID3D11ShaderResourceView,
    q_rtv: ID3D11RenderTargetView,
    q_srv: ID3D11ShaderResourceView,
    e_rtv: ID3D11RenderTargetView,
    e_srv: ID3D11ShaderResourceView,
    ann_copy: ID3D11Texture2D,
    ann_copy_srv: ID3D11ShaderResourceView,
    accum: ID3D11Texture2D,
    accum_rtv: ID3D11RenderTargetView,
    accum_srv: ID3D11ShaderResourceView,
    trail_rtv: ID3D11RenderTargetView,
    trail_srv: ID3D11ShaderResourceView,
}












/// Bytecode d'un point d'entrée de `shaders.hlsl`, compilé par `build.rs` (`compile_hlsl`) :
/// aucun `D3DCompile` à l'exécution, donc rien à payer quand le compositeur se construit.
macro_rules! shader {
    ($entry:literal) => {
        include_bytes!(concat!(env!("OUT_DIR"), "/", $entry, ".cso"))
    };
}

impl Compositor {
    /// Compositeur à la taille de rendu par défaut (`OUT_W`×`OUT_H`).
    /// Préférer `new_sized` dès qu'on connaît la géométrie de sortie réelle.
    pub fn new(gpu: &Gpu) -> Result<Compositor> {
        Self::new_sized(gpu, OUT_W, OUT_H)
    }

    /// Compositeur rastérisant à `w`×`h`.
    ///
    /// La taille de rendu est fixée à la construction plutôt que mutable à chaud :
    /// la rendre variable imposerait de passer le RT, la NV12, la staging et toute
    /// la pyramide de flou en `RefCell`, donc d'ajouter de la mutabilité intérieure
    /// sur le chemin GPU chaud. Pour changer de taille, `resized` rend un
    /// compositeur dont seules les cibles sont neuves.
    ///
    /// Les dimensions passées sont arrondies via `normalize_render_size` (pair,
    /// ≥2 — contrainte NV12). L'appelant qui décide de reconstruire DOIT comparer
    /// sa taille voulue à `normalize_render_size(...)` et non à la valeur brute :
    /// sinon une cible impaire ne serait jamais atteinte par `render_size()` (qui
    /// renvoie la valeur arrondie), et le compositeur se reconstruirait à chaque
    /// frame. C'est justement pour rendre cette règle partageable qu'elle est une
    /// fonction publique et non un calcul enfoui ici.
    pub fn new_sized(gpu: &Gpu, w: u32, h: u32) -> Result<Compositor> {
        let (w, h) = Self::normalize_render_size(w, h);
        unsafe { Self::new_inner(gpu, w, h) }
    }

    /// Arrondit une taille de rendu voulue à ce qu'un render target peut réellement
    /// être : au pair supérieur (la texture NV12 est en 4:2:0, chroma
    /// sous-échantillonnée 2×2, et `CreateTexture2D` refuse une dimension impaire),
    /// jamais sous 2. UNE seule définition de la règle, appelée par `new_sized`
    /// (côté production de la taille) et par la boucle de preview (côté décision de
    /// reconstruire) — les deux ne peuvent donc pas diverger.
    pub fn normalize_render_size(w: u32, h: u32) -> (u32, u32) {
        (((w.max(2) + 1) & !1), ((h.max(2) + 1) & !1))
    }

    /// Le même compositeur, rastérisant à `w`×`h` : seules les cibles (`Targets`) sont
    /// réallouées. Scène, paramètres, curseur, caches d'images et segmentation webcam restent en
    /// place.
    ///
    /// Reconstruire le compositeur entier, comme le faisait la preview, rechargeait le modèle de
    /// segmentation et repartait sans masque : l'effet webcam s'éteignait jusqu'à la première
    /// inférence. Un format Auto change de forme à chaque cran de padding, donc à chaque cran.
    pub fn resized(self, w: u32, h: u32) -> Result<Compositor> {
        let (w, h) = Self::normalize_render_size(w, h);
        let Targets {
            rt,
            rtv,
            rt_srv,
            staging,
            nv12,
            rtv_y,
            rtv_uv,
            half_a_rtv,
            half_a_srv,
            half_b_rtv,
            half_b_srv,
            q_rtv,
            q_srv,
            e_rtv,
            e_srv,
            ann_copy,
            ann_copy_srv,
            accum,
            accum_rtv,
            accum_srv,
            trail_rtv,
            trail_srv,
        } = unsafe { Self::make_targets(&self.dev, w, h)? };
        Ok(Compositor {
            rt,
            rtv,
            rt_srv,
            staging,
            nv12,
            rtv_y,
            rtv_uv,
            half_a_rtv,
            half_a_srv,
            half_b_rtv,
            half_b_srv,
            q_rtv,
            q_srv,
            e_rtv,
            e_srv,
            ann_copy,
            ann_copy_srv,
            accum,
            accum_rtv,
            accum_srv,
            trail_rtv,
            trail_srv,
            render_size: Cell::new((w, h)),
            // Caches dimensionnés à l'ancienne taille : recréés à la demande.
            resize_target: RefCell::new(None),
            bg_cache: RefCell::new(None),
            live_readback_staging: RefCell::new(None),
            nv12_readback_staging: RefCell::new(None),
            ..self
        })
    }

    unsafe fn make_targets(dev: &ID3D11Device, out_w: u32, out_h: u32) -> Result<Targets> {
        // --- render target RGBA8 (gamma natif de la vidéo ; voir note couleur docs) ---
        let mut td = D3D11_TEXTURE2D_DESC {
            Width: out_w,
            Height: out_h,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_R8G8B8A8_UNORM,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        let mut rt: Option<ID3D11Texture2D> = None;
        dev.CreateTexture2D(&td, None, Some(&mut rt))?;
        let rt = rt.unwrap();
        let mut rtv: Option<ID3D11RenderTargetView> = None;
        dev.CreateRenderTargetView(&rt, None, Some(&mut rtv))?;
        let mut rt_srv: Option<ID3D11ShaderResourceView> = None;
        dev.CreateShaderResourceView(&rt, None, Some(&mut rt_srv))?;

        // staging pour readback PNG
        td.Usage = D3D11_USAGE_STAGING;
        td.BindFlags = 0;
        td.CPUAccessFlags = D3D11_CPU_ACCESS_READ.0 as u32;
        let mut staging: Option<ID3D11Texture2D> = None;
        dev.CreateTexture2D(&td, None, Some(&mut staging))?;

        // notre texture NV12 simple (ArraySize=1) : NV12+RT n'est autorisé qu'en non-array
        // sur cet iGPU. On y rend la conversion, puis copie GPU->GPU vers le pool encodeur.
        let nvd = D3D11_TEXTURE2D_DESC {
            Width: out_w,
            Height: out_h,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_NV12,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        let mut nv12: Option<ID3D11Texture2D> = None;
        dev.CreateTexture2D(&nvd, None, Some(&mut nv12))?;
        let nv12 = nv12.unwrap();
        let mk_rtv = |fmt: DXGI_FORMAT| -> Result<ID3D11RenderTargetView> {
            let d = D3D11_RENDER_TARGET_VIEW_DESC {
                Format: fmt,
                ViewDimension: D3D11_RTV_DIMENSION_TEXTURE2D,
                Anonymous: D3D11_RENDER_TARGET_VIEW_DESC_0 {
                    Texture2D: D3D11_TEX2D_RTV { MipSlice: 0 },
                },
            };
            let mut rtv: Option<ID3D11RenderTargetView> = None;
            dev.CreateRenderTargetView(&nv12, Some(&d), Some(&mut rtv))?;
            Ok(rtv.unwrap())
        };
        let rtv_y = mk_rtv(DXGI_FORMAT_R8_UNORM)?;
        let rtv_uv = mk_rtv(DXGI_FORMAT_R8G8_UNORM)?;

        // textures RGBA RT+SRV à une taille donnée (chaîne de flou)
        let mk_rgba = |w: u32, h: u32| -> Result<(ID3D11RenderTargetView, ID3D11ShaderResourceView)> {
            let hd = D3D11_TEXTURE2D_DESC {
                Width: w,
                Height: h,
                MipLevels: 1,
                ArraySize: 1,
                Format: DXGI_FORMAT_R8G8B8A8_UNORM,
                SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
                Usage: D3D11_USAGE_DEFAULT,
                BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
                CPUAccessFlags: 0,
                MiscFlags: 0,
            };
            let mut t: Option<ID3D11Texture2D> = None;
            dev.CreateTexture2D(&hd, None, Some(&mut t))?;
            let t = t.unwrap();
            let mut rtv: Option<ID3D11RenderTargetView> = None;
            dev.CreateRenderTargetView(&t, None, Some(&mut rtv))?;
            let mut srv: Option<ID3D11ShaderResourceView> = None;
            dev.CreateShaderResourceView(&t, None, Some(&mut srv))?;
            Ok((rtv.unwrap(), srv.unwrap()))
        };
        // Pyramide dual-Kawase derivee de la taille de rendu (et non d'un demi de
        // 1080 fige) : sinon le rayon effectif du flou de fond changerait d'un format
        // a l'autre. `.max(1)` protege les tres petites tailles de preview.
        let (half_w, half_h) = ((out_w / 2).max(1), (out_h / 2).max(1));
        let (half_a_rtv, half_a_srv) = mk_rgba(half_w, half_h)?;
        let (half_b_rtv, half_b_srv) = mk_rgba(half_w, half_h)?;
        let (q_rtv, q_srv) = mk_rgba((half_w / 2).max(1), (half_h / 2).max(1))?;
        let (e_rtv, e_srv) = mk_rgba((half_w / 4).max(1), (half_h / 4).max(1))?;
        let (trail_rtv, trail_srv) = mk_rgba(out_w, out_h)?;

        // accumulateur pleine réso (RGBA)
        let ad = D3D11_TEXTURE2D_DESC {
            Width: out_w,
            Height: out_h,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_R8G8B8A8_UNORM,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        let mut accum: Option<ID3D11Texture2D> = None;
        dev.CreateTexture2D(&ad, None, Some(&mut accum))?;
        let accum = accum.unwrap();
        let mut accum_rtv: Option<ID3D11RenderTargetView> = None;
        dev.CreateRenderTargetView(&accum, None, Some(&mut accum_rtv))?;
        let mut accum_srv: Option<ID3D11ShaderResourceView> = None;
        dev.CreateShaderResourceView(&accum, None, Some(&mut accum_srv))?;

        // Copie de travail des annotations flou. Chaîne de mips COMPLÈTE (`MipLevels: 0`) : c'est
        // elle qui fournit le flou. Échantillonner un niveau plus bas donne un vrai lissage pour
        // n'importe quel rayon à coût constant, là où un noyau de quelques taps espacés produit
        // des copies fantômes au lieu d'un flou.
        let ann_desc = D3D11_TEXTURE2D_DESC {
            MipLevels: 0,
            BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
            MiscFlags: D3D11_RESOURCE_MISC_GENERATE_MIPS.0 as u32,
            ..ad
        };
        let mut ann_copy: Option<ID3D11Texture2D> = None;
        dev.CreateTexture2D(&ann_desc, None, Some(&mut ann_copy))?;
        let ann_copy = ann_copy.unwrap();
        let mut ann_copy_srv: Option<ID3D11ShaderResourceView> = None;
        dev.CreateShaderResourceView(&ann_copy, None, Some(&mut ann_copy_srv))?;

        Ok(Targets {
            rt,
            rtv: rtv.unwrap(),
            rt_srv: rt_srv.unwrap(),
            staging: staging.unwrap(),
            nv12,
            rtv_y,
            rtv_uv,
            half_a_rtv,
            half_a_srv,
            half_b_rtv,
            half_b_srv,
            q_rtv,
            q_srv,
            e_rtv,
            e_srv,
            ann_copy,
            ann_copy_srv: ann_copy_srv.unwrap(),
            accum,
            accum_rtv: accum_rtv.unwrap(),
            accum_srv: accum_srv.unwrap(),
            trail_rtv,
            trail_srv,
        })
    }

    unsafe fn new_inner(gpu: &Gpu, out_w: u32, out_h: u32) -> Result<Compositor> {
        let dev = gpu.device.clone();
        let ctx = gpu.context.clone();
        let Targets {
            rt,
            rtv,
            rt_srv,
            staging,
            nv12,
            rtv_y,
            rtv_uv,
            half_a_rtv,
            half_a_srv,
            half_b_rtv,
            half_b_srv,
            q_rtv,
            q_srv,
            e_rtv,
            e_srv,
            ann_copy,
            ann_copy_srv,
            accum,
            accum_rtv,
            accum_srv,
            trail_rtv,
            trail_srv,
        } = Self::make_targets(&dev, out_w, out_h)?;

        // --- shaders ---
        let mut vs: Option<ID3D11VertexShader> = None;
        dev.CreateVertexShader(shader!("vs_main"), None, Some(&mut vs))?;
        let mut ps: Option<ID3D11PixelShader> = None;
        dev.CreatePixelShader(shader!("ps_main"), None, Some(&mut ps))?;
        let mut ps_models: Option<ID3D11PixelShader> = None;
        dev.CreatePixelShader(shader!("ps_main_models"), None, Some(&mut ps_models))?;

        // shaders RGB->NV12
        let mut vs_fs: Option<ID3D11VertexShader> = None;
        dev.CreateVertexShader(shader!("vs_fs"), None, Some(&mut vs_fs))?;
        let mut ps_y: Option<ID3D11PixelShader> = None;
        dev.CreatePixelShader(shader!("ps_y"), None, Some(&mut ps_y))?;
        let mut ps_uv: Option<ID3D11PixelShader> = None;
        dev.CreatePixelShader(shader!("ps_uv"), None, Some(&mut ps_uv))?;

        // --- sampler bilinéaire clamp ---
        let sd = D3D11_SAMPLER_DESC {
            Filter: D3D11_FILTER_MIN_MAG_MIP_LINEAR,
            AddressU: D3D11_TEXTURE_ADDRESS_CLAMP,
            AddressV: D3D11_TEXTURE_ADDRESS_CLAMP,
            AddressW: D3D11_TEXTURE_ADDRESS_CLAMP,
            ComparisonFunc: D3D11_COMPARISON_NEVER,
            MaxLOD: f32::MAX,
            ..Default::default()
        };
        let mut sampler: Option<ID3D11SamplerState> = None;
        dev.CreateSamplerState(&sd, Some(&mut sampler))?;

        // --- constant buffer dynamique ---
        let bd = D3D11_BUFFER_DESC {
            ByteWidth: std::mem::size_of::<LayerCB>() as u32,
            Usage: D3D11_USAGE_DYNAMIC,
            BindFlags: D3D11_BIND_CONSTANT_BUFFER.0 as u32,
            CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,
            ..Default::default()
        };
        let mut cbuf: Option<ID3D11Buffer> = None;
        dev.CreateBuffer(&bd, None, Some(&mut cbuf))?;

        // --- blend alpha prémultiplié ---
        let mut bl = D3D11_BLEND_DESC::default();
        bl.RenderTarget[0] = D3D11_RENDER_TARGET_BLEND_DESC {
            BlendEnable: true.into(),
            SrcBlend: D3D11_BLEND_ONE,
            DestBlend: D3D11_BLEND_INV_SRC_ALPHA,
            BlendOp: D3D11_BLEND_OP_ADD,
            SrcBlendAlpha: D3D11_BLEND_ONE,
            DestBlendAlpha: D3D11_BLEND_INV_SRC_ALPHA,
            BlendOpAlpha: D3D11_BLEND_OP_ADD,
            RenderTargetWriteMask: D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8,
        };
        let mut blend: Option<ID3D11BlendState> = None;
        dev.CreateBlendState(&bl, Some(&mut blend))?;

        // blend désactivé mais écriture ACTIVE (le défaut a WriteMask=0 -> rien n'est écrit)
        let mut bl_none = D3D11_BLEND_DESC::default();
        bl_none.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8;
        let mut blend_none: Option<ID3D11BlendState> = None;
        dev.CreateBlendState(&bl_none, Some(&mut blend_none))?;

        // shaders de flou + copie
        let mut ps_blur: Option<ID3D11PixelShader> = None;
        dev.CreatePixelShader(shader!("ps_blur"), None, Some(&mut ps_blur))?;
        let mut ps_tex: Option<ID3D11PixelShader> = None;
        dev.CreatePixelShader(shader!("ps_tex"), None, Some(&mut ps_tex))?;

        // shaders dual-Kawase
        let mut ps_kdown: Option<ID3D11PixelShader> = None;
        dev.CreatePixelShader(shader!("ps_kawase_down"), None, Some(&mut ps_kdown))?;
        let mut ps_kup: Option<ID3D11PixelShader> = None;
        dev.CreatePixelShader(shader!("ps_kawase_up"), None, Some(&mut ps_kup))?;

        // blend additif pondéré (facteur = 1/N) de l'accumulateur
        let mut bla = D3D11_BLEND_DESC::default();
        bla.RenderTarget[0] = D3D11_RENDER_TARGET_BLEND_DESC {
            BlendEnable: true.into(),
            SrcBlend: D3D11_BLEND_BLEND_FACTOR,
            DestBlend: D3D11_BLEND_ONE,
            BlendOp: D3D11_BLEND_OP_ADD,
            SrcBlendAlpha: D3D11_BLEND_BLEND_FACTOR,
            DestBlendAlpha: D3D11_BLEND_ONE,
            BlendOpAlpha: D3D11_BLEND_OP_ADD,
            RenderTargetWriteMask: D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8,
        };
        let mut blend_add: Option<ID3D11BlendState> = None;
        dev.CreateBlendState(&bla, Some(&mut blend_add))?;
        // L'état par défaut (aucun lié), plus le scissor. Sans culling : le triangle plein écran
        // n'a pas à dépendre de son sens de parcours.
        let rsd = D3D11_RASTERIZER_DESC {
            FillMode: D3D11_FILL_SOLID,
            CullMode: D3D11_CULL_NONE,
            ScissorEnable: true.into(),
            DepthClipEnable: true.into(),
            ..Default::default()
        };
        let mut rs_scissor: Option<ID3D11RasterizerState> = None;
        dev.CreateRasterizerState(&rsd, Some(&mut rs_scissor))?;

        Ok(Compositor {
            dev,
            ctx,
            rt,
            rtv,
            rt_srv,
            staging,
            vs: vs.unwrap(),
            ps: ps.unwrap(),
            ps_models: ps_models.unwrap(),
            vs_fs: vs_fs.unwrap(),
            ps_y: ps_y.unwrap(),
            ps_uv: ps_uv.unwrap(),
            sampler: sampler.unwrap(),
            cbuf: cbuf.unwrap(),
            blend: blend.unwrap(),
            blend_none: blend_none.unwrap(),
            nv12,
            rtv_y,
            rtv_uv,
            ps_blur: ps_blur.unwrap(),
            ps_tex: ps_tex.unwrap(),
            half_a_rtv,
            half_a_srv,
            half_b_rtv,
            half_b_srv,
            ps_kdown: ps_kdown.unwrap(),
            ps_kup: ps_kup.unwrap(),
            q_rtv,
            q_srv,
            e_rtv,
            e_srv,
            ann_copy,
            ann_copy_srv,
            accum,
            accum_rtv,
            accum_srv,
            blend_add: blend_add.unwrap(),
            rs_scissor: rs_scissor.unwrap(),
            trail_rtv,
            trail_srv,
            bg_cache: RefCell::new(None),
            cursor: RefCell::new(None),
            cursor_t_override: RefCell::new(None),
            footage: std::cell::Cell::new(None),
            timeline_t_override: RefCell::new(None),
            programme_time: RefCell::new(None),
            srv_cache: RefCell::new(HashMap::new()),
            live_params: RefCell::new(LiveParams::default()),
            scene: RefCell::new(None),
            text_raster: match crate::text::TextRasterizer::new() {
                Ok(r) => Some(r),
                Err(e) => {
                    eprintln!("[texte] init Direct2D/DirectWrite impossible, annotations texte désactivées: {e}");
                    None
                }
            },
            text_cache: RefCell::new(HashMap::new()),
            ann_img_cache: RefCell::new(HashMap::new()),
            img_cache: RefCell::new(HashMap::new()),
            img_tick: std::cell::Cell::new(0),
            img_frame_start: std::cell::Cell::new(0),
            sdf_cache: RefCell::new(HashMap::new()),
            webcam_mask: RefCell::new(None),
            render_size: Cell::new((out_w, out_h)),
            resize_target: RefCell::new(None),
            live_readback_staging: 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),
            nv12_readback_staging: RefCell::new(None),
            dof_pyramid: RefCell::new(None),
            cpu_backend: gpu.backend == crate::d3d::Backend::Cpu,
        })
    }

    /// Largeur du render target en px. **Le** dénominateur de toute conversion
    /// px→normalisé de ce fichier : à utiliser partout où `OUT_W` servait de
    /// référence géométrique. Cf. `Compositor::render_size`.
    #[inline]
    fn rw(&self) -> f32 {
        self.render_size.get().0 as f32
    }

    /// Hauteur du render target en px. Cf. `Compositor::rw`.
    #[inline]
    fn rh(&self) -> f32 {
        self.render_size.get().1 as f32
    }

    /// Dimensions entières du render target — pour les viewports et les boucles
    /// de readback, qui veulent des `u32` et non des `f32`.
    #[inline]
    fn render_dims(&self) -> (u32, u32) {
        self.render_size.get()
    }

    /// Taille à laquelle ce compositeur rastérise, après l'arrondi au pair de
    /// `new_sized`. L'appelant la compare à la géométrie qu'il veut produire pour
    /// savoir s'il doit reconstruire le compositeur (cf. `new_sized`).
    pub fn render_size(&self) -> (u32, u32) {
        self.render_size.get()
    }

    /// Met à jour les paramètres continus pilotés par l'inspector (thread live uniquement).
    pub fn set_live_params(&self, p: LiveParams) {
        *self.live_params.borrow_mut() = p;
    }

    /// Rebranche le seul champ qui dépend du CLIP et non des réglages (cf. `LiveParams::has_webcam`).
    /// L'export pose ses `LiveParams` une fois pour toute la timeline, mais chaque clip a sa propre
    /// réponse à « y a-t-il une caméra ? » : d'où un setter ciblé plutôt qu'un `set_live_params`
    /// par clip, qui écraserait les réglages posés par l'appelant.
    pub fn set_has_webcam(&self, v: bool) {
        self.live_params.borrow_mut().has_webcam = v;
    }

    /// Installe (ou retire) la scène de l'app. Présente → `compose_frame` prend ses placements
    /// depuis le layout preset au lieu du planning fixture.
    pub fn set_scene(&self, s: Option<Scene>) {
        *self.scene.borrow_mut() = s;
    }

    /// The Y (R8) and UV (R8G8) views of the decoder frame — over a private COPY, never
    /// over the decoder surface itself.
    ///
    /// Two documented D3D11 rules rule out the direct path. The first is explicit, on
    /// `D3D11_BIND_DECODER`: "you cannot use texture arrays that are created with this
    /// flag in calls to ID3D11Device::CreateShaderResourceView". The ffmpeg pool IS such
    /// an array (`initial_pool_size` = 32, see `get_hw_format`). The second explains what
    /// we were seeing: between the video engine and the 3D pipeline "there is no automatic
    /// hazard tracking" — the surface stays the decoder's reference frame, so it may be
    /// rewritten WHILE the shader samples it. ffmpeg's `ID3D11VideoContext` is in fact the
    /// SAME object as our immediate context (it comes out of a QueryInterface on it), and
    /// `SetMultithreadProtected(TRUE)` only makes an individual call atomic, never a
    /// sequence.
    ///
    /// Measured on a Snapdragon X Elite (Adreno X1-85), same build, same recording, the
    /// path picked by an environment variable: 768 black frames out of 792 when sampling
    /// the decoder surface, 2 out of 545 through the copy. The black was OPAQUE and total,
    /// so not "one frame late" but no frame at all.
    ///
    /// `CopySubresourceRegion` is issued on the immediate context, so it IS ordered against
    /// the draws that follow; the destination texture is `ArraySize = 1` and carries only
    /// `BIND_SHADER_RESOURCE`, which also takes it out of the restriction above. The cost
    /// is one GPU→GPU copy per frame and per source, with nothing going back to system
    /// memory.
    ///
    /// What hid the cause for so long: exporting the SAME scene never produced a black
    /// frame (28 342 verified), because the export drains the GPU every frame through the
    /// encoder. Everything that slowed the live loop — one more readback, a lock, a pause —
    /// cut the black proportionally without ever removing it.
    pub unsafe fn nv12_srvs(
        &self,
        frame: *const AVFrame,
    ) -> Result<(ID3D11ShaderResourceView, ID3D11ShaderResourceView)> {
        let tex_ptr = (*frame).data[0] as *mut c_void;
        let slice = (*frame).data[1] as u32;
        let src = ID3D11Texture2D::from_raw_borrowed(&tex_ptr)
            .ok_or_else(|| anyhow::anyhow!("frame has no D3D11 texture"))?
            .clone();

        // Cache hit: the pool reuses the same textures, so this allocates once per decoder
        // after warmup. The COPY itself happens on EVERY frame — that is what freezes the
        // slice's contents before the decoder takes it back.
        //
        // The key is a bare address and pins nothing. A decoder replaced without
        // `clear_srv_cache` (a mid-stream resolution change, `CpuFrames::ensure_tex`) can
        // hand a NEW texture the address of an old one, and a copy into a smaller destination
        // is dropped without an error: the picture freezes. So a hit only counts while the
        // destination still has the source's size and format.
        let mut sd = D3D11_TEXTURE2D_DESC::default();
        src.GetDesc(&mut sd);
        let key = tex_ptr as usize;
        let cached = self.srv_cache.borrow().get(&key).cloned().filter(|(dst, ..)| {
            let mut dd = D3D11_TEXTURE2D_DESC::default();
            dst.GetDesc(&mut dd);
            (dd.Width, dd.Height, dd.Format) == (sd.Width, sd.Height, sd.Format)
        });
        let (dst, y, uv) = match cached {
            Some(v) => v,
            None => {
                let dd = D3D11_TEXTURE2D_DESC {
                    Width: sd.Width,
                    Height: sd.Height,
                    MipLevels: 1,
                    ArraySize: 1,
                    Format: sd.Format,
                    SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
                    Usage: D3D11_USAGE_DEFAULT,
                    BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
                    CPUAccessFlags: 0,
                    MiscFlags: 0,
                };
                let mut dst: Option<ID3D11Texture2D> = None;
                self.dev.CreateTexture2D(&dd, None, Some(&mut dst))?;
                let dst = dst.unwrap();
                let mk = |fmt: DXGI_FORMAT| -> Result<ID3D11ShaderResourceView> {
                    let mut d = D3D11_SHADER_RESOURCE_VIEW_DESC {
                        Format: fmt,
                        ViewDimension: D3D11_SRV_DIMENSION_TEXTURE2D,
                        ..Default::default()
                    };
                    d.Anonymous.Texture2D = D3D11_TEX2D_SRV { MostDetailedMip: 0, MipLevels: 1 };
                    let mut srv: Option<ID3D11ShaderResourceView> = None;
                    self.dev.CreateShaderResourceView(&dst, Some(&d), Some(&mut srv))?;
                    Ok(srv.unwrap())
                };
                let y = mk(DXGI_FORMAT_R8_UNORM)?;
                let uv = mk(DXGI_FORMAT_R8G8_UNORM)?;
                self.srv_cache
                    .borrow_mut()
                    .insert(key, (dst.clone(), y.clone(), uv.clone()));
                (dst, y, uv)
            }
        };

        self.ctx.CopySubresourceRegion(&dst, 0, 0, 0, 0, &src, slice, None);
        Ok((y, uv))
    }

    /// Dimensions réelles de la texture décodeur (alignée macrobloc : 1080->1088, etc.).
    pub unsafe fn tex_dims(&self, frame: *const AVFrame) -> (u32, u32) {
        let tex_ptr = (*frame).data[0] as *mut c_void;
        let tex = ID3D11Texture2D::from_raw_borrowed(&tex_ptr).unwrap();
        let mut d = D3D11_TEXTURE2D_DESC::default();
        tex.GetDesc(&mut d);
        (d.Width, d.Height)
    }

    /// État de composition : RT principal, viewport plein, shaders de calque, blend prémultiplié.
    /// (Sans clear — sert à reprendre après les passes de flou.)
    pub unsafe fn bind_compose_state(&self) {
        self.ctx.OMSetRenderTargets(Some(&[Some(self.rtv.clone())]), None);
        let vp = D3D11_VIEWPORT {
            TopLeftX: 0.0, TopLeftY: 0.0,
            Width: self.rw(), Height: self.rh(), MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp]));
        self.ctx.VSSetShader(&self.vs, None);
        self.ctx.PSSetShader(&self.ps, None);
        self.ctx.PSSetSamplers(0, Some(&[Some(self.sampler.clone())]));
        self.ctx.IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
        self.ctx.OMSetBlendState(&self.blend, None, 0xffffffff);
    }

    /// Prépare la passe : état de composition + clear.
    pub unsafe fn begin(&self, clear: [f32; 4]) {
        self.bind_compose_state();
        self.ctx.ClearRenderTargetView(&self.rtv, &clear);
    }

    /// Garde le fond que le RT porte à cet instant (`bg_cache`), sous `key`.
    unsafe fn keep_background(&self, key: crate::frame_geometry::BackgroundKey) -> Result<()> {
        // L'ancienne texture est reprise : `resized` vide le cache, sa taille est la bonne.
        let old = self.bg_cache.borrow_mut().take().map(|c| c.tex);
        let tex = match old {
            Some(tex) => tex,
            None => {
                let mut d = D3D11_TEXTURE2D_DESC::default();
                self.rt.GetDesc(&mut d);
                d.BindFlags = 0;
                let mut tex: Option<ID3D11Texture2D> = None;
                self.dev.CreateTexture2D(&d, None, Some(&mut tex))?;
                tex.ok_or_else(|| anyhow::anyhow!("CreateTexture2D (fond gardé)"))?
            }
        };
        self.ctx.CopyResource(&tex, &self.rt);
        *self.bg_cache.borrow_mut() = Some(BgCache { key, tex });
        Ok(())
    }

    /// Passe plein écran générique (triangle unique) : `srv` -> `rtv` via `ps`, avec `fx`.
    unsafe fn fs_pass(
        &self,
        rtv: &ID3D11RenderTargetView,
        srv: &ID3D11ShaderResourceView,
        ps: &ID3D11PixelShader,
        w: u32,
        h: u32,
        fx: [f32; 4],
    ) {
        self.ctx.OMSetBlendState(&self.blend_none, None, 0xffffffff);
        self.ctx.OMSetRenderTargets(Some(&[Some(rtv.clone())]), None);
        self.ctx.PSSetShaderResources(0, Some(&[Some(srv.clone())]));
        self.ctx.VSSetShader(&self.vs_fs, None);
        self.ctx.PSSetShader(ps, None);
        self.ctx.PSSetSamplers(0, Some(&[Some(self.sampler.clone())]));
        let vp = D3D11_VIEWPORT {
            TopLeftX: 0.0, TopLeftY: 0.0,
            Width: w as f32, Height: h as f32, MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp]));
        self.upload_cb(&LayerCB { fx, ..Default::default() });
        self.ctx.Draw(3, 0);
        self.ctx.PSSetShaderResources(0, Some(&[None]));
    }

    /// Fond flouté (§7), dual-Kawase : suppose le screen déjà dessiné plein écran dans le RT.
    /// Chaîne down (RT→960→480→240) puis up (240→480→960→RT), tronquée au nombre de niveaux
    /// que demande la force (`background_blur_steps`). ~5-8 taps par passe à résolution
    /// décroissante, vs 2 passes gaussiennes 49-tap. Le RT devient le fond.
    pub unsafe fn blur_bg(&self, amount: f32) {
        let Some((levels, off)) = crate::frame_geometry::background_blur_steps(amount) else {
            return;
        };
        // La pyramide se dérive de la taille de rendu, pas d'une constante : sinon
        // le rayon effectif du flou changerait avec la résolution de sortie (un
        // demi de 1080 n'est pas un demi de 2160), et le fond flouté ne serait plus
        // le même effet d'un format à l'autre.
        let (rw_i, rh_i) = self.render_dims();
        let (half_w, half_h) = (rw_i / 2, rh_i / 2);
        let pyramid = [
            (&self.rtv, &self.rt_srv, rw_i, rh_i),
            (&self.half_a_rtv, &self.half_a_srv, half_w, half_h),
            (&self.q_rtv, &self.q_srv, half_w / 2, half_h / 2),
            (&self.e_rtv, &self.e_srv, half_w / 4, half_h / 4),
        ];
        // texel = 1/(dims de la SOURCE échantillonnée)
        let fx = |(w, h): (u32, u32)| [1.0 / w.max(1) as f32, 1.0 / h.max(1) as f32, off, 0.0];
        for i in 0..levels {
            let (_, src, sw, sh) = pyramid[i];
            let (dst, _, dw, dh) = pyramid[i + 1];
            self.fs_pass(dst, src, &self.ps_kdown, dw, dh, fx((sw, sh)));
        }
        for i in (0..levels).rev() {
            let (_, src, sw, sh) = pyramid[i + 1];
            let (dst, _, dw, dh) = pyramid[i];
            self.fs_pass(dst, src, &self.ps_kup, dw, dh, fx((sw, sh)));
        }
    }

    /// Remplit la pyramide de profondeur de champ depuis la frame écran et rend sa SRV.
    ///
    /// UN draw du mode 0 existant, en UV plein, vers une cible demi-résolution : un échantillon
    /// bilinéaire 2:1 est une moyenne 2x2, cette cible EST donc déjà le niveau 1 d'une pyramide
    /// pleine résolution. `GenerateMips` fait le reste, comme pour `ann_copy`. Cible vidée
    /// d'abord et `color.a = 1` : un `LayerCB` par défaut a `color.a = 0`, et le mode 0 sortirait
    /// une pyramide transparente. `mb.x = 1` : un seul tap, pas de flou de mouvement.
    ///
    /// Laisse l'état de composition lié sur le RT principal ; l'appelant enchaîne sur `begin`.
    unsafe fn fill_dof_pyramid(
        &self,
        sy: &ID3D11ShaderResourceView,
        suv: &ID3D11ShaderResourceView,
        tex_w: u32,
        tex_h: u32,
    ) -> Result<ID3D11ShaderResourceView> {
        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 desc = D3D11_TEXTURE2D_DESC {
                Width: w,
                Height: h,
                MipLevels: crate::frame_geometry::dof_pyramid_levels(w, h),
                ArraySize: 1,
                Format: DXGI_FORMAT_R8G8B8A8_UNORM,
                SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
                Usage: D3D11_USAGE_DEFAULT,
                BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
                CPUAccessFlags: 0,
                MiscFlags: D3D11_RESOURCE_MISC_GENERATE_MIPS.0 as u32,
            };
            let mut tex: Option<ID3D11Texture2D> = None;
            self.dev.CreateTexture2D(&desc, None, Some(&mut tex))?;
            let tex = tex.unwrap();
            // RTV sur le niveau 0 seul (défaut), SRV sur toute la chaîne (défaut).
            let mut rtv: Option<ID3D11RenderTargetView> = None;
            self.dev.CreateRenderTargetView(&tex, None, Some(&mut rtv))?;
            let mut srv: Option<ID3D11ShaderResourceView> = None;
            self.dev.CreateShaderResourceView(&tex, None, Some(&mut srv))?;
            *self.dof_pyramid.borrow_mut() =
                Some(DofPyramid { rtv: rtv.unwrap(), srv: srv.unwrap(), width: w, height: h });
        }
        let pyr = self.dof_pyramid.borrow();
        let pyr = pyr.as_ref().expect("pyramide allouée ci-dessus");
        self.bind_compose_state();
        // Délie t5 : la pyramide y est peut-être encore liée depuis le mode 8 ou 18 précédent, et
        // une ressource liée en lecture ET en écriture est retirée d'office par le runtime.
        self.ctx.PSSetShaderResources(5, Some(&[None]));
        self.ctx.OMSetRenderTargets(Some(&[Some(pyr.rtv.clone())]), None);
        self.ctx.ClearRenderTargetView(&pyr.rtv, &[0.0, 0.0, 0.0, 0.0]);
        self.ctx.RSSetViewports(Some(&[D3D11_VIEWPORT {
            TopLeftX: 0.0,
            TopLeftY: 0.0,
            Width: w as f32,
            Height: h as f32,
            MinDepth: 0.0,
            MaxDepth: 1.0,
        }]));
        let full = [0.0, 0.0, 1.0, 1.0];
        self.draw_video(
            &LayerCB {
                dst: full,
                src: full,
                quad_px: [w as f32, h 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()
            },
            sy,
            suv,
        );
        // La pyramide quitte la sortie avant de générer ses mips.
        self.bind_compose_state();
        self.ctx.GenerateMips(&pyr.srv);
        Ok(pyr.srv.clone())
    }

    unsafe fn upload_cb(&self, cb: &LayerCB) {
        let mut m = D3D11_MAPPED_SUBRESOURCE::default();
        self.ctx
            .Map(&self.cbuf, 0, D3D11_MAP_WRITE_DISCARD, 0, Some(&mut m))
            .unwrap();
        std::ptr::copy_nonoverlapping(cb as *const LayerCB as *const u8, m.pData as *mut u8, std::mem::size_of::<LayerCB>());
        self.ctx.Unmap(&self.cbuf, 0);
        self.ctx.VSSetConstantBuffers(0, Some(&[Some(self.cbuf.clone())]));
        self.ctx.PSSetConstantBuffers(0, Some(&[Some(self.cbuf.clone())]));
    }

    /// Dessine le quad d'un calque, ses ressources déjà liées. Le pixel shader suit son mode :
    /// `ps_models` pour un modèle 3D (`LayerCB::needs_models`), `ps` pour tout le reste, qui ne
    /// paie pas ainsi les registres de ces modèles.
    unsafe fn draw_layer(&self, cb: &LayerCB) {
        self.upload_cb(cb);
        self.ctx.PSSetShader(if cb.needs_models() { &self.ps_models } else { &self.ps }, None);
        self.ctx.Draw(4, 0);
    }

    /// Calque vidéo NV12.
    pub unsafe fn draw_video(
        &self,
        cb: &LayerCB,
        srv_y: &ID3D11ShaderResourceView,
        srv_uv: &ID3D11ShaderResourceView,
    ) {
        self.ctx
            .PSSetShaderResources(0, Some(&[Some(srv_y.clone()), Some(srv_uv.clone())]));
        self.draw_layer(cb);
    }

    /// Calque couleur pleine (fond).
    pub unsafe fn draw_solid(&self, cb: &LayerCB) {
        self.draw_layer(cb);
    }

    /// Fond wallpaper image (cover-fit). `path` = chemin absolu (résolu côté app). Décodé et
    /// uploadé une fois (cache), puis échantillonné en mode 6. Err → l'appelant retombe sur une
    /// couleur plate. Le rect uv `src` recouvre toute la sortie en rognant le débordement.
    /// Ouvre une frame du point de vue de `img_cache` : tout ce qui sera touché après cet appel
    /// est le jeu actif, et devient inévinçable jusqu'à la frame suivante.
    fn begin_image_frame(&self) {
        // `+ 1` : la première entrée de cette frame recevra `img_tick + 1`, et la protection
        // porte sur `tick >= img_frame_start`. Sans le décalage on protégerait aussi la
        // DERNIÈRE entrée de la frame précédente, 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, décodée une seule fois puis réutilisée.
    ///
    /// Le cache était NON BORNÉ, et c'est un vrai coût : les wallpapers livrés pèsent 23,7 Mo sur
    /// disque mais 1 774 Mo une fois décodés en RGBA8 — `wallpaper8.jpg` fait 7680x7680, soit
    /// 225 Mo à lui seul. Parcourir le sélecteur les chargeait tous et n'en libérait aucun.
    ///
    /// L'éviction est LRU sous un budget en octets, et ne touche jamais une texture que la frame
    /// EN COURS a déjà servie : sans ça, un fond d'écran et un fond de caméra un peu gros se
    /// chasseraient l'un l'autre à chaque frame, et un décodage coûte 129 ms contre les ~3,5 ms
    /// d'une frame. Si le jeu actif dépasse à lui seul le budget, on dépasse le budget.
    unsafe fn cached_image(&self, path: &str) -> Result<(ID3D11ShaderResourceView, u32, u32)> {
        let tick = self.img_tick.get() + 1;
        self.img_tick.set(tick);
        // La recherche est isolée dans un `let` pour que l'emprunt immuable soit relâché AVANT le
        // `borrow_mut()` (sinon double-emprunt RefCell → panic sur la 1re frame image).
        let hit = self.img_cache.borrow().get(path).cloned();
        if let Some((srv, w, h, _)) = hit {
            self.img_cache.borrow_mut().insert(path.to_string(), (srv.clone(), w, h, tick));
            return Ok((srv, w, h));
        }
        let (srv, w, h) = self.load_image_srv(path)?;
        let mut cache = self.img_cache.borrow_mut();
        cache.insert(path.to_string(), (srv.clone(), w, h, tick));
        // La politique vit dans `frame_geometry` : les trois backends la partagent, comme la
        // géométrie, plutôt 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((srv, w, h))
    }

    unsafe fn draw_image_bg(
        &self,
        path: &str,
        output_aspect: f32,
        motion: WallpaperMotion,
        programme_t: f32,
    ) -> Result<()> {
        let full = [0.0, 0.0, 1.0, 1.0];
        self.draw_image_in(path, full, [0.0, 0.0], 0.0, output_aspect, motion, programme_t)
    }

    /// `draw_image_bg` pour un rect quelconque — la bulle webcam s'en sert avec ses coins
    /// arrondis. `output_aspect` est le ratio du RECT visé, pas celui de la sortie : le crop
    /// « cover » se calcule contre la zone qu'on remplit. `motion` anime l'image au temps
    /// programme `programme_t` ; la bulle passe `WallpaperMotion::None`.
    #[allow(clippy::too_many_arguments)]
    unsafe fn draw_image_in(
        &self,
        path: &str,
        dst: [f32; 4],
        quad_px: [f32; 2],
        radius_px: f32,
        output_aspect: f32,
        motion: WallpaperMotion,
        programme_t: f32,
    ) -> Result<()> {
        let (srv, iw, ih) = self.cached_image(path)?;
        let ai = iw as f32 / ih as f32;
        // Crop « cover » contre le ratio de la zone remplie (`output_aspect`) : l'image garde ses
        // proportions, rognée sur l'axe en trop. Le RT porte la géométrie de sortie, donc rien ne
        // la ré-étire ensuite.
        let ao = output_aspect;
        let (u0, v0, u1, v1) = if ai > ao {
            let vis = ao / ai; // rogne horizontalement
            ((1.0 - vis) * 0.5, 0.0, 1.0 - (1.0 - vis) * 0.5, 1.0)
        } else {
            let vis = ai / ao; // rogne verticalement
            (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, ao);
        self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
        self.draw_layer(&LayerCB {
            dst,
            src: [u0, v0, u1, v1],
            quad_px,
            radius_px,
            mode: 6.0,
            fx: [0.0, 0.0, anim[0], anim[1]],
            mb,
            ..Default::default()
        });
        Ok(())
    }

    /// Peint le fond du mode « personnalisé » DANS la bulle webcam, avant que la caméra n'y soit
    /// découpée par-dessus.
    ///
    /// Le shader ne sait peindre qu'une couleur plate sous le masque, donc un dégradé ou une image
    /// y tombaient sur du noir — et le défaut EST une image (`DEFAULT_WALLPAPER`), si bien que le
    /// mode ne rendait jamais ce que le sélecteur montrait. Peindre le fond puis composer la
    /// caméra en détourage donne exactement le même résultat (`lerp(fond, caméra, personne)`, ici
    /// par le mélange alpha) pour les trois sortes de fond, en réutilisant les chemins déjà
    /// éprouvés du fond d'écran, et sans rien ajouter aux trois shaders.
    ///
    /// `quad_px` / `radius_px` sont ceux de la bulle : le fond doit épouser ses coins arrondis,
    /// sinon un rectangle déborde derrière la caméra.
    unsafe fn draw_webcam_bg(
        &self,
        bg: Option<&SceneBackground>,
        dst: [f32; 4],
        quad_px: [f32; 2],
        radius_px: f32,
    ) {
        const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
        let solid = |color: [f32; 4]| LayerCB {
            dst,
            quad_px,
            radius_px,
            mode: 1.0,
            color,
            ..Default::default()
        };
        match bg {
            Some(SceneBackground::Color { color }) => {
                self.draw_solid(&solid(parse_hex(color).unwrap_or(BLACK)));
            }
            // Le mouvement ne vaut que pour le fond d'écran : la bulle garde son dégradé immobile.
            Some(SceneBackground::Gradient { angle_deg, stops, offsets, .. }) => {
                // angle CSS → direction unitaire, même convention que le fond d'écran.
                let a = angle_deg.to_radians();
                let dir = [a.sin(), -a.cos()];
                self.draw_solid(&LayerCB {
                    dst,
                    quad_px,
                    radius_px,
                    fx: [dir[0], dir[1], 0.0, 0.0],
                    ..crate::frame_geometry::gradient_layer(stops, offsets, BLACK)
                });
            }
            Some(SceneBackground::Image { path, .. }) => {
                // Même contrat que le fond d'écran : un chemin cassé est loggé puis remplacé par
                // du noir. Un fallback silencieux redonnerait le bug qu'on corrige.
                let aspect = if quad_px[1] > 0.0 { quad_px[0] / quad_px[1] } else { 1.0 };
                let still = WallpaperMotion::None;
                if let Err(e) =
                    self.draw_image_in(path, dst, quad_px, radius_px, aspect, still, 0.0)
                {
                    eprintln!("[compositor] fond webcam \"{}\" : {:#}", path, e);
                    self.draw_solid(&solid(BLACK));
                }
            }
            // Personnalisé sans fond : noir, comme avant — mais c'est désormais le seul chemin
            // qui y mène, au lieu de l'être pour toute image et tout dégradé.
            None => self.draw_solid(&solid(BLACK)),
        }
    }

    /// Décode un fichier image (jpg/png) → texture RGBA immuable + SRV.
    unsafe fn load_image_srv(&self, path: &str) -> Result<(ID3D11ShaderResourceView, u32, u32)> {
        // Les annotations image stockent une data URL (cf. `types.ts` : « Separate storage for
        // image data URL »), pas un chemin : on décode alors depuis la mémoire. Les wallpapers
        // continuent de passer par le disque.
        let img = if let Some(bytes) = decode_data_uri(path) {
            image::load_from_memory(&bytes)
                .map_err(|e| anyhow::anyhow!("data URI image ({} octets): {}", bytes.len(), e))?
                .to_rgba8()
        } else {
            image::open(path)
                .map_err(|e| anyhow::anyhow!("wallpaper {}: {}", path, e))?
                .to_rgba8()
        };
        let (w, h) = (img.width(), img.height());
        let pixels = img.into_raw();
        let td = D3D11_TEXTURE2D_DESC {
            Width: w,
            Height: h,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_R8G8B8A8_UNORM,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_IMMUTABLE,
            BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        let init = D3D11_SUBRESOURCE_DATA {
            pSysMem: pixels.as_ptr() as *const c_void,
            SysMemPitch: w * 4,
            SysMemSlicePitch: 0,
        };
        let mut tex: Option<ID3D11Texture2D> = None;
        self.dev.CreateTexture2D(&td, Some(&init), Some(&mut tex))?;
        let tex = tex.unwrap();
        let mut srv: Option<ID3D11ShaderResourceView> = None;
        self.dev.CreateShaderResourceView(&tex, None, Some(&mut srv))?;
        Ok((srv.unwrap(), w, h))
    }

    /// Champ de distance du sprite `path` (t4 du mode 15) et sa forme, calculés au premier appel.
    unsafe fn cursor_sdf(&self, path: &str) -> Result<(ID3D11ShaderResourceView, 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 td = D3D11_TEXTURE2D_DESC {
            Width: sdf.width,
            Height: sdf.height,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_R16_FLOAT,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_IMMUTABLE,
            BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        let init = D3D11_SUBRESOURCE_DATA {
            pSysMem: texels.as_ptr() as *const c_void,
            SysMemPitch: sdf.width * 2,
            SysMemSlicePitch: 0,
        };
        let mut tex: Option<ID3D11Texture2D> = None;
        self.dev.CreateTexture2D(&td, Some(&init), Some(&mut tex))?;
        let mut srv: Option<ID3D11ShaderResourceView> = None;
        self.dev.CreateShaderResourceView(&tex.unwrap(), None, Some(&mut srv))?;
        let entry = (srv.unwrap(), sdf.shape);
        self.sdf_cache.borrow_mut().insert(path.to_string(), entry.clone());
        Ok(entry)
    }

    /// Extrait la frame webcam en RGB8 à la résolution du modèle, dans `out`.
    ///
    /// `src` est le rect source de la webcam en UV (le même que celui passé à `draw_video`),
    /// donc le crop utilisateur et le miroir sont déjà dedans — le modèle voit exactement ce
    /// que le spectateur verra, et le masque n'a pas à être recadré après coup.
    ///
    /// **À appeler AVANT `begin()`** : la méthode réquisitionne la cible de rendu et le
    /// viewport, et ne les restaure pas. Les appeler dans l'autre ordre dessinerait la scène
    /// dans une texture de 256x144.
    ///
    /// C'est le seul readback GPU->CPU du chemin. Il porte 256x144x4 = 147 Ko, contre la
    /// frame entière que la preview lit déjà à chaque image ; sur le chemin export, qui lui
    /// est GPU-résident de bout en bout, c'est en revanche un point de synchronisation neuf
    /// et c'est là qu'il faudra le mesurer.
    pub unsafe fn capture_webcam_rgb(
        &self,
        wy: &ID3D11ShaderResourceView,
        wuv: &ID3D11ShaderResourceView,
        src: [f32; 4],
        width: u32,
        height: u32,
        out: &mut Vec<u8>,
    ) -> Result<()> {
        if width == 0 || height == 0 {
            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 td = D3D11_TEXTURE2D_DESC {
                    Width: width,
                    Height: height,
                    MipLevels: 1,
                    ArraySize: 1,
                    Format: DXGI_FORMAT_R8G8B8A8_UNORM,
                    SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
                    Usage: D3D11_USAGE_DEFAULT,
                    BindFlags: D3D11_BIND_RENDER_TARGET.0 as u32,
                    CPUAccessFlags: 0,
                    MiscFlags: 0,
                };
                let mut rt: Option<ID3D11Texture2D> = None;
                self.dev.CreateTexture2D(&td, None, Some(&mut rt))?;
                let rt = rt.unwrap();
                let mut rtv: Option<ID3D11RenderTargetView> = None;
                self.dev.CreateRenderTargetView(&rt, None, Some(&mut rtv))?;

                let sd = D3D11_TEXTURE2D_DESC {
                    Usage: D3D11_USAGE_STAGING,
                    BindFlags: 0,
                    CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32,
                    ..td
                };
                let mut staging: Option<ID3D11Texture2D> = None;
                self.dev.CreateTexture2D(&sd, None, Some(&mut staging))?;

                *slot = Some(SegCapture {
                    rtv: rtv.unwrap(),
                    rt,
                    staging: staging.unwrap(),
                    width,
                    height,
                });
            }
        }

        let cap = self.seg_capture.borrow();
        let cap = cap.as_ref().expect("créé juste au-dessus");

        self.bind_compose_state();
        self.ctx.OMSetBlendState(&self.blend_none, None, 0xffffffff);
        self.ctx.OMSetRenderTargets(Some(&[Some(cap.rtv.clone())]), None);
        let vp = D3D11_VIEWPORT {
            TopLeftX: 0.0, TopLeftY: 0.0,
            Width: width as f32, Height: height as f32, MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp]));
        // Plein cadre de la cible, sans coins ni motion blur : le modèle veut l'image, pas
        // la mise en forme.
        self.draw_video(
            &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()
            },
            wy,
            wuv,
        );

        self.ctx.CopyResource(&cap.staging, &cap.rt);
        let mut mapped = D3D11_MAPPED_SUBRESOURCE::default();
        self.ctx.Map(&cap.staging, 0, D3D11_MAP_READ, 0, Some(&mut mapped))?;
        out.clear();
        out.reserve((width * height * 3) as usize);
        for row in 0..height as usize {
            let line = (mapped.pData as *const u8).add(row * mapped.RowPitch as usize);
            for col in 0..width as usize {
                let px = line.add(col * 4);
                // RGBA -> RGB : le modèle n'a pas de canal alpha en entrée.
                out.push(*px);
                out.push(*px.add(1));
                out.push(*px.add(2));
            }
        }
        self.ctx.Unmap(&cap.staging, 0);
        Ok(())
    }

    /// Publie le masque de segmentation du sujet webcam (R8, `width`x`height`, 0 = fond).
    ///
    /// Appelé depuis le thread d'inférence, pas depuis le thread de rendu — d'où le
    /// `SetMultithreadProtected(true)` posé à la création du device (`d3d_windows.rs`). La
    /// texture est `DYNAMIC` et réécrite en place ; elle n'est recréée que si la résolution du
    /// modèle change, ce qui n'arrive pas en régime établi.
    pub fn set_webcam_mask(&self, data: &[u8], width: u32, height: u32) -> Result<()> {
        if width == 0 || height == 0 {
            bail!("masque webcam de dimensions nulles ({width}x{height})");
        }
        let expected = (width as usize) * (height as usize);
        if data.len() < expected {
            bail!("masque webcam trop court : {} octets pour {width}x{height}", data.len());
        }

        let mut slot = self.webcam_mask.borrow_mut();
        let needs_alloc = !matches!(slot.as_ref(), Some(m) if m.width == width && m.height == height);
        if needs_alloc {
            let td = D3D11_TEXTURE2D_DESC {
                Width: width,
                Height: height,
                MipLevels: 1,
                ArraySize: 1,
                Format: DXGI_FORMAT_R8_UNORM,
                SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
                Usage: D3D11_USAGE_DYNAMIC,
                BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
                CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,
                MiscFlags: 0,
            };
            let mut tex: Option<ID3D11Texture2D> = None;
            unsafe { self.dev.CreateTexture2D(&td, None, Some(&mut tex))? };
            let tex = tex.unwrap();
            let mut srv: Option<ID3D11ShaderResourceView> = None;
            unsafe { self.dev.CreateShaderResourceView(&tex, None, Some(&mut srv))? };
            *slot = Some(WebcamMask { tex, srv: srv.unwrap(), width, height });
        }

        let mask = slot.as_ref().expect("alloué juste au-dessus");
        unsafe {
            let mut mapped = D3D11_MAPPED_SUBRESOURCE::default();
            self.ctx.Map(&mask.tex, 0, D3D11_MAP_WRITE_DISCARD, 0, Some(&mut mapped))?;
            // `RowPitch` n'est pas `width` : le driver aligne les lignes, donc on recopie
            // ligne à ligne plutôt que d'un bloc.
            for row in 0..height as usize {
                let dst = (mapped.pData as *mut u8).add(row * mapped.RowPitch as usize);
                let src = data.as_ptr().add(row * width as usize);
                std::ptr::copy_nonoverlapping(src, dst, width as usize);
            }
            self.ctx.Unmap(&mask.tex, 0);
        }
        Ok(())
    }

    /// Un tour de segmentation : téléverse le masque prêt, puis soumet une nouvelle frame si
    /// la cadence l'autorise.
    ///
    /// Les deux moitiés sont volontairement désynchronisées. Le masque téléversé ici vient de
    /// la frame précédente — une frame de retard sur une silhouette est invisible, alors
    /// qu'attendre l'inférence bloquerait le rendu, ce qui est exactement le coût que toute
    /// cette conception cherche à ne pas payer.
    unsafe fn pump_segmentation(
        &self,
        wy: &ID3D11ShaderResourceView,
        wuv: &ID3D11ShaderResourceView,
        valid: [f32; 2],
    ) -> Result<()> {
        if *self.seg_failed.borrow() {
            return Ok(());
        }
        // Rien à faire si aucun effet n'est demandé : ni capture, ni inférence, ni masque.
        // Le coût de la fonctionnalité 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(());
        }

        // Démarrage paresseux, piloté par la scène : personne n'a à appeler
        // `enable_segmentation` à la main, et un modèle introuvable éteint 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] désactivée : {e}");
                // Une scène qui reste identique retenterait à chaque frame ; on pose un
                // worker vide plutôt 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 démarrer et
            // l'effet apparaîtra dans quelques millisecondes, ce que personne ne voit. À
            // l'export cette frame part dans le fichier — on enchaîne donc sur la capture et
            // l'inférence plutôt que de la laisser sortir non détourée.
            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 réglage en preview et le mauvais à l'export, où les
        // frames défilent aussi vite que la machine décode : le nombre de frames couvertes par
        // un masque dépendrait alors de la charge. En déterministe, une inférence 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 ENTIÈRE, pas le sous-rect dessiné : un crop utilisateur serré amputerait
        // le sujet en entrée du modèle, et le masque serait faux là où il compte le plus.
        // Le shader ramène ses coordonnées dans cet espace via `fx.xy`.
        self.capture_webcam_rgb(
            wy,
            wuv,
            [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 composée, sinon
            // on retombe sur le défaut qu'on corrige. Une inférence ratée laisse le masque
            // précédent, 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) => {
                        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 ignorée : {e}"),
                }
            }
        } else if let Some(w) = self.seg_worker.borrow().as_ref() {
            w.submit(&scratch);
        }
        Ok(())
    }

    /// Démarre la segmentation du sujet webcam pour ce compositeur.
    ///
    /// Idempotent. Tant qu'elle n'est pas appelée, `compose_frame` ne fait rien de plus et
    /// la webcam se dessine comme avant — c'est ce qui rend l'effet inerte plutôt que cassé
    /// sur une build sans modèle.
    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 déterministe, le segmenteur reste ici : l'inférence tourne sur le thread de rendu,
        // donc le masque de la frame N est prêt AVANT qu'elle ne soit composée. 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, _, _| {
            // Écrase le masque précédent s'il n'a pas encore été téléversé : c'est le plus
            // récent 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 réels) et l'inférence tourne sur un worker :
    /// c'est le bon choix, l'affichage ne doit jamais attendre. À l'export les frames sont rendues
    /// aussi vite que la machine décode, sans rapport avec le temps réel — et ces deux choix
    /// deviennent alors des bugs. La cadence horloge fait dépendre le nombre de frames couvertes
    /// par un masque de la vitesse de la machine, et le worker asynchrone rend les premières
    /// frames AVANT que le premier masque n'existe : elles partent dans le fichier avec le vrai
    /// arrière-plan de la webcam. Deux exports du même projet ne donnent donc pas les mêmes
    /// pixels, ce qui casse l'invariant « l'export est identique à la preview ».
    ///
    /// En déterministe : une inférence PAR FRAME, synchrone. Plus coûteux (~3 ms/frame), mais
    /// l'export est hors ligne et chaque frame porte le masque calculé depuis SA propre image.
    ///
    /// À appeler avant la première frame — c'est ce qui décide 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
        // PRÉSENCE d'un moteur : sans démonter celui qui ne correspond plus, le drapeau mentirait.
        // Un compositeur qui a déjà servi en preview garderait son worker, `seg_sync` resterait
        // vide, et l'export entier ne ferait AUCUNE inférence. Le démarrage paresseux de
        // `pump_segmentation` réinstalle le bon moteur à la frame suivante.
        *self.seg_worker.borrow_mut() = None;
        *self.seg_sync.borrow_mut() = None;
        // Et le masque que le worker démonté avait peut-être déjà déposé : il vient de l'autre
        // mode, il n'a rien à faire sur la première frame de celui-ci.
        *self.seg_inbox.lock().unwrap() = None;
    }

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

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

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

    /// Voir `cursor_t_override`. `None` restaure le comportement fixture (`frame / FPS`).
    pub fn set_cursor_time(&self, t: Option<f32>) {
        *self.cursor_t_override.borrow_mut() = t;
    }

    /// Voir `timeline_t_override`. `None` restaure le comportement fixture (`frame / FPS`).
    pub fn set_timeline_time(&self, t: Option<f32>) {
        *self.timeline_t_override.borrow_mut() = t;
    }

    /// Voir `programme_time`. `None` restaure le comportement fixture (`frame / FPS`).
    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()
    }

    /// Copie de la scène courante (si présente) — utilisé par l'export multiclip pour lire les
    /// réglages curseur (thème/lissage/show) sans dupliquer le contrat de scène côté pipeline.
    pub fn scene_snapshot(&self) -> Option<Scene> {
        self.scene.borrow().clone()
    }

    /// Curseur custom (dot+ring) centré en `center` (0..1 sortie), taille `size_px`, opacité `a`.
    /// `clip` = rect "Clip to canvas" en espace sortie [x,y,w,h] ; passer un rect englobant tout
    /// (ex. [-1,-1,3,3]) pour désactiver l'effet.
    unsafe fn draw_cursor(&self, center: [f32; 2], size_px: f32, a: f32, clip: [f32; 4]) -> [f32; 4] {
        let w = size_px / self.rw();
        let h = size_px / self.rh();
        let dst = [center[0] - w * 0.5, center[1] - h * 0.5, w, h];
        self.draw_solid(&LayerCB {
            dst,
            quad_px: [size_px, size_px],
            mode: 4.0,
            color: [1.0, 1.0, 1.0, a],
            fx: clip,
            ..Default::default()
        });
        dst
    }

    /// Curseur thème (sprite PNG, ex. arrow.png) dont le PIVOT `hotspot` (fraction 0..1 de
    /// l'image) tombe sur `center`, à la taille de référence `size_px`. `Err` → l'appelant
    /// retombe sur `draw_cursor` (math dot+ring). La géométrie vient de
    /// `frame_geometry::cursor_sprite_cb`, partagée avec macOS et Linux.
    ///
    /// Avec `model`, le même sprite extrudé (mode 15, `cursor_model_cb`) : le sprite en t2, son
    /// champ de distance en t4.
    unsafe fn draw_cursor_sprite(
        &self,
        placement: CursorPlacement,
        size_px: f32,
        a: f32,
        sprite: &SceneCursorSprite,
        clip: [f32; 4],
        model: Option<crate::frame_geometry::CursorPose>,
    ) -> Result<Option<[f32; 4]>> {
        let path = sprite.path.as_str();
        let (srv, iw, ih) = self.cached_image(path)?;
        // Sans champ de distance, repli sur le sprite plat plutôt que sur le curseur math.
        // Parité Linux.
        if let Some(pose) = model {
            match self.cursor_sdf(path) {
                Ok((sdf, shape)) => {
                    let shape = crate::frame_geometry::model_shape(sprite, shape);
                    let Some(cb) = crate::frame_geometry::cursor_model_cb(
                        placement, size_px, pose, shape, a, clip,
                    ) else {
                        return Ok(None);
                    };
                    self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
                    self.ctx.PSSetShaderResources(4, Some(&[Some(sdf)]));
                    self.draw_layer(&cb);
                    self.ctx.PSSetShaderResources(4, Some(&[None]));
                    return Ok(Some(cb.dst));
                }
                Err(e) => eprintln!("[curseur] champ de \"{path}\" : {e:#}"),
            }
        }
        let ar = iw as f32 / ih as f32;
        let (pw, ph) = if ar >= 1.0 { (size_px, size_px / ar) } else { (size_px * ar, size_px) };
        let cb = crate::frame_geometry::cursor_sprite_cb(
            placement,
            [pw, ph],
            [sprite.hotspot_x, sprite.hotspot_y],
            a,
            clip,
            [self.rw(), self.rh()],
        );
        self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
        self.draw_layer(&cb);
        Ok(Some(cb.dst))
    }

    /// Sprite de l'état courant (`cursor_type`, ex. `"text"`), à défaut celui de la flèche,
    /// à défaut le curseur math (dot+ring). Avec `model`, ce sprite extrudé (mode 15) : même
    /// résolution que `plan_cursor`, qui en a tiré la pose.
    ///
    /// Le repli sur la flèche compte : un thème n'apporte que sa flèche et son pointeur, les
    /// autres états venant de l'art intégrée — mais si un état inconnu apparaît, mieux vaut
    /// une flèche qu'un point dans un cercle.
    #[allow(clippy::too_many_arguments)]
    unsafe fn draw_cur_themed(
        &self,
        sprites: &HashMap<String, SceneCursorSprite>,
        cursor_type: Option<&str>,
        placement: CursorPlacement,
        size_px: f32,
        a: f32,
        clip: [f32; 4],
        model: Option<crate::frame_geometry::CursorPose>,
    ) -> Option<[f32; 4]> {
        let sprite = cursor_type.and_then(|t| sprites.get(t)).or_else(|| sprites.get("arrow"));
        if let Some(sprite) = sprite {
            if let Ok(dst) = self.draw_cursor_sprite(placement, size_px, a, sprite, clip, model) {
                return dst;
            }
        }
        // Le repli math reste droit même sur un plan incliné : il ne devrait plus apparaître
        // maintenant que l'art par défaut existe, et lui donner sa propre passe de warp pour
        // un cas de secours ne se justifie pas.
        Some(self.draw_cursor(placement.upright_center(), size_px, a, clip))
    }

    /// Ombre portée (§7 E4) sous un quad `dst` (normalisé) de taille `size_px`.
    /// Le quad d'ombre est élargi de `spread` px et décalé de `offset_px`, des px de SORTIE
    /// (même convention que `radius_px` pour l'arrondi normal, cf. `compose_frame`), convertis
    /// ici en fractions du render target, axe par axe. Le RT porte la géométrie de sortie : le
    /// halo reste isotrope sans correction. `mb.yz` reste à 1 et le shader ne le lit plus : du
    /// temps du canvas figé en 16:9, il portait l'étirement de sortie que la SDF devait annuler.
    pub unsafe fn draw_shadow(
        &self,
        dst: [f32; 4],
        size_px: [f32; 2],
        radius: f32,
        spread: f32,
        offset_px: [f32; 2],
        opacity: f32,
    ) {
        let sx = spread / self.rw();
        let sy = spread / self.rh();
        let ox = offset_px[0] / self.rw();
        let oy = offset_px[1] / self.rh();
        let cb = 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()
        };
        self.draw_solid(&cb);
    }

    /// Ombre d'un écran incliné en 3D : la pénombre suit le QUADRILATÈRE projeté (mode 12), pas
    /// son rect englobant. `corners` sont les 4 coins (TL, TR, BR, BL) en px relatifs au centre,
    /// tels que `rotated_quad_corners_px` les rend ; `center_px` est ce centre à l'écran.
    ///
    /// `radius` est le rayon des coins du PLAN, réutilisé tel quel : la projection l'étire de
    /// ±10 % selon l'endroit du bord, écart invisible sur une ombre floue, alors qu'une ombre à
    /// coins vifs derrière un écran arrondi dépasse en pointe et se voit tout de suite.
    #[allow(clippy::too_many_arguments)]
    pub unsafe fn draw_quad_shadow(
        &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,
    ) {
        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 boîte de rendu doit contenir la pénombre entière, sinon elle se coupe net — le
        // quadrilatère seul ne suffit pas.
        let box_w = (max_x - min_x) + 2.0 * spread;
        let box_h = (max_y - min_y) + 2.0 * spread;
        let origin_x = center_px[0] + min_x - spread + offset_px[0];
        let origin_y = center_px[1] + min_y - spread + offset_px[1];
        // Coins en px locaux à cette boîte, même convention que le mode 8.
        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],
            [self.rw(), self.rh()],
        );
        self.draw_solid(&LayerCB {
            dst: [
                origin_x / self.rw(),
                origin_y / self.rh(),
                box_w / self.rw(),
                box_h / self.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,
            mb: [0.0, spread, 1.0, mask_radius],
            ..Default::default()
        });
    }

    /// 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()
    }

    /// Compose une frame animée (§6/§8) : fond flouté + screen zoomé (padding, coins, ombre)
    /// + webcam crop carré (coins, ombre), placements interpolés A↔B par la timeline.
    pub unsafe fn compose_frame(
        &self,
        screen: *const AVFrame,
        webcam: *const AVFrame,
        frame: f32,
        cfg: &Cfg,
    ) -> Result<()> {
        self.begin_image_frame();
        let (sy, suv) = self.nv12_srvs(screen)?;
        let (wy, wuv) = self.nv12_srvs(webcam)?;
        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) = ((*webcam).width as f32, (*webcam).height as f32);
        // Étendue valide de la texture webcam : les décodeurs allouent des textures alignées,
        // donc la frame n'occupe pas forcément toute la texture.
        let w_valid = [wcw / wtw as f32, wch / wth as f32];

        // Segmentation, AVANT `begin()` : la capture réquisitionne la cible de rendu.
        self.pump_segmentation(&wy, &wuv, w_valid)?;
        let u_max = scw / stw as f32;
        let v_max = sch / sth as f32;

        let scene_ref = self.scene.borrow();
        let cursor_ref = self.cursor.borrow();
        let lp = *self.live_params.borrow();
        let g = crate::frame_geometry::plan_frame(&crate::frame_geometry::FrameGeometryInput {
            render_px: [self.rw(), self.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_t_override.borrow(),
            programme_time: *self.programme_time.borrow(),
        });
        self.footage.set(Some(g.footage_quad([self.rw(), self.rh()])));
        let scene_preset = g.scene_preset.clone();
        let mb_taps = g.mb_taps;
        let mb_amount = g.mb_amount;
        let source_t = g.source_t;
        let _padding_scale = g.padding_scale;
        let cut = g.cut;
        let s_dst = g.s_dst;
        let s_dst_prev = g.s_dst_prev;
        let s_ann = g.s_ann;
        let s_radius = g.s_radius;
        let frame_min_px = g.frame_min_px;
        let w_dst = g.w_dst;
        let w_dst_prev = g.w_dst_prev;
        let w_px = g.w_px;
        let w_radius = g.w_radius;
        let shape_fade = g.shape_fade;

        // Profondeur de champ : la pyramide n'est remplie que sur une frame inclinée qui la lit,
        // AVANT `begin`, qui rebranche ensuite le RT principal et le vide.
        let dof = g.depth_of_field_on(self.cpu_backend);
        let dof_srv = if dof { Some(self.fill_dof_pyramid(&sy, &suv, stw, sth)?) } else { None };

        // --- fond ---
        // Parité web (frameRenderer.blurredBackgroundLayer) : le fond est le WALLPAPER sélectionné
        // (image/couleur/gradient) et « Blur BG » floute CE wallpaper, PAS la vidéo. Le natif
        // dupliquait la vidéo floutée → le « vieux flou ». Côté APP (scène présente) on dessine
        // donc le wallpaper (couleur pour l'instant ; gradient/image rendus depuis la scène
        // ensuite ; pour une couleur plate le flou est un no-op visuel). Côté fixture/bench
        // (pas de scène) on garde le fond screen-flouté, dont le coût est mesuré (C4).
        let scene_bg = self.scene.borrow().as_ref().map(|s| (s.background.clone(), s.effects.blur));
        // Le fond de la frame d'avant, s'il est celui qu'on demande (`BackgroundKey`), est recopié
        // au lieu d'être redessiné. Côté scène seulement : sans scène, le fond est la vidéo floutée.
        let bg_size = [self.rw(), self.rh()];
        let bg_cached = scene_ref.as_ref().is_some_and(|s| {
            self.bg_cache
                .borrow()
                .as_ref()
                .is_some_and(|c| {
                    c.key.matches(Some(&s.background), s.effects.blur, lp.bg_color, bg_size)
                })
        });
        if bg_cached {
            self.bind_compose_state();
            if let Some(c) = self.bg_cache.borrow().as_ref() {
                self.ctx.CopyResource(&self.rt, &c.tex);
            }
        } else {
            self.begin([0.0, 0.0, 0.0, 1.0]);
            // Faux si l'image du fond n'a pas pu se charger : son repli n'est pas gardé.
            let mut bg_drawn = true;
            if let Some((bg, blur_wallpaper)) = scene_bg {
                match bg {
                    SceneBackground::Color { color } => {
                        let c = parse_hex(&color).unwrap_or(lp.bg_color);
                        self.draw_solid(&LayerCB {
                            dst: [0.0, 0.0, 1.0, 1.0],
                            mode: 1.0,
                            color: c,
                            ..Default::default()
                        });
                    }
                    SceneBackground::Gradient { angle_deg, stops, offsets, motion } => {
                        // angle CSS → direction unitaire (espace sortie, y vers le bas) :
                        // 0° = vers le haut, 90° = vers la droite.
                        let a = angle_deg.to_radians();
                        let dir = [a.sin(), -a.cos()];
                        let (anim, mb) = crate::frame_geometry::wallpaper_motion_slots(
                            motion,
                            g.programme_t,
                            self.rw() / self.rh(),
                        );
                        self.draw_solid(&LayerCB {
                            dst: [0.0, 0.0, 1.0, 1.0],
                            fx: [dir[0], dir[1], anim[0], anim[1]],
                            mb,
                            ..crate::frame_geometry::gradient_layer(&stops, &offsets, lp.bg_color)
                        });
                    }
                    SceneBackground::Image { path, motion } => {
                        // image bg (cover-fit, mise en cache) ; fallback couleur si chargement échoue
                        // (loggé — un fallback silencieux masquerait un chemin cassé, cf. le panic
                        // borrow qu'on a déjà eu : toute panne doit être visible/traçable).
                        let aspect = self.rw() / self.rh();
                        if let Err(e) = self.draw_image_bg(&path, aspect, motion, g.programme_t) {
                            eprintln!("[compositor] wallpaper image \"{}\" : {:#}", path, e);
                            bg_drawn = false;
                            self.draw_solid(&LayerCB {
                                dst: [0.0, 0.0, 1.0, 1.0],
                                mode: 1.0,
                                color: lp.bg_color,
                                ..Default::default()
                            });
                        }
                    }
                }
                // « Blur BG » (parité web blurredBackgroundLayer) : floute CE wallpaper qu'on vient
                // de dessiner (dual-Kawase, déjà utilisé pour le fond fixture ci-dessous). No-op
                // visuel sur une couleur plate, effet réel sur gradient/image.
                if blur_wallpaper > 0.0 {
                    self.blur_bg(blur_wallpaper);
                    self.bind_compose_state();
                }
            } else if cfg.bg_blur > 0.0 {
                let over = 0.06;
                self.draw_video(
                    &LayerCB {
                        dst: [-over, -over, 1.0 + 2.0 * over, 1.0 + 2.0 * over],
                        src: [0.0, 0.0, u_max, v_max],
                        quad_px: [self.rw(), self.rh()],
                        mode: 0.0,
                        color: [1.0, 1.0, 1.0, 1.0],
                        ..Default::default()
                    },
                    &sy,
                    &suv,
                );
                self.blur_bg(cfg.bg_blur);
                self.bind_compose_state();
                self.draw_solid(&LayerCB {
                    dst: [0.0, 0.0, 1.0, 1.0],
                    mode: 1.0,
                    color: [0.0, 0.0, 0.0, 0.35],
                    ..Default::default()
                });
            } else {
                self.draw_solid(&LayerCB {
                    dst: [0.0, 0.0, 1.0, 1.0],
                    mode: 1.0,
                    color: lp.bg_color,
                    ..Default::default()
                });
            }
            // Pas de cache pour un fond animé (`of` rend `None`).
            let key = scene_ref.as_ref().filter(|_| bg_drawn).and_then(|s| {
                crate::frame_geometry::BackgroundKey::of(
                    Some(&s.background),
                    s.effects.blur,
                    lp.bg_color,
                    bg_size,
                )
            });
            if let Some(key) = key {
                self.keep_background(key)?;
            }
        }

        // --- screen : crop du clip actif, puis zoom appliqué dans ce rect source (§8) ---
        // `for_clip_window` conserve l'index pour distinguer plusieurs clips du même asset.
        // `active_crop` déjà résolu plus haut (utilisé pour dimensionner `s_dst`) — une seule
        // source de vérité pour ce lookup.
        let s_px = [s_dst[2] * self.rw(), s_dst[3] * self.rh()];
        // Coupes calculées plus haut (elles dimensionnent `s_dst`) : le zoom vit désormais
        // dans la boîte, la coupe ne porte que le crop. `dst_prev` porte la vélocité du
        // motion blur — la coupe, elle, est la même aux deux frames.
        let [su0, sv0, su1, sv1] = cut;
        let (hu, hv) = ((su1 - su0) * 0.5, (sv1 - sv0) * 0.5);
        let [su0_p, sv0_p, su1_p, sv1_p] = cut;
        let (hu_p, hv_p) = ((su1_p - su0_p) * 0.5, (sv1_p - sv0_p) * 0.5);
        // Géométrie du tilt, calculée UNE fois : l'ombre et l'écran doivent porter exactement le
        // même quadrilatère. Deux calculs séparés, c'est une ombre qui se décolle dès qu'un des
        // deux change.
        let tilt = g.screen_tilt(s_px);
        let quad_center_px =
            [(s_dst[0] + s_dst[2] * 0.5) * self.rw(), (s_dst[1] + s_dst[3] * 0.5) * self.rh()];
        // L'ombre suit la silhouette réellement affichée : le rect arrondi quand l'écran est
        // droit, le quadrilatère projeté quand il est incliné. Un rect droit derrière un écran
        // penché ne se lisait pas comme son ombre mais comme une seconde surface. Elle suit
        // aussi la croissance de la boîte pendant un zoom (issue #179) : quand la boîte sort
        // du cadre, l'ombre en sort avec elle, sans jamais se lire comme une bande noire.
        // Avec un cadre de fenêtre, c'est le CADRE qui porte l'ombre (`shadow_caster`), sinon
        // elle tomberait sous l'écran seul et la barre de titre flotterait au-dessus.
        let render_px = [self.rw(), self.rh()];
        // Flou de mouvement de l'écran CADRÉ (`FrameGeometry::screen_trail`) : ombre, cadre,
        // métrage et appareil se dessinent dans un rendu isolé et transparent, que le mode 18
        // recompose ensuite sur le fond le long de la trajectoire de la boîte, ou du plan incliné.
        let trail = g.screen_trail(render_px);
        if trail {
            self.ctx.OMSetRenderTargets(Some(&[Some(self.trail_rtv.clone())]), None);
            self.ctx.ClearRenderTargetView(&self.trail_rtv, &[0.0, 0.0, 0.0, 0.0]);
        }
        if cfg.shadow {
            let spread = 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.
            if let Some(cb) = g.device_shadow_cb(render_px, spread, offset, opacity) {
                self.draw_solid(&cb);
            } else {
                match g.shadow_caster(render_px) {
                    ShadowCaster::Upright { dst, size_px, radius } => {
                        self.draw_shadow(dst, size_px, radius, spread, offset, opacity)
                    }
                    // Même rayon que le plan incliné lui-même (cf. le dessin du mode 8).
                    ShadowCaster::Tilted { corners, center_px, radius, mask } => self
                        .draw_quad_shadow(&corners, center_px, radius, mask, spread, offset, opacity),
                }
            }
        }
        // Le cadre (mode 14) passe SOUS l'écran : l'écran le recouvre, ne laissant voir que la
        // barre de titre, le filet et les coins bas entre les deux arrondis.
        if let Some(cb) = g.window_frame_cb(render_px) {
            self.draw_solid(&cb);
        }
        let square_top = g.screen_square_top();
        // Sous le chrome de fenetre, la remontee de son contour interieur au-dessus de l'ecran :
        // l'arrondi du haut se fait par le cadre (`screen_top_lift_px`). 0 sans fenetre.
        let top_lift = g.screen_top_lift_px(render_px);
        if let Some(quad) = tilt {
            // Écran incliné (angle fixe) ou vu par la caméra réelle : warp inverse du mode 8 dans
            // la bbox du quad projeté (`tilted_screen_cb`, partagé). Les coins arrondis y sont
            // rendus dans le repère DU PLAN : sans eux le plan a des arêtes de couteau qui
            // tranchent le contenu en pleine phrase, et l'œil lit une découpe là où il devrait
            // lire une inclinaison.
            // La pyramide de profondeur de champ en t5, que `draw_video` ne lie pas. `None` quand
            // l'effet est coupé : `k = 0`, le shader n'y lit rien.
            self.ctx.PSSetShaderResources(5, Some(&[dof_srv.clone()]));
            self.draw_video(
                &crate::frame_geometry::tilted_screen_cb(
                    &quad,
                    s_px,
                    quad_center_px,
                    [su0, sv0, su0 + 2.0 * hu, sv0 + 2.0 * hv],
                    g.focus_plane,
                    s_radius,
                    top_lift,
                    dof,
                    render_px,
                    g.screen_mask,
                    g.tilt_pixel_trail(render_px),
                ),
                &sy,
                &suv,
            );
            self.ctx.PSSetShaderResources(5, Some(&[None]));
        } else {
            // Sous le masque d'un layout en bloc, rogné au slot (`FrameGeometry::mask_flat_screen`).
            let (dst, src, quad_px, radius_px) = g.mask_flat_screen(
                s_dst,
                [su0, sv0, su0 + 2.0 * hu, sv0 + 2.0 * hv],
                s_px,
                s_radius,
                render_px,
            );
            self.draw_video(
                &LayerCB {
                    dst,
                    src,
                    quad_px,
                    radius_px,
                    mode: 0.0,
                    color: [0.0, 0.0, 0.0, 1.0],
                    src_prev: [su0_p, sv0_p, su0_p + 2.0 * hu_p, sv0_p + 2.0 * hv_p],
                    dst_prev: s_dst_prev,
                    mb: [g.screen_pixel_taps(render_px), mb_amount, top_lift, square_top],
                    ..Default::default()
                },
                &sy,
                &suv,
            );
        }
        // L'appareil modelé (mode 17) passe APRÈS l'écran, et non sous lui comme le chrome plat :
        // son socle vient DEVANT le plan du métrage et sa lunette mord dessus. Le shader s'arrête
        // au plan du métrage dans l'ouverture, donc il ne recouvre jamais l'image.
        if let Some(cb) = g.device_frame_cb(render_px) {
            self.draw_solid(&cb);
        }
        if trail {
            self.ctx.OMSetRenderTargets(Some(&[Some(self.rtv.clone())]), None);
            // t2 = l'écran cadré isolé ; t5 = la pyramide, avec laquelle le repli relit le
            // métrage hors de la sortie comme le mode 8 l'a dessiné.
            self.ctx.PSSetShaderResources(2, Some(&[Some(self.trail_srv.clone())]));
            self.ctx.PSSetShaderResources(5, Some(&[dof_srv.clone()]));
            self.draw_video(&g.screen_trail_cb(render_px, dof), &sy, &suv);
            self.ctx.PSSetShaderResources(2, Some(&[None]));
            self.ctx.PSSetShaderResources(5, Some(&[None]));
        }

        // --- flous de confidentialité : sur le métrage, AVANT le curseur. Le curseur reste net
        // par-dessus, et le cristal de Prism Glow, qui réfracte l'image composée, n'y voit que des
        // pixels déjà floutés. Les autres annotations restent le calque le plus haut (plus bas).
        self.draw_annotations(scene_ref.as_ref(), source_t, s_ann, &g, true);

        // --- curseur custom : suit le mapping src/dst (zoom+layout), click bounce,
        // et flou de mouvement (parité `compositor_macos.rs` et `compositor_linux.rs`) ---
        if let Some(track) = cursor_ref.as_ref() {
            let plan = crate::frame_geometry::plan_cursor(
                &g,
                &crate::frame_geometry::CursorPlanInput {
                    render_px: [self.rw(), self.rh()],
                    u_max,
                    v_max,
                    cfg,
                    live: lp,
                    scene: scene_ref.as_ref(),
                    track,
                    t: self.cursor_t_override.borrow().unwrap_or(frame / FPS),
                },
            )
            .map(|p| p.for_backend(self.cpu_backend));
            if let Some(plan) = plan {
                let cursor_sprites: HashMap<String, SceneCursorSprite> = scene_ref
                    .as_ref()
                    .map(|s| s.cursor.cursor_sprites.clone())
                    .unwrap_or_default();
                let cursor_type = plan.cursor_type.as_deref();
                // Le cristal de Prism Glow réfracte l'image telle qu'elle est composée à cet
                // instant, flous compris : sa copie en t5, une fois pour toutes les copies de la
                // traînée (`ann_copy` est libre, les flous l'ont déjà lue).
                if plan.glass {
                    self.ctx.CopySubresourceRegion(&self.ann_copy, 0, 0, 0, 0, &self.rt, 0, None);
                    self.ctx.PSSetShaderResources(5, Some(&[Some(self.ann_copy_srv.clone())]));
                }
                // L'impact des clics (mode 16, sans texture), posé sur l'écran SOUS le curseur.
                for cb in &plan.impacts {
                    self.draw_solid(cb);
                }
                if plan.taps <= 1 {
                    self.draw_cur_themed(
                        &cursor_sprites,
                        cursor_type,
                        plan.placement,
                        plan.size_px,
                        plan.alpha,
                        plan.clip,
                        plan.model,
                    );
                } else {
                    // Flou RÉEL, pas des copies discrètes : accumule les N échantillons dans un
                    // buffer ISOLÉ (transparent), pas directement sur la scène déjà composée.
                    self.ctx.ClearRenderTargetView(&self.accum_rtv, &[0.0, 0.0, 0.0, 0.0]);
                    self.ctx.OMSetRenderTargets(Some(&[Some(self.accum_rtv.clone())]), None);
                    // L'union des quads peints dans `accum` (x0, y0, x1, y1 en fractions de la
                    // sortie) : la seule région que la recopie doit relire.
                    let mut bounds = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
                    for k in 0..plan.taps {
                        let f = k as f32 / (plan.taps - 1) as f32;
                        let w = crate::frame_geometry::cursor_tap_weight(k, plan.taps);
                        self.ctx.OMSetBlendState(&self.blend_add, Some(&[w, w, w, w]), 0xffffffff);
                        let drawn = self.draw_cur_themed(
                            &cursor_sprites,
                            cursor_type,
                            plan.prev_placement.lerp(plan.placement, f),
                            plan.size_px,
                            plan.alpha,
                            plan.clip,
                            plan.model,
                        );
                        if let Some(d) = drawn {
                            bounds = [
                                bounds[0].min(d[0]),
                                bounds[1].min(d[1]),
                                bounds[2].max(d[0] + d[2]),
                                bounds[3].max(d[1] + d[3]),
                            ];
                        }
                    }
                    // composite le buffer accumulé sur la scène (blend "over" normal, prémultiplié).
                    self.ctx.OMSetRenderTargets(Some(&[Some(self.rtv.clone())]), None);
                    self.ctx.PSSetShaderResources(0, Some(&[Some(self.accum_srv.clone())]));
                    self.ctx.VSSetShader(&self.vs_fs, None);
                    self.ctx.PSSetShader(&self.ps_tex, None);
                    self.ctx.PSSetSamplers(0, Some(&[Some(self.sampler.clone())]));
                    let vp = D3D11_VIEWPORT {
                        TopLeftX: 0.0,
                        TopLeftY: 0.0,
                        Width: self.rw(),
                        Height: self.rh(),
                        MinDepth: 0.0,
                        MaxDepth: 1.0,
                    };
                    self.ctx.RSSetViewports(Some(&[vp]));
                    self.ctx.OMSetBlendState(&self.blend, None, 0xffffffff);
                    // Rien n'a été peint dans `accum` hors des quads de la traînée : la recopie
                    // s'y borne au lieu de repasser sur toute la sortie (0,5 ms par frame 1080p
                    // mesurée sur Linux, Radeon 610M).
                    let (rw, rh) = (self.rw(), self.rh());
                    let rect = RECT {
                        left: (bounds[0] * rw).floor().clamp(0.0, rw) as i32,
                        top: (bounds[1] * rh).floor().clamp(0.0, rh) as i32,
                        right: (bounds[2] * rw).ceil().clamp(0.0, rw) as i32,
                        bottom: (bounds[3] * rh).ceil().clamp(0.0, rh) as i32,
                    };
                    if rect.right > rect.left && rect.bottom > rect.top {
                        self.ctx.RSSetState(&self.rs_scissor);
                        self.ctx.RSSetScissorRects(Some(&[rect]));
                        self.ctx.Draw(3, 0);
                        self.ctx.RSSetState(None);
                    }
                    self.ctx.PSSetShaderResources(0, Some(&[None]));
                    // restaure l'état de composition standard (VS/PS/topologie quad-strip) pour
                    // le dessin de la webcam qui suit juste après.
                    self.bind_compose_state();
                }
                if plan.glass {
                    self.ctx.PSSetShaderResources(5, Some(&[None]));
                }
            }
        }

        // --- webcam : sous-rect SOURCE couvrant la boîte de destination ---
        // La coupe est dérivée du ratio RÉEL de la boîte (`cover_crop_uv`), donc la caméra
        // n'est jamais étirée quel que soit le rect qu'on lui donne.
        //
        // Avant, la source était prise PLEIN CADRE pour rectangle/rounded, en supposant que
        // « le dst matche le ratio de la source ». C'est vrai du placement par DÉFAUT
        // (`fit_cam_aspect` façonne alors le dst), mais faux dès que l'app fournit le rect :
        // le preset side-by-side donne à la caméra un slot de colonne au ratio arbitraire
        // (cf. `computeCompositeLayout`, branche dual-frame — `webcamRect = webcamSlot`, sans
        // aucun ajustement d'aspect), et la caméra y était étirée. L'hypothèse était donc
        // portée par l'appelant ; la dériver ici la rend vraie par construction.
        //
        // Le center-crop carré de square/circle en est un cas particulier (boîte 1:1) — il n'a
        // plus besoin d'être traité à part.
        let [su0, sv0, su1, sv1] = crate::frame_geometry::webcam_source_rect(
            [wcw, wch],
            [wtw as f32, wth as f32],
            scene_ref
                .as_ref()
                .and_then(|scene| scene.layout.webcam_crop),
            w_px[0] / w_px[1].max(0.0001),
        );
        // miroir = échanger les bornes u du rect source (flip horizontal).
        let (u0, u1) = if lp.webcam_mirror { (su1, su0) } else { (su0, su1) };
        if lp.has_webcam {
            // L'ombre portée appartient à la bulle flottante PiP : elle se retire avec elle
            // (`shape_fade`), pour qu'au plein écran plus rien n'encadre la caméra. C'est une
            // ombre légère NON paramétrable — indépendante du slider Shadow, qui ne pilote plus
            // que l'écran (`WEBCAM_SHADOW_OPACITY`, pas `shadow_scale`) — et propre au PiP : les
            // blocs side-by-side / top-bottom soudent la caméra à l'écran et n'en portent aucune
            // (parité `preset.shadow` web, `null` hors PiP dans `compositeLayout.ts`).
            let webcam_is_block = matches!(
                scene_preset.as_deref(),
                Some("dual-frame") | Some("vertical-stack"),
            );
            // L'ombre appartient à la bulle PiP. En détourage il n'y a plus de bulle — une
            // ombre portée par un rectangle invisible se lit comme un artefact.
            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();
            if cfg.shadow && !webcam_is_block && !is_cutout && shape_fade > 0.0 {
                let strength = WEBCAM_SHADOW_OPACITY * shape_fade;
                self.draw_shadow(
                    w_dst,
                    w_px,
                    w_radius,
                    WEBCAM_SHADOW_SPREAD_FRAC * frame_min_px,
                    [0.0, WEBCAM_SHADOW_OFFSET_FRAC * frame_min_px],
                    strength,
                );
            }
            // Effet d'arrière-plan : le mode vient de la scène, le masque par pixel de
            // l'inférence. Les DEUX sont requis — un mode sans masque rendrait la webcam
            // invisible en détourage, donc tant que rien n'a été segmenté on dessine la piste
            // telle quelle. C'est aussi ce qui rend le premier lancement gracieux.
            let mask = self.webcam_mask.borrow();
            let effect = scene_ref
                .as_ref()
                .and_then(|s| s.webcam_effect.as_ref())
                .filter(|_| mask.is_some())
                .map(|e| (e.shader_code(), e))
                .filter(|(code, _)| *code > 0.0);

            // Fond personnalisé : on PEINT le fond dans la bulle, puis on y découpe la caméra
            // par-dessus — le mélange alpha donne `lerp(fond, caméra, 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 ; dégradés et
            // images y tombaient sur du noir, et le défaut EST une image.
            let (effect_code, blur_intensity) = match effect {
                Some((code, e)) if code > 2.5 => {
                    self.draw_webcam_bg(e.background.as_ref(), w_dst, w_px, w_radius);
                    (1.0, 0.0)
                }
                Some((code, e)) => (code, e.blur_intensity.clamp(0.0, 1.0)),
                None => (0.0, 0.0),
            };

            if let Some(m) = mask.as_ref() {
                // `draw_video` ne lie que les slots 0-1, donc le masque posé ici tient pour
                // l'appel qui suit. Il est délié juste après pour ne pas fuir sur les calques
                // d'annotation, qui utilisent eux aussi le slot 2 et au-delà.
                self.ctx.PSSetShaderResources(3, Some(&[Some(m.srv.clone())]));
            }
            self.draw_video(
                &LayerCB {
                    dst: w_dst,
                    src: [u0, sv0, u1, sv1],
                    quad_px: w_px,
                    radius_px: w_radius,
                    mode: 0.0,
                    // `color.a` porte l'alpha du découpage (`color.a * personne`) ; le RGB n'est
                    // plus lu, le fond ayant déjà été peint sous la caméra.
                    color: [0.0, 0.0, 0.0, 1.0],
                    fx: [w_valid[0], w_valid[1], effect_code, blur_intensity],
                    src_prev: [u0, sv0, u1, sv1], // src fixe (pas de zoom webcam)
                    dst_prev: w_dst_prev,
                    mb: [mb_taps, mb_amount, 1.0, 0.0],
                    ..Default::default()
                },
                &wy,
                &wuv,
            );
            if mask.is_some() {
                self.ctx.PSSetShaderResources(3, Some(&[None]));
            }
        }

        // --- annotations : calque le plus haut, comme dans le DOM de la preview (le calque y est
        // monté après la vidéo). Ancrées sur `s_ann`, le rect ÉCRAN SANS ZOOM — c'est le conteneur
        // que reçoit l'overlay web (`layout.screenRect`) — et volontairement pas sur le rect de
        // sortie, ni sujettes au zoom : dans la preview l'overlay est frère de l'élément qui porte
        // la transform, donc les annotations restent en place pendant que le contenu zoome dessous.
        // Ce fut `s_dst` tant que le zoom vivait dans la coupe source ; depuis l'issue #179 il vit
        // dans la BOÎTE, et `s_dst` emmenait annotations et sous-titres avec lui.
        // Les flous de confidentialité, eux, sont passés avant le curseur (plus haut) : ils suivent
        // le contenu (`FrameGeometry::privacy_mask`), d'où la géométrie entière passée en plus de
        // `s_ann`.
        // `source_t`, la même base de temps que les zoom/speed regions : le temps SOURCE du clip,
        // pas le compteur de frames. C'est ce qui garde une annotation alignée sur l'image quand
        // une speed region répète ou saute des frames.
        self.draw_annotations(scene_ref.as_ref(), source_t, s_ann, &g, false);
        Ok(())
    }

    /// Dessine les annotations visibles à `t`. `s_ann` = rect écran SANS ZOOM, en fractions de
    /// sortie.
    ///
    /// Le paramètre s'appelle `s_ann` et pas `screen_dst` parce que c'est le seul rect correct
    /// pour le texte, les flèches et les images : lui passer `s_dst` fait dériver et grossir les
    /// sous-titres sous un zoom (issue #179, puis #397 sur Linux). L'arithmétique elle-même vit
    /// dans `frame_geometry::annotation_dst_in`, partagée par les trois backends. Le flou, lui,
    /// se place par `g.privacy_mask` : un masque doit rester sur ce qu'il cache.
    ///
    /// `privacy` : les flous de confidentialité seuls, dessinés sur le métrage avant le curseur ;
    /// sinon toutes les autres annotations, le calque le plus haut.
    unsafe fn draw_annotations(
        &self,
        scene: Option<&Scene>,
        t: f32,
        s_ann: [f32; 4],
        g: &crate::frame_geometry::FrameGeometry,
        privacy: bool,
    ) {
        let Some(scene) = scene else { return };
        if scene.annotations.is_empty() {
            return;
        }
        let visible = |a: &crate::scene::SceneAnnotation| {
            t >= a.start_sec as f32 && t < a.end_sec as f32 && (a.kind == "blur") == privacy
        };
        // Une seule recopie du render target pour TOUTES les annotations flou de la frame — leur
        // lecture doit voir l'image composée sans les flous eux-mêmes, sinon deux zones qui se
        // recouvrent s'échantillonneraient l'une l'autre selon l'ordre de dessin.
        let needs_copy = scene
            .annotations
            .iter()
            .any(|a| visible(a) && a.kind == "blur" && a.blur.is_some());
        if needs_copy {
            // `CopySubresourceRegion` et non `CopyResource` : les deux textures n'ont pas le même
            // nombre de niveaux, on ne remplit que le mip 0 puis on laisse le GPU dériver le reste.
            self.ctx.CopySubresourceRegion(&self.ann_copy, 0, 0, 0, 0, &self.rt, 0, None);
            self.ctx.GenerateMips(&self.ann_copy_srv);
        }
        // La liste arrive déjà triée par zIndex croissant côté app, donc l'ordre d'itération EST
        // l'ordre de peinture — pas de tri par frame.
        for annotation in &scene.annotations {
            if !visible(annotation) {
                continue;
            }
            // `anchor` et non `s_ann` : un sous-titre (`space: "frame"`) se mesure sur le
            // cadre de sortie. Le dénominateur de la police plus bas lit le MÊME `anchor`.
            let anchor = annotation.anchor_rect(s_ann);
            let dst = crate::frame_geometry::annotation_dst_in(
                anchor,
                annotation.x,
                annotation.y,
                annotation.w,
                annotation.h,
            );
            let quad_px = [dst[2] * self.rw(), dst[3] * self.rh()];
            if quad_px[0] <= 0.0 || quad_px[1] <= 0.0 {
                continue;
            }
            match annotation.kind.as_str() {
                "figure" => {
                    let Some(figure) = annotation.figure.as_ref() else { continue };
                    let (segments, half_stroke) = crate::regions::arrow_local_geometry(
                        &figure.direction,
                        figure.stroke_width,
                        quad_px,
                    );
                    let rgba = parse_hex(&figure.color).unwrap_or([1.0, 1.0, 1.0, 1.0]);
                    self.draw_solid(&LayerCB {
                        dst,
                        quad_px,
                        mode: 9.0,
                        color: rgba,
                        fx: segments[0],
                        src_prev: segments[1],
                        dst_prev: segments[2],
                        mb: [1.0, half_stroke, 0.0, 0.0],
                        ..Default::default()
                    });
                }
                "blur" => {
                    let Some(blur) = annotation.blur.as_ref() else { continue };
                    let Some(mask) = g.privacy_mask(annotation, [self.rw(), self.rh()]) else {
                        continue;
                    };
                    // Le masque en tracé libre demande une liste de points côté GPU (buffer
                    // structuré), pas encore faite : on masque alors la BOÎTE ENGLOBANTE.
                    //
                    // Ce choix est délibéré et asymétrique. Ne rien dessiner laisserait passer en
                    // clair, dans le fichier exporté, ce que l'utilisateur a explicitement désigné
                    // comme à cacher — un masque de confidentialité qui ne masque pas est pire que
                    // pas de masque, parce qu'il donne confiance à tort. Sur-flouter une marge
                    // autour de la zone ne trahit personne.
                    let freehand_fallback = blur.shape == "freehand";
                    let is_blur = if blur.style == "blur" { 1.0 } else { 0.0 };
                    // `intensity` pilote le rayon du flou, `block_size` la grille de mosaïque —
                    // deux réglages distincts côté app, un seul paramètre ici selon le style.
                    let amount = if is_blur > 0.5 { blur.intensity } else { blur.block_size };
                    // Le repli du tracé libre passe par le rectangle, pas l'ovale : un ovale
                    // inscrit dans la boîte englobante en retirerait les coins, donc une partie de
                    // ce que l'utilisateur a couvert.
                    // Masque élargi à la trace du flou de mouvement : l'ovale n'y couvrirait plus tout.
                    let is_oval =
                        if blur.shape == "oval" && !freehand_fallback && mask.oval_ok { 1.0 } else { 0.0 };
                    // La teinte n'a de sens qu'en mosaïque : elle sert à marquer visiblement une
                    // zone caviardée. Un flou teinté ne ressemblerait plus à 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();
                    self.ctx.PSSetShaderResources(2, Some(&[Some(self.ann_copy_srv.clone())]));
                    self.draw_solid(&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()
                    });
                }
                "image" => {
                    let Some(src) = annotation.image_path.as_ref() else { continue };
                    if src.is_empty() {
                        continue;
                    }
                    // Cache indexé sur l'ID de l'annotation, pas sur la data URL : celle-ci pèse
                    // souvent des mégaoctets, et la prendre comme clé de HashMap la ferait hacher
                    // à chaque frame. La longueur, stockée à côté, sert de garde-fou quand
                    // l'utilisateur change l'image (une nouvelle image de longueur identique au
                    // bit près serait manquée jusqu'au rechargement — coût accepté en connaissance).
                    let key = annotation.id.clone();
                    let cached = {
                        let cache = self.ann_img_cache.borrow();
                        cache.get(&key).filter(|(_, _, _, len)| *len == src.len()).cloned()
                    };
                    let Some((srv, iw, ih, _)) = cached.or_else(|| {
                        match self.load_image_srv(src) {
                            Ok((srv, w, h)) => {
                                let entry = (srv, w, h, src.len());
                                self.ann_img_cache.borrow_mut().insert(key, entry.clone());
                                Some(entry)
                            }
                            Err(e) => {
                                eprintln!("[annotation image] {}: {e}", annotation.id);
                                None
                            }
                        }
                    }) else {
                        continue;
                    };
                    if iw == 0 || ih == 0 {
                        continue;
                    }
                    // `object-contain`, comme la preview : mise à l'échelle uniforme pour tenir
                    // DANS la boîte, centrée. On rétrécit le rect de destination au ratio de
                    // l'image plutôt que de recadrer la source, ce qui donne exactement ça.
                    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 fit = [
                        dst[0] + (dst[2] - fit_w) * 0.5,
                        dst[1] + (dst[3] - fit_h) * 0.5,
                        fit_w,
                        fit_h,
                    ];
                    self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
                    self.draw_solid(&LayerCB {
                        dst: fit,
                        src: [0.0, 0.0, 1.0, 1.0],
                        quad_px: [fit_w * self.rw(), fit_h * self.rh()],
                        // mode 7 = sprite RGBA avec alpha, déjà utilisé par les thèmes de curseur :
                        // exactement ce qu'il faut ici, donc aucun shader de plus. `fx` est son
                        // rect de clip — plein cadre, pour ne rien découper.
                        mode: 7.0,
                        color: [1.0, 1.0, 1.0, 1.0],
                        fx: [0.0, 0.0, 1.0, 1.0],
                        ..Default::default()
                    });
                }
                "text" => {
                    let Some(text) = annotation.text.as_ref() else { continue };
                    let Some(raster) = self.text_raster.as_ref() else { continue };
                    if text.content.trim().is_empty() {
                        continue;
                    }
                    // `font_size_rel` est une fraction de la HAUTEUR DE LA BOÎTE D'ANCRAGE — rect
                    // écran, ou cadre de sortie pour un sous-titre (cf. le contrat et
                    // `annotationScale.ts`) : on la ramène en pixels de sortie ici, avec le même
                    // produit que la preview applique contre sa propre boîte.
                    let anchor_h_px = anchor[3] * self.rh();
                    let spec = crate::text::TextSpec {
                        content: text.content.clone(),
                        color: parse_hex(&text.color).unwrap_or([1.0, 1.0, 1.0, 1.0]),
                        // "transparent" ne parse pas en hex : alpha 0 => pas de fond, ce qui est
                        // exactement la sémantique CSS.
                        background: parse_hex(&text.background_color).unwrap_or([0.0, 0.0, 0.0, 0.0]),
                        font_size_px: text.font_size_rel * anchor_h_px,
                        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() as u32, quad_px[1].round() as u32],
                    };
                    let key = spec.cache_key();
                    let cached = {
                        let cache = self.text_cache.borrow();
                        cache.get(&annotation.id).filter(|(_, k)| *k == key).map(|(srv, _)| srv.clone())
                    };
                    let Some(srv) = cached.or_else(|| match raster.rasterize(&self.dev, &spec) {
                        Ok(srv) => {
                            self.text_cache
                                .borrow_mut()
                                .insert(annotation.id.clone(), (srv.clone(), key));
                            Some(srv)
                        }
                        Err(e) => {
                            eprintln!("[annotation texte] {}: {e}", annotation.id);
                            None
                        }
                    }) else {
                        continue;
                    };
                    // Animation d'apparition. Elle est comptée en temps SOURCE (le seul dont on
                    // dispose ici) : dans une région accélérée, elle défile donc au rythme du
                    // clip. À vitesse 1 — le cas de toutes les annotations existantes — c'est
                    // exactement le timing de l'aperçu DOM.
                    let anim = crate::text_anim::text_animation_state(
                        text.animation.as_deref(),
                        (t - annotation.start_sec as f32) * 1000.0,
                        ((annotation.end_sec - annotation.start_sec) * 1000.0) as f32,
                    );
                    // Les décalages sont donnés à la hauteur de référence : on les ramène à la
                    // sortie, comme la taille de police, pour que l'animation ait la même
                    // amplitude visuelle quelle que soit la résolution.
                    let anim_px = self.rh() / crate::text_anim::ANIMATION_REFERENCE_HEIGHT;
                    let (mut ax, mut ay, mut aw, mut ah) = (
                        dst[0] + anim.translate_x * anim_px / self.rw(),
                        dst[1] + anim.translate_y * anim_px / self.rh(),
                        dst[2],
                        dst[3],
                    );
                    if (anim.scale - 1.0).abs() > 1e-4 {
                        // Mise à l'échelle autour du CENTRE de la boîte : un texte qui grossit par
                        // son coin haut-gauche glisserait en biais au lieu de gonfler sur place.
                        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 à écrire : on ne rogne que la LARGEUR, source et destination
                    // ensemble, ce qui reproduit le `inset(0 X% 0 0)` de l'aperçu sans redemander
                    // une rastérisation par caractère.
                    let reveal = anim.reveal.clamp(0.0, 1.0);
                    if reveal <= 0.0 {
                        continue;
                    }
                    self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
                    self.draw_solid(&LayerCB {
                        dst: [ax, ay, aw * reveal, ah],
                        src: [0.0, 0.0, reveal, 1.0],
                        quad_px: [aw * reveal * self.rw(), ah * self.rh()],
                        // mode 11 : sprite en alpha DÉJÀ prémultiplié (ce que produit D2D).
                        mode: 11.0,
                        color: [1.0, 1.0, 1.0, anim.opacity],
                        ..Default::default()
                    });
                }
                _ => {}
            }
        }
        self.ctx.PSSetShaderResources(2, Some(&[None]));
    }

    /// Flou de mouvement (§8) : moyenne de `n` sous-frames aux temps intermédiaires
    /// (mêmes textures vidéo, params d'animation à frame+k/n). Résultat laissé dans le RT.
    pub unsafe fn compose_frame_mb(
        &self,
        screen: *const AVFrame,
        webcam: *const AVFrame,
        frame: u32,
        cfg: &Cfg,
    ) -> Result<()> {
        let n = cfg.mblur_n;
        if n <= 1 {
            return self.compose_frame(screen, webcam, frame as f32, cfg);
        }
        // accumulateur à zéro
        self.ctx.ClearRenderTargetView(&self.accum_rtv, &[0.0, 0.0, 0.0, 0.0]);
        let w = 1.0 / n as f32;
        for k in 0..n {
            let tf = frame as f32 + (k as f32 + 0.5) / n as f32 - 0.5;
            self.compose_frame(screen, webcam, tf, cfg)?; // -> self.rt
            // accum += rt * (1/n)  (blend factor = 1/n, dest = ONE)
            self.ctx.OMSetRenderTargets(Some(&[Some(self.accum_rtv.clone())]), None);
            self.ctx.PSSetShaderResources(0, Some(&[Some(self.rt_srv.clone())]));
            self.ctx.VSSetShader(&self.vs_fs, None);
            self.ctx.PSSetShader(&self.ps_tex, None);
            self.ctx.PSSetSamplers(0, Some(&[Some(self.sampler.clone())]));
            let vp = D3D11_VIEWPORT {
                TopLeftX: 0.0, TopLeftY: 0.0,
                Width: self.rw(), Height: self.rh(), MinDepth: 0.0, MaxDepth: 1.0,
            };
            self.ctx.RSSetViewports(Some(&[vp]));
            self.ctx.OMSetBlendState(&self.blend_add, Some(&[w, w, w, w]), 0xffffffff);
            self.upload_cb(&LayerCB::default());
            self.ctx.Draw(3, 0);
            self.ctx.PSSetShaderResources(0, Some(&[None]));
        }
        // recopie l'accumulateur dans le RT (pour rgb_to_nv12 qui échantillonne rt_srv)
        let src: ID3D11Resource = self.accum.cast()?;
        let dst: ID3D11Resource = self.rt.cast()?;
        self.ctx.CopyResource(&dst, &src);
        Ok(())
    }

    /// Rend le RT RGBA vers notre texture NV12 puis copie vers la surface `out_tex`/`slice`.
    pub unsafe fn rgb_to_nv12(&self, out_tex: *mut c_void, slice: u32) -> Result<()> {
        self.render_nv12();
        let src: ID3D11Resource = self.nv12.cast()?;
        let dst_tex = ID3D11Texture2D::from_raw_borrowed(&out_tex).unwrap().clone();
        let dst: ID3D11Resource = dst_tex.cast()?;
        self.ctx.CopySubresourceRegion(&dst, slice, 0, 0, 0, &src, 0, None);
        Ok(())
    }

    /// Alloue (une fois par taille) les ressources du resize export : RGBA intermédiaire +
    /// sa propre texture NV12 à `w`×`h`. `w`/`h` doivent être pairs (exigé par NV12 4:2:0,
    /// le plan UV fait exactement la moitié) — l'appelant (export_multi côté napi) arrondit.
    unsafe fn ensure_resize_target(&self, w: u32, h: u32) -> Result<()> {
        if let Some(t) = self.resize_target.borrow().as_ref() {
            if t.w == w && t.h == h {
                return Ok(());
            }
        }
        let rd = D3D11_TEXTURE2D_DESC {
            Width: w,
            Height: h,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_R8G8B8A8_UNORM,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        let mut rgba: Option<ID3D11Texture2D> = None;
        self.dev.CreateTexture2D(&rd, None, Some(&mut rgba))?;
        let rgba = rgba.unwrap();
        let mut rgba_rtv: Option<ID3D11RenderTargetView> = None;
        self.dev.CreateRenderTargetView(&rgba, None, Some(&mut rgba_rtv))?;
        let mut rgba_srv: Option<ID3D11ShaderResourceView> = None;
        self.dev.CreateShaderResourceView(&rgba, None, Some(&mut rgba_srv))?;

        // NV12 non-array à la taille cible (même contrainte que le NV12 principal).
        let nvd = D3D11_TEXTURE2D_DESC {
            Width: w,
            Height: h,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_NV12,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        let mut nv12: Option<ID3D11Texture2D> = None;
        self.dev.CreateTexture2D(&nvd, None, Some(&mut nv12))?;
        let nv12 = nv12.unwrap();
        let mk_rtv = |fmt: DXGI_FORMAT| -> Result<ID3D11RenderTargetView> {
            let d = D3D11_RENDER_TARGET_VIEW_DESC {
                Format: fmt,
                ViewDimension: D3D11_RTV_DIMENSION_TEXTURE2D,
                Anonymous: D3D11_RENDER_TARGET_VIEW_DESC_0 { Texture2D: D3D11_TEX2D_RTV { MipSlice: 0 } },
            };
            let mut rtv: Option<ID3D11RenderTargetView> = None;
            self.dev.CreateRenderTargetView(&nv12, Some(&d), Some(&mut rtv))?;
            Ok(rtv.unwrap())
        };
        let nv12_rtv_y = mk_rtv(DXGI_FORMAT_R8_UNORM)?;
        let nv12_rtv_uv = mk_rtv(DXGI_FORMAT_R8G8_UNORM)?;

        *self.resize_target.borrow_mut() = Some(ResizeTarget {
            w,
            h,
            rgba_rtv: rgba_rtv.unwrap(),
            rgba_srv: rgba_srv.unwrap(),
            nv12,
            nv12_rtv_y,
            nv12_rtv_uv,
        });
        Ok(())
    }

    /// Redimensionne (bilinéaire) le RT composé, à sa taille de rendu, vers `resize_target.rgba`
    /// (`target_w`×`target_h`), avant la conversion NV12 dans `rgb_to_nv12_scaled`.
    ///
    /// Plein cadre, sans viewport ni bandes. Le RT porte déjà la géométrie de sortie (l'export
    /// le crée à la taille de sortie) et les appelants demandent cette géométrie : l'échelle est
    /// donc la même sur les deux axes, à l'arrondi au pair de `normalize_render_size` près. Rien
    /// n'est pré-compensé en amont : la passe `undistort`, qui rétrécissait l'écran et la webcam
    /// avant un étirement non uniforme, a disparu avec le canvas figé en 16:9.
    unsafe fn blit_resized(&self, target_w: u32, target_h: u32) -> Result<()> {
        self.ensure_resize_target(target_w, target_h)?;
        let cache = self.resize_target.borrow();
        let t = cache.as_ref().unwrap();
        self.ctx.OMSetBlendState(&self.blend_none, None, 0xffffffff);
        self.ctx.OMSetRenderTargets(Some(&[Some(t.rgba_rtv.clone())]), None);
        self.ctx.PSSetShaderResources(0, Some(&[Some(self.rt_srv.clone())]));
        self.ctx.VSSetShader(&self.vs_fs, None);
        self.ctx.PSSetShader(&self.ps_tex, None);
        self.ctx.PSSetSamplers(0, Some(&[Some(self.sampler.clone())]));
        let vp = D3D11_VIEWPORT {
            TopLeftX: 0.0, TopLeftY: 0.0,
            Width: target_w as f32, Height: target_h as f32, MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp]));
        self.ctx.Draw(3, 0);
        self.ctx.PSSetShaderResources(0, Some(&[None]));
        Ok(())
    }

    /// Lit le RT composité (résolu à `target_w`×`target_h`, via le même `blit_resized`
    /// réutilisé par `rgb_to_nv12_scaled` pour l'export) vers un `Vec<u8>` RGBA8
    /// tightly-packed (`target_w * target_h * 4` octets, ordre R,G,B,A en mémoire — ce
    /// que `putImageData(..., 'rgba8')` attend côté JS).
    ///
    /// Pourquoi un helper dédié plutôt qu'un open-coding dans `live.rs` : tout le
    /// pattern GPU→CPU de ce fichier (staging `D3D11_USAGE_STAGING`, `CopyResource`,
    /// `Map`/`D3D11_MAP_READ` + copie ligne par ligne qui respecte `RowPitch`) vit déjà
    /// dans `dump_nv12`/`dump_raw` — le partager garde la connaissance D3D11 confinée
    /// à ce fichier et assure que le live et l'export ne divergent pas sur un détail de
    /// copie. La staging est cachée par taille (`live_readback_staging`) — recréée quand
    /// `target_w`/`target_h` changent — pour ne pas payer une allocation par frame.
    ///
    /// Pré-requis : `target_w`/`target_h` ≥ 1. Aucun effet sur le pipeline d'export
    /// (les sites d'appel de `rgb_to_nv12_scaled` et `blit_resized` ne sont pas touchés
    /// — ce helper réutilise `blit_resized` mais n'est pas sur le chemin d'export).
    pub unsafe fn readback_resized(
        &self,
        target_w: u32,
        target_h: u32,
    ) -> Result<Vec<u8>> {
        // `ensure_resize_target` (partagé avec l'export) crée INCONDITIONNELLEMENT une
        // texture NV12 en plus de la RGBA, même si ce chemin RGBA-only ne s'en sert jamais —
        // et NV12 (4:2:0, chroma sous-échantillonnée 2×2) exige des dimensions PAIRES.
        // Le canvas Electron (taille device-pixel arbitraire, ex. 910×513) atterrit souvent
        // sur une dimension impaire → `CreateTexture2D` de la texture NV12 échouait avec
        // E_INVALIDARG (0x80070057), et donc TOUT le readback live (jamais une seule frame
        // publiée). On arrondit au pair supérieur ici uniquement — l'export appelle
        // `rgb_to_nv12_scaled`/`blit_resized` directement avec ses propres dimensions et
        // n'est pas concerné par cet arrondi.
        let w = (target_w.max(1) + 1) & !1;
        let h = (target_h.max(1) + 1) & !1;
        // Dims RÉELLEMENT demandées par l'appelant — le buffer retourné doit rester à cette
        // taille exacte (le canvas JS attend `target_w*target_h*4` octets pile), même si le GPU
        // travaille en interne à `w`×`h` (arrondi pair) pour satisfaire la contrainte NV12.
        let out_w = target_w.max(1);
        let out_h = target_h.max(1);

        // 1) Resize GPU exactement comme `rgb_to_nv12_scaled` : remplit le `resize_target`
        //    RGBA à `w`×`h`. On s'arrête avant la conversion NV12 — on copie le RGBA.
        self.blit_resized(w, h)?;
        // BUG corrigé : un SRV n'est PAS la ressource (`ID3D11ShaderResourceView` et
        // `ID3D11Texture2D` sont des interfaces COM sans rapport de parenté) — un
        // `.cast::<ID3D11Texture2D>()` direct sur le SRV échoue avec E_NOINTERFACE
        // (0x80004002, confirmé à l'exécution). Il faut passer par `GetResource()`
        // (méthode de `ID3D11View`, implémentée par tout SRV/RTV) pour récupérer la
        // ressource sous-jacente, ici directement en `ID3D11Resource` — le type que
        // `CopyResource` attend de toute façon, donc pas besoin d'aller jusqu'à
        // `ID3D11Texture2D`.
        let rgba_resource: ID3D11Resource = {
            let cache = self.resize_target.borrow();
            let t = cache.as_ref().unwrap();
            t.rgba_srv.GetResource()?
        };

        // 2) Staging texture CPU-readable à la taille cible, recréée paresseusement
        //    quand la taille change (cache : `live_readback_staging`).
        let staging = {
            let mut slot = self.live_readback_staging.borrow_mut();
            match slot.as_ref() {
                Some((sw, sh, t)) if *sw == w && *sh == h => t.clone(),
                _ => {
                    let desc = D3D11_TEXTURE2D_DESC {
                        Width: w,
                        Height: h,
                        MipLevels: 1,
                        ArraySize: 1,
                        // Même format que `resize_target.rgba` créé dans
                        // `ensure_resize_target` (R8G8B8A8_UNORM) — la `CopyResource`
                        // est valide sans conversion GPU.
                        Format: DXGI_FORMAT_R8G8B8A8_UNORM,
                        SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
                        Usage: D3D11_USAGE_STAGING,
                        BindFlags: 0,
                        CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32,
                        MiscFlags: 0,
                    };
                    let mut tex: Option<ID3D11Texture2D> = None;
                    self.dev.CreateTexture2D(&desc, None, Some(&mut tex))?;
                    let tex = tex.unwrap();
                    *slot = Some((w, h, tex.clone()));
                    tex
                }
            }
        };

        // 3) GPU → CPU : `CopyResource` resize_target → staging, puis `Map` + copie
        //    ligne par ligne qui respecte `RowPitch` (cf. `dump_nv12`/`dump_raw`).
        // `ID3D11Texture2D` hérite réellement de `ID3D11Resource` (contrairement au
        // SRV plus haut) donc ce `.cast()` est valide.
        let dst: ID3D11Resource = staging.cast()?;
        self.ctx.CopyResource(&dst, &rgba_resource);
        let mut m = D3D11_MAPPED_SUBRESOURCE::default();
        self.ctx.Map(&staging, 0, D3D11_MAP_READ, 0, Some(&mut m))?;
        // Crop implicite : on ne lit que les `out_w`×`out_h` premiers pixels de la texture
        // (arrondie pair) — le reliquat éventuel (au plus 1px en largeur/hauteur) est ignoré.
        let mut out: Vec<u8> = vec![0u8; (out_w * out_h * 4) as usize];
        let row_bytes = (out_w * 4) as usize;
        for y in 0..out_h as usize {
            let src_row = (m.pData as *const u8).add(y * m.RowPitch as usize);
            let dst_row = out.as_mut_ptr().add(y * row_bytes);
            std::ptr::copy_nonoverlapping(src_row, dst_row, row_bytes);
        }
        self.ctx.Unmap(&staging, 0);
        Ok(out)
    }

    /// Readback du RT composité vers CPU **à sa résolution de rendu**, sans aucun resize.
    ///
    /// Contrairement à `readback_resized` (qui passe par `blit_resized` → un `resize_target`
    /// incluant une texture NV12 jamais lue par ce chemin RGBA-only, puis une staging séparée),
    /// on copie directement `rt → staging` : la `staging` du compositeur est DÉJÀ dimensionnée
    /// à la résolution de rendu (`new_inner`), exactement le patron de `dump_raw`. Depuis la
    /// refonte ratio, le RT est rastérisé à la géométrie de sortie ramenée au panneau — soit
    /// précisément la taille que la preview veut afficher —, donc le resize de `readback_resized`
    /// était devenu une copie identité doublée d'une alloc NV12 inutile, du coût pur à chaque
    /// frame. `readback_resized` reste pour le golden test (qui readback à une taille arbitraire).
    ///
    /// Retourne `(render_w, render_h, pixels)` avec `pixels.len() == render_w * render_h * 4`
    /// octets RGBA8 tightly-packed. L'appelant (`live.rs`) publie ces dims dans le packet ; le
    /// canvas côté JS se dimensionne dessus (frame auto-descriptive), donc aucun couplage de
    /// taille à maintenir des deux côtés.
    pub unsafe fn readback_direct(&self) -> Result<(u32, u32, Vec<u8>)> {
        let (rw, rh) = self.render_dims();
        self.ctx.CopyResource(&self.staging, &self.rt);
        let mut m = D3D11_MAPPED_SUBRESOURCE::default();
        self.ctx.Map(&self.staging, 0, D3D11_MAP_READ, 0, Some(&mut m))?;
        // Copie ligne par ligne qui respecte `RowPitch` (la staging peut être paddée par le
        // driver) — même idiome que `dump_raw`/`readback_resized`.
        let row = (rw * 4) as usize;
        let mut out = vec![0u8; row * rh as usize];
        for y in 0..rh as usize {
            let src = (m.pData as *const u8).add(y * m.RowPitch as usize);
            let dst = out.as_mut_ptr().add(y * row);
            std::ptr::copy_nonoverlapping(src, dst, row);
        }
        self.ctx.Unmap(&self.staging, 0);
        Ok((rw, rh, out))
    }

    /// Le RT de la dernière composition, à `render_size()`, pour qui le copie ailleurs sans
    /// passer par la RAM : l'anneau de textures partagées de la preview (`shared_frames`).
    pub fn render_target(&self) -> &ID3D11Texture2D {
        &self.rt
    }

    /// Comme `rgb_to_nv12`, mais vers `target_w`×`target_h` : si la cible diffère de la taille
    /// de rendu, le RT composé est d'abord redimensionné (bilinéaire, `ps_tex`/`sampler` déjà
    /// utilisés partout ailleurs dans le fichier, cf. `blit_resized`). Le RT suivant la sortie,
    /// c'est l'exception : dans le cas nominal la cible est la taille de rendu, et le coût est
    /// celui de `rgb_to_nv12`.
    pub unsafe fn rgb_to_nv12_scaled(
        &self,
        target_w: u32,
        target_h: u32,
        out_tex: *mut c_void,
        slice: u32,
    ) -> Result<()> {
        // Raccourci : la cible est déjà la taille à laquelle on vient de rastériser
        // → aucun resize à faire, on convertit le RT directement. Comparé à la
        // taille de rendu COURANTE et non à une constante : une fois le RT aligné
        // sur `output`, c'est justement le cas nominal.
        // Produire le NV12 (partagé avec l'encodeur logiciel), puis le copier GPU→GPU
        // vers le pool de l'encodeur matériel — la seule partie qui lui soit propre.
        let src_tex = self.nv12_source(target_w, target_h)?;
        let src: ID3D11Resource = src_tex.cast()?;
        let dst_tex = ID3D11Texture2D::from_raw_borrowed(&out_tex).unwrap().clone();
        let dst: ID3D11Resource = dst_tex.cast()?;
        self.ctx.CopySubresourceRegion(&dst, slice, 0, 0, 0, &src, 0, None);
        Ok(())
    }

    /// Rastérise le NV12 de sortie à `target_w`×`target_h` et rend LA TEXTURE du
    /// compositeur qui le porte. C'est la moitié commune aux deux encodeurs : le matériel
    /// la copie GPU→GPU vers le pool AMF (`rgb_to_nv12_scaled` ci-dessus), le logiciel la
    /// relit vers la RAM (`read_nv12_scaled` ci-dessous). Extraite pour que les deux
    /// backends produisent le MÊME NV12 — sinon l'export CPU dériverait du matériel sur
    /// un détail de conversion, exactement ce que l'iso doit empêcher.
    unsafe fn nv12_source(&self, target_w: u32, target_h: u32) -> Result<ID3D11Texture2D> {
        let (rw_i, rh_i) = self.render_dims();
        if target_w == rw_i && target_h == rh_i {
            self.render_nv12();
            return Ok(self.nv12.clone());
        }
        // Même séquence que `rgb_to_nv12_scaled`, dont c'est la partie « produire ».
        self.blit_resized(target_w, target_h)?;
        let cache = self.resize_target.borrow();
        let t = cache.as_ref().unwrap();
        self.ctx.OMSetRenderTargets(Some(&[Some(t.nv12_rtv_y.clone())]), None);
        self.ctx.PSSetShaderResources(0, Some(&[Some(t.rgba_srv.clone())]));
        let vp_y = D3D11_VIEWPORT {
            TopLeftX: 0.0, TopLeftY: 0.0,
            Width: target_w as f32, Height: target_h as f32, MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp_y]));
        self.ctx.PSSetShader(&self.ps_y, None);
        self.ctx.Draw(3, 0);

        self.ctx.OMSetRenderTargets(Some(&[Some(t.nv12_rtv_uv.clone())]), None);
        let vp_uv = D3D11_VIEWPORT {
            TopLeftX: 0.0, TopLeftY: 0.0,
            Width: (target_w / 2) as f32, Height: (target_h / 2) as f32, MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp_uv]));
        self.ctx.PSSetShader(&self.ps_uv, None);
        self.ctx.Draw(3, 0);
        self.ctx.PSSetShaderResources(0, Some(&[None]));
        Ok(t.nv12.clone())
    }

    /// Le NV12 de sortie LU vers la mémoire système, plan Y puis plan UV.
    ///
    /// Pendant de `rgb_to_nv12_scaled` pour un encodeur LOGICIEL : `libopenh264` ne sait
    /// pas prendre une texture D3D11, il veut des plans en RAM. C'est la seule copie
    /// GPU→CPU du chemin d'export CPU, et elle est inévitable — le backend CPU rastérise
    /// sur WARP (donc déjà en RAM côté pilote) mais D3D11 n'expose pas ces octets
    /// autrement que par une staging.
    ///
    /// `dst_y`/`dst_uv` doivent tenir `target_h * pitch_y` et `target_h/2 * pitch_uv`
    /// octets — typiquement les `data[0]`/`data[1]` d'une `AVFrame` NV12.
    pub unsafe fn read_nv12_scaled(
        &self,
        target_w: u32,
        target_h: u32,
        dst_y: *mut u8,
        pitch_y: usize,
        dst_uv: *mut u8,
        pitch_uv: usize,
    ) -> Result<()> {
        let src_tex = self.nv12_source(target_w, target_h)?;

        // Staging NV12 cachée par taille (même idiome que `live_readback_staging`) :
        // une allocation par changement de résolution, pas une par frame.
        let mut cache = self.nv12_readback_staging.borrow_mut();
        if cache.as_ref().map(|(w, h, _)| (*w, *h)) != Some((target_w, target_h)) {
            let sd = D3D11_TEXTURE2D_DESC {
                Width: target_w,
                Height: target_h,
                MipLevels: 1,
                ArraySize: 1,
                Format: DXGI_FORMAT_NV12,
                SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
                Usage: D3D11_USAGE_STAGING,
                BindFlags: 0,
                CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32,
                MiscFlags: 0,
            };
            let mut t: Option<ID3D11Texture2D> = None;
            self.dev.CreateTexture2D(&sd, None, Some(&mut t))?;
            *cache = Some((target_w, target_h, t.unwrap()));
        }
        let staging = &cache.as_ref().unwrap().2;

        let src: ID3D11Resource = src_tex.cast()?;
        let dst: ID3D11Resource = staging.cast()?;
        self.ctx.CopyResource(&dst, &src);

        let mut m = D3D11_MAPPED_SUBRESOURCE::default();
        self.ctx.Map(&dst, 0, D3D11_MAP_READ, 0, Some(&mut m))?;
        // Disposition NV12 mappée : Y sur `target_h` lignes de `RowPitch`, puis UV sur
        // `target_h/2` lignes au même pitch. Copie ligne par ligne — les deux pitchs
        // diffèrent (le driver pad, ffmpeg aligne sur son propre SIMD).
        let row = (target_w as usize).min(m.RowPitch as usize).min(pitch_y);
        for y in 0..target_h as usize {
            let s = (m.pData as *const u8).add(y * m.RowPitch as usize);
            std::ptr::copy_nonoverlapping(s, dst_y.add(y * pitch_y), row);
        }
        let uv_src = (m.pData as *const u8).add(m.RowPitch as usize * target_h as usize);
        let uv_row = (target_w as usize).min(m.RowPitch as usize).min(pitch_uv);
        for y in 0..(target_h as usize / 2) {
            let s = uv_src.add(y * m.RowPitch as usize);
            std::ptr::copy_nonoverlapping(s, dst_uv.add(y * pitch_uv), uv_row);
        }
        self.ctx.Unmap(&dst, 0);
        Ok(())
    }

    /// Convertit le RT RGBA vers notre texture NV12 (§5) : Y pleine réso, UV demi-réso.
    pub unsafe fn render_nv12(&self) {
        self.ctx.OMSetBlendState(&self.blend_none, None, 0xffffffff);
        self.ctx.VSSetShader(&self.vs_fs, None);
        self.ctx.PSSetSamplers(0, Some(&[Some(self.sampler.clone())]));

        // passe Y : basculer le RT AVANT de binder le SRV (le RGBA RT était encore RTV via
        // begin() ; D3D11 rejetterait le SRV d'une ressource encore liée en RTV).
        self.ctx.OMSetRenderTargets(Some(&[Some(self.rtv_y.clone())]), None);
        self.ctx.PSSetShaderResources(0, Some(&[Some(self.rt_srv.clone())]));
        let vp_y = D3D11_VIEWPORT {
            TopLeftX: 0.0, TopLeftY: 0.0,
            Width: self.rw(), Height: self.rh(), MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp_y]));
        self.ctx.PSSetShader(&self.ps_y, None);
        self.ctx.Draw(3, 0);

        // passe UV (demi-résolution)
        self.ctx.OMSetRenderTargets(Some(&[Some(self.rtv_uv.clone())]), None);
        let vp_uv = D3D11_VIEWPORT {
            TopLeftX: 0.0, TopLeftY: 0.0,
            Width: self.rw() / 2.0, Height: self.rh() / 2.0, MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp_uv]));
        self.ctx.PSSetShader(&self.ps_uv, None);
        self.ctx.Draw(3, 0);

        // libère le SRV du RT (il redevient RTV au prochain begin())
        self.ctx.PSSetShaderResources(0, Some(&[None]));
    }

    /// Debug : dump notre NV12 (Y puis UV entrelacé) en RAW, pour inspecter la conversion.
    pub unsafe fn dump_nv12(&self, path: &str) -> Result<()> {
        let sd = D3D11_TEXTURE2D_DESC {
            Width: OUT_W,
            Height: OUT_H,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_NV12,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_STAGING,
            BindFlags: 0,
            CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32,
            MiscFlags: 0,
        };
        let mut stg: Option<ID3D11Texture2D> = None;
        self.dev.CreateTexture2D(&sd, None, Some(&mut stg))?;
        let stg = stg.unwrap();
        let src: ID3D11Resource = self.nv12.cast()?;
        let dstr: ID3D11Resource = stg.cast()?;
        self.ctx.CopyResource(&dstr, &src);
        let mut m = D3D11_MAPPED_SUBRESOURCE::default();
        self.ctx.Map(&stg, 0, D3D11_MAP_READ, 0, Some(&mut m))?;
        let (rw_i, rh_i) = self.render_dims();
        let mut out = Vec::with_capacity((rw_i * rh_i * 3 / 2) as usize);
        // plan Y
        for y in 0..rh_i as usize {
            let row = (m.pData as *const u8).add(y * m.RowPitch as usize);
            out.extend_from_slice(std::slice::from_raw_parts(row, rw_i as usize));
        }
        // plan UV : commence à RowPitch*Height (offset donné par le pitch), demi-hauteur
        let uv_off = m.RowPitch as usize * rh_i as usize;
        for y in 0..(rh_i / 2) as usize {
            let row = (m.pData as *const u8).add(uv_off + y * m.RowPitch as usize);
            out.extend_from_slice(std::slice::from_raw_parts(row, rw_i as usize));
        }
        self.ctx.Unmap(&stg, 0);
        std::fs::write(path, &out)?;
        Ok(())
    }

    /// Recopie le RT en RAM (RGBA tightly-packed) — vérification uniquement.
    pub unsafe fn dump_raw(&self, path: &str) -> Result<()> {
        self.ctx.CopyResource(&self.staging, &self.rt);
        let mut m = D3D11_MAPPED_SUBRESOURCE::default();
        self.ctx.Map(&self.staging, 0, D3D11_MAP_READ, 0, Some(&mut m))?;
        let (rw_i, rh_i) = self.render_dims();
        let mut out = vec![0u8; (rw_i * rh_i * 4) as usize];
        for y in 0..rh_i as usize {
            let src = (m.pData as *const u8).add(y * m.RowPitch as usize);
            let dst = out.as_mut_ptr().add(y * rw_i as usize * 4);
            std::ptr::copy_nonoverlapping(src, dst, rw_i as usize * 4);
        }
        self.ctx.Unmap(&self.staging, 0);
        std::fs::write(path, &out)?;
        Ok(())
    }

    /// Blit du RT composité (RGBA) vers un render target externe (backbuffer swapchain),
    /// mis à l'échelle dans le viewport `(x,y,w,h)` en pixels — sert la preview (§preview).
    /// Passe de copie `ps_tex` : même échantillonnage que `render_nv12`, sans conversion.
    /// Le caller a déjà clear le RTV (barres letterbox) avant l'appel.
    pub unsafe fn blit_to(&self, rtv: &ID3D11RenderTargetView, x: f32, y: f32, w: f32, h: f32) {
        self.ctx.OMSetBlendState(&self.blend_none, None, 0xffffffff);
        self.ctx.OMSetRenderTargets(Some(&[Some(rtv.clone())]), None);
        self.ctx.PSSetShaderResources(0, Some(&[Some(self.rt_srv.clone())]));
        self.ctx.VSSetShader(&self.vs_fs, None);
        self.ctx.PSSetShader(&self.ps_tex, None);
        self.ctx.PSSetSamplers(0, Some(&[Some(self.sampler.clone())]));
        self.ctx.IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
        let vp = D3D11_VIEWPORT {
            TopLeftX: x, TopLeftY: y, Width: w, Height: h, MinDepth: 0.0, MaxDepth: 1.0,
        };
        self.ctx.RSSetViewports(Some(&[vp]));
        self.upload_cb(&LayerCB::default());
        self.ctx.Draw(3, 0);
        self.ctx.PSSetShaderResources(0, Some(&[None]));
    }

    /// Vide le cache de SRV décodeur. À appeler après la fermeture d'un jeu de décodeurs
    /// (p.ex. après un export) pour ne pas retenir indéfiniment des textures de pool.
    pub fn clear_srv_cache(&self) {
        self.srv_cache.borrow_mut().clear();
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Preuve de bout en bout que `img_cache` est borné : charge TOUS les wallpapers livrés,
    /// une frame par wallpaper — ce que fait le sélecteur quand on le parcourt — et vérifie que
    /// le total reste sous le budget.
    ///
    /// Opt-in : il crée un vrai device D3D11, ce qu'aucun autre test de ce fichier ne fait (celui
    /// juste en dessous s'en passe volontairement) et qu'un runner sans adaptateur ne peut pas
    /// fournir. Même convention que le harnais visuel de la segmentation :
    ///
    ///     set OPENSCREEN_CACHE_DEMO=1 && cargo test -p openscreen-compositor --release
    ///         img_cache_stays_under_budget -- --nocapture
    ///
    /// Les tests de `lru_evictions` couvrent la POLITIQUE ; celui-ci couvre le CÂBLAGE — que le
    /// backend l'appelle vraiment, sur les bonnes tailles, et que le budget morde sur nos assets.
    #[test]
    fn img_cache_stays_under_budget() {
        if std::env::var_os("OPENSCREEN_CACHE_DEMO").is_none() {
            eprintln!("OPENSCREEN_CACHE_DEMO absent — saute (ce test demande un device D3D11)");
            return;
        }
        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .parent()
            .and_then(|p| p.parent())
            .expect("racine du dépôt")
            .join("public/wallpapers");
        let mut papers: Vec<_> = std::fs::read_dir(&root)
            .expect("public/wallpapers")
            .filter_map(|e| e.ok().map(|e| e.path()))
            .filter(|p| {
                matches!(p.extension().and_then(|e| e.to_str()), Some("jpg" | "jpeg" | "png"))
            })
            .collect();
        papers.sort();
        assert!(papers.len() >= 10, "il faut plusieurs wallpapers pour que le budget morde");

        let gpu = crate::d3d::Gpu::create_backend(crate::d3d::Backend::Hardware, false)
            .expect("device D3D11");
        let comp = Compositor::new(&gpu).expect("compositeur");

        let mut cumule = 0u64;
        let mut pic = 0u64;
        for path in &papers {
            // Une frame par wallpaper : c'est le rythme du sélecteur, et c'est ce qui rend
            // l'entrée précédente évinçable. Dans une même frame elle ne le serait pas.
            comp.begin_image_frame();
            let p = path.to_string_lossy().to_string();
            let (_, w, h) = unsafe { comp.cached_image(&p) }.expect("chargement");
            cumule += w as u64 * h as u64 * 4;
            let cache = comp.img_cache.borrow();
            let total: u64 = cache.values().map(|e| e.1 as u64 * e.2 as u64 * 4).sum();
            pic = pic.max(total);
            eprintln!(
                "  {:<20} {:>5}x{:<5} | cache {:>2} entrées {:>4} Mo | cumulé sans éviction {:>5} Mo",
                path.file_name().unwrap().to_string_lossy(),
                w,
                h,
                cache.len(),
                total / 1048576,
                cumule / 1048576,
            );
        }
        eprintln!(
            "
  budget {} Mo | pic observé {} Mo | cumulé si rien n'était évincé {} Mo",
            IMG_CACHE_BUDGET_BYTES / 1048576,
            pic / 1048576,
            cumule / 1048576,
        );
        assert!(
            pic <= IMG_CACHE_BUDGET_BYTES,
            "le cache a dépassé son budget : {} Mo > {} Mo",
            pic / 1048576,
            IMG_CACHE_BUDGET_BYTES / 1048576
        );
        assert!(
            cumule > IMG_CACHE_BUDGET_BYTES,
            "sans éviction le total ({} Mo) doit dépasser le budget, sinon le test ne prouve rien",
            cumule / 1048576
        );
    }

    /// Un NV12 sans données, à la taille voulue : tout ce que `nv12_srvs` lit d'une frame.
    fn nv12_frame(gpu: &crate::d3d::Gpu, w: u32, h: u32) -> (Box<AVFrame>, ID3D11Texture2D) {
        let desc = D3D11_TEXTURE2D_DESC {
            Width: w,
            Height: h,
            MipLevels: 1,
            ArraySize: 1,
            Format: DXGI_FORMAT_NV12,
            SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
            Usage: D3D11_USAGE_DEFAULT,
            BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
            CPUAccessFlags: 0,
            MiscFlags: 0,
        };
        unsafe {
            let mut tex: Option<ID3D11Texture2D> = None;
            gpu.device.CreateTexture2D(&desc, None, Some(&mut tex)).expect("texture NV12");
            let tex = tex.expect("texture NV12");
            let mut frame: Box<AVFrame> = Box::new(std::mem::zeroed());
            frame.data[0] = tex.as_raw() as *mut u8;
            frame.data[1] = std::ptr::null_mut();
            (frame, tex)
        }
    }

    /// Un décodeur remplacé sans `clear_srv_cache` (changement de résolution en cours de flux,
    /// `CpuFrames::ensure_tex`) peut donner à une texture NEUVE l'adresse d'une ancienne. La
    /// copie privée gardée pour l'ancienne est alors trop petite, `CopySubresourceRegion` la
    /// saute sans erreur et l'image gèle. On ne peut pas choisir l'adresse d'une texture ;
    /// l'entrée de la petite est donc replacée sous la clé de la grande, l'état exact où le
    /// cache se retrouve après un tel recyclage.
    #[test]
    fn a_larger_source_at_a_cached_address_gets_a_copy_of_its_own_size() {
        let Ok(gpu) = crate::d3d::Gpu::create_auto(false) else {
            eprintln!("pas de device D3D11 — test sauté");
            return;
        };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("compositeur");
        let (small, _small_tex) = nv12_frame(&gpu, 64, 64);
        let (large, _large_tex) = nv12_frame(&gpu, 128, 96);
        let (small_key, large_key) = (small.data[0] as usize, large.data[0] as usize);

        unsafe { comp.nv12_srvs(&*small) }.expect("source de 64x64");
        {
            let mut cache = comp.srv_cache.borrow_mut();
            let stale = cache.remove(&small_key).expect("entrée de la petite source");
            cache.insert(large_key, stale);
        }
        unsafe { comp.nv12_srvs(&*large) }.expect("source de 128x96");

        let (dst, ..) = comp.srv_cache.borrow().get(&large_key).cloned().expect("entrée remplacée");
        let mut dd = D3D11_TEXTURE2D_DESC::default();
        unsafe { dst.GetDesc(&mut dd) };
        assert_eq!((dd.Width, dd.Height), (128, 96), "la copie a gardé la taille de l'ancienne texture");
    }

    /// Un cran de padding en format Auto change la taille de rendu de la preview. `resized`
    /// réalloue les cibles et garde le reste : le masque webcam, et la boîte aux lettres où le
    /// worker de segmentation dépose les suivants.
    #[test]
    fn resizing_keeps_the_segmentation_and_reads_back_at_the_new_size() {
        let Ok(gpu) = crate::d3d::Gpu::create_auto(false) else {
            eprintln!("pas de device D3D11 — test sauté");
            return;
        };
        let comp = Compositor::new_sized(&gpu, 320, 180).expect("compositeur");
        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 déposerait ses masques dans une boîte 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));
    }
}