Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
//! 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, SceneShaderEffect, ShaderEffectTarget,
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_TRIANGLELIST,
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,
}
/// Un effet shader de la scène (`shader_fx`), par hash de sa source.
enum ShaderFx {
/// naga + FXC tournent sur un thread de fond.
Pending(std::sync::mpsc::Receiver<Result<crate::shader_fx::CompiledFx, String>>),
Ready(ID3D11VertexShader, ID3D11PixelShader),
/// Erreur déjà écrite ; l'effet ne se dessine pas.
Failed,
}
struct ShaderFxEntry {
state: ShaderFx,
/// Dernier usage, pour l'éviction (`SHADER_FX_CACHE`).
used: u64,
}
/// Combien d'effets compilés le compositeur garde. Un agent qui itère en crée un par version.
const SHADER_FX_CACHE: usize = 64;
/// Le calque transparent des textes, pour les effets qui ne visent qu'eux.
struct TextLayer {
tex: ID3D11Texture2D,
rtv: ID3D11RenderTargetView,
srv: ID3D11ShaderResourceView,
}
/// Une cible RGBA qu'on peint puis qu'on lit : la pyramide de profondeur de champ, la copie de
/// l'enregistrement que lit `footage()`.
struct RgbaTarget {
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<RgbaTarget>>,
/// L'enregistrement à sa résolution, pour les effets qui lisent `footage()` : alloué au premier
/// d'entre eux, recréé quand la coupe change de taille, peint seulement aux frames où un tel
/// effet est actif.
footage_copy: RefCell<Option<RgbaTarget>>,
/// Effets shader de la scène, compilés une fois par source, les moins récents évincés au-delà
/// de `SHADER_FX_CACHE`.
shader_fx: RefCell<HashMap<u64, ShaderFxEntry>>,
shader_fx_tick: Cell<u64>,
/// `ctx` (b2) et `params` (b3) de la passe d'effet.
shader_fx_cb: ID3D11Buffer,
shader_fx_params_cb: ID3D11Buffer,
/// Alloué à la première frame qui porte un effet `text` ; à la taille de rendu.
text_layer: RefCell<Option<TextLayer>>,
/// Vrai par défaut : une frame dont l'effet compile encore attend son binaire, parce qu'un
/// export ne doit jamais rendre de frame sans l'effet. La preview le passe à faux et saute
/// l'effet le temps de la compilation (~10 ms), puis recompose (`shader_fx_landed`).
shader_fx_blocking: Cell<bool>,
/// 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),
text_layer: 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))?;
let fx_bd = D3D11_BUFFER_DESC {
ByteWidth: std::mem::size_of::<crate::shader_fx::FxContext>() as u32,
..bd
};
let mut shader_fx_cb: Option<ID3D11Buffer> = None;
dev.CreateBuffer(&fx_bd, None, Some(&mut shader_fx_cb))?;
let fx_params_bd = D3D11_BUFFER_DESC {
ByteWidth: crate::shader_fx::PARAMS_BUFFER_BYTES as u32,
..bd
};
let mut shader_fx_params_cb: Option<ID3D11Buffer> = None;
dev.CreateBuffer(&fx_params_bd, None, Some(&mut shader_fx_params_cb))?;
// --- 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),
footage_copy: RefCell::new(None),
shader_fx: RefCell::new(HashMap::new()),
shader_fx_tick: Cell::new(0),
shader_fx_cb: shader_fx_cb.unwrap(),
shader_fx_params_cb: shader_fx_params_cb.unwrap(),
shader_fx_blocking: Cell::new(true),
text_layer: 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;
// Les effets nouveaux partent compiler tout de suite, hors du thread de rendu : à la
// première frame qui les montre, ils sont en général déjà prêts. Après la pose de la
// scène : l'éviction épargne ce qu'elle montre.
if let Some(scene) = self.scene.borrow().as_ref() {
for effect in &scene.shader_effects {
self.shader_fx_entry(effect);
}
}
}
/// Faux pour la preview : voir `shader_fx_blocking`.
pub fn set_shader_fx_blocking(&self, on: bool) {
self.shader_fx_blocking.set(on);
}
/// Fait aboutir les compilations terminées. Vrai si un effet vient d'être prêt : la preview
/// en pause doit alors recomposer, sinon elle resterait sur la frame sans l'effet.
pub fn shader_fx_landed(&self) -> bool {
let mut landed = false;
for entry in self.shader_fx.borrow_mut().values_mut() {
let got = match &entry.state {
ShaderFx::Pending(rx) => rx.try_recv(),
_ => continue,
};
match got {
Ok(result) => {
entry.state = self.finish_shader_fx(result);
landed = true;
}
Err(std::sync::mpsc::TryRecvError::Empty) => {}
Err(std::sync::mpsc::TryRecvError::Disconnected) => entry.state = ShaderFx::Failed,
}
}
landed
}
/// La clé de cache d'`effect`, sa compilation lancée s'il est neuf, et son dernier usage noté.
/// `None` pour un contrat que ce compositeur ne connaît pas : la région ne se dessine pas.
fn shader_fx_entry(&self, effect: &SceneShaderEffect) -> Option<u64> {
if effect.contract != crate::shader_fx::CONTRACT {
return None;
}
let key = crate::shader_fx::source_hash(effect);
let tick = self.shader_fx_tick.get() + 1;
self.shader_fx_tick.set(tick);
let mut fx = self.shader_fx.borrow_mut();
fx.entry(key)
.or_insert_with(|| ShaderFxEntry {
state: ShaderFx::Pending(crate::shader_fx::spawn_compile(effect)),
used: tick,
})
.used = tick;
// Un agent qui itère crée une entrée par version : on garde les plus récentes, et toutes
// celles que la scène montre.
if fx.len() > SHADER_FX_CACHE {
let scene = self.scene.borrow();
let shown = scene.as_ref().map_or(&[][..], |s| &s.shader_effects[..]);
if let Some(oldest) = crate::shader_fx::eviction_victim(fx.iter().map(|(k, e)| (*k, e.used)), shown) {
fx.remove(&oldest);
}
}
Some(key)
}
fn finish_shader_fx(&self, result: Result<crate::shader_fx::CompiledFx, String>) -> ShaderFx {
let created = result.and_then(|c| unsafe {
let (mut vs, mut ps) = (None, None);
self.dev
.CreateVertexShader(&c.vs, None, Some(&mut vs))
.and_then(|()| self.dev.CreatePixelShader(&c.ps, None, Some(&mut ps)))
.map_err(|e| e.to_string())?;
Ok((vs.unwrap(), ps.unwrap()))
});
match created {
Ok((vs, ps)) => ShaderFx::Ready(vs, ps),
Err(e) => {
eprintln!("[shader-fx] {e}");
ShaderFx::Failed
}
}
}
/// Les shaders d'`effect`. Le compositeur d'export attend leur compilation ; la preview
/// (`shader_fx_blocking` faux) rend `None` tant qu'ils compilent. `None` aussi s'ils ont échoué.
fn shader_fx_ready(&self, effect: &SceneShaderEffect) -> Option<(ID3D11VertexShader, ID3D11PixelShader)> {
let key = self.shader_fx_entry(effect)?;
let mut fx = self.shader_fx.borrow_mut();
let entry = fx.get_mut(&key)?;
if let ShaderFx::Pending(rx) = &entry.state {
let got = if self.shader_fx_blocking.get() {
rx.recv().map_err(|e| e.to_string())
} else {
match rx.try_recv() {
Ok(result) => Ok(result),
Err(std::sync::mpsc::TryRecvError::Empty) => return None,
Err(e) => Err(e.to_string()),
}
};
entry.state = match got {
Ok(result) => self.finish_shader_fx(result),
Err(e) => {
eprintln!("[shader-fx] {e}");
ShaderFx::Failed
}
};
}
match &entry.state {
ShaderFx::Ready(vs, ps) => Some((vs.clone(), ps.clone())),
_ => None,
}
}
unsafe fn upload_bytes(&self, buf: &ID3D11Buffer, bytes: &[u8]) -> bool {
let mut m = D3D11_MAPPED_SUBRESOURCE::default();
if self.ctx.Map(buf, 0, D3D11_MAP_WRITE_DISCARD, 0, Some(&mut m)).is_err() {
return false;
}
std::ptr::copy_nonoverlapping(bytes.as_ptr(), m.pData as *mut u8, bytes.len());
self.ctx.Unmap(buf, 0);
true
}
/// Une passe d'effet sur `dst` (le RT principal, ou le calque des textes) : `dst` est copié
/// dans `ann_copy`, libre à ce stade, puis l'effet le repeint en entier.
unsafe fn apply_shader_effect(
&self,
effect: &SceneShaderEffect,
dst: (&ID3D11Texture2D, &ID3D11RenderTargetView),
cb: &crate::shader_fx::FxContext,
footage: Option<&ID3D11ShaderResourceView>,
) {
let Some((vs, ps)) = self.shader_fx_ready(effect) else { return };
let ctx_bytes = std::slice::from_raw_parts(
cb as *const crate::shader_fx::FxContext as *const u8,
std::mem::size_of::<crate::shader_fx::FxContext>(),
);
let params = crate::shader_fx::pack_params(effect);
let params_bytes = std::slice::from_raw_parts(
params.as_ptr() as *const u8,
(params.len() * 4).min(crate::shader_fx::PARAMS_BUFFER_BYTES),
);
if !self.upload_bytes(&self.shader_fx_cb, ctx_bytes)
|| !self.upload_bytes(&self.shader_fx_params_cb, params_bytes)
{
return;
}
// On ne lit pas la cible sur laquelle on dessine : copie dans `ann_copy` (les flous
// d'annotation et le cristal de Prism Glow l'ont déjà lue).
self.ctx.CopySubresourceRegion(&self.ann_copy, 0, 0, 0, 0, dst.0, 0, None);
self.ctx.OMSetRenderTargets(Some(&[Some(dst.1.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.IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
self.ctx.VSSetShader(&vs, None);
self.ctx.PSSetShader(&ps, None);
// Les registres du prélude tels que naga les sort : t0, s1, b2 (ctx), b3 (params), et t4
// pour `footage()` (rien quand l'effet ne la lit pas : une lecture y rendrait 0).
self.ctx.PSSetShaderResources(0, Some(&[Some(self.ann_copy_srv.clone())]));
self.ctx.PSSetShaderResources(4, Some(&[footage.cloned()]));
self.ctx.PSSetSamplers(1, Some(&[Some(self.sampler.clone())]));
self.ctx.PSSetConstantBuffers(
2,
Some(&[Some(self.shader_fx_cb.clone()), Some(self.shader_fx_params_cb.clone())]),
);
self.ctx.OMSetBlendState(&self.blend_none, None, 0xffffffff);
self.ctx.Draw(3, 0);
self.ctx.PSSetShaderResources(0, Some(&[None]));
self.ctx.PSSetShaderResources(4, Some(&[None]));
self.ctx.PSSetConstantBuffers(2, Some(&[None, None]));
self.bind_compose_state();
}
/// Le calque transparent des textes, à la taille de rendu, alloué à la première frame qui en a
/// besoin (un effet `ShaderEffectTarget::Text`).
unsafe fn text_layer(&self) -> Result<(ID3D11Texture2D, ID3D11RenderTargetView, ID3D11ShaderResourceView)> {
if let Some(l) = self.text_layer.borrow().as_ref() {
return Ok((l.tex.clone(), l.rtv.clone(), l.srv.clone()));
}
let mut d = D3D11_TEXTURE2D_DESC::default();
self.rt.GetDesc(&mut d);
d.BindFlags = (D3D11_BIND_RENDER_TARGET.0 | D3D11_BIND_SHADER_RESOURCE.0) as u32;
d.MiscFlags = 0;
d.CPUAccessFlags = 0;
d.Usage = D3D11_USAGE_DEFAULT;
let mut tex: Option<ID3D11Texture2D> = None;
self.dev.CreateTexture2D(&d, None, Some(&mut tex))?;
let tex = tex.ok_or_else(|| anyhow::anyhow!("CreateTexture2D (calque des textes)"))?;
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))?;
let layer = TextLayer {
tex,
rtv: rtv.ok_or_else(|| anyhow::anyhow!("RTV (calque des textes)"))?,
srv: srv.ok_or_else(|| anyhow::anyhow!("SRV (calque des textes)"))?,
};
let out = (layer.tex.clone(), layer.rtv.clone(), layer.srv.clone());
*self.text_layer.borrow_mut() = Some(layer);
Ok(out)
}
/// 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(RgbaTarget { 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())
}
/// Peint l'enregistrement à sa résolution pour `footage()` (`docs/shader-effects.md`, C.2) : la
/// coupe du métrage (`content_cut`, le repère de `fx_to_footage`) en UN draw du mode 0, comme
/// `fill_dof_pyramid`, donc par la même conversion NV12 que l'écran dessiné.
unsafe fn fill_footage_copy(
&self,
sy: &ID3D11ShaderResourceView,
suv: &ID3D11ShaderResourceView,
cut: [f32; 4],
tex_w: u32,
tex_h: u32,
) -> Result<ID3D11ShaderResourceView> {
let (w, h) = crate::shader_fx::footage_copy_px(cut, [tex_w as f32, tex_h as f32]);
let stale = self.footage_copy.borrow().as_ref().is_none_or(|c| (c.width, c.height) != (w, h));
if stale {
let desc = 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 tex: Option<ID3D11Texture2D> = None;
self.dev.CreateTexture2D(&desc, None, Some(&mut tex))?;
let tex = tex.unwrap();
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.footage_copy.borrow_mut() =
Some(RgbaTarget { rtv: rtv.unwrap(), srv: srv.unwrap(), width: w, height: h });
}
let copy = self.footage_copy.borrow();
let copy = copy.as_ref().expect("copie allouée ci-dessus");
self.bind_compose_state();
// Délie t4 : la copie y est encore liée depuis l'effet de la frame précédente, et une
// ressource liée en lecture ET en écriture est retirée d'office par le runtime.
self.ctx.PSSetShaderResources(4, Some(&[None]));
self.ctx.OMSetRenderTargets(Some(&[Some(copy.rtv.clone())]), None);
self.ctx.ClearRenderTargetView(©.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: cut,
quad_px: [w as f32, h as f32],
mode: 0.0,
color: [1.0, 1.0, 1.0, 1.0],
src_prev: cut,
dst_prev: full,
mb: [1.0, 0.0, 1.0, 0.0],
..Default::default()
},
sy,
suv,
);
self.bind_compose_state();
Ok(copy.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:#}"),
}
}
// Le verre à plat de Glass Lens (mode 19) : la copie qu'il réfracte est déjà en t5
// (`CursorPlan::glass`).
if model.is_none() {
let glass = sprite.glass.as_deref().and_then(|name| {
crate::frame_geometry::cursor_glass_cb(placement, size_px, name, a, clip, [self.rw(), self.rh()])
});
if let Some(cb) = glass {
self.draw_layer(&cb);
return Ok(Some(cb.dst));
}
}
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 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);
// La pointe et les clics récents, tels que les effets shader les lisent : ceux de
// l'enregistrement, que le curseur soit dessiné ou non (`effect_pointer`).
let mut fx_pointer = crate::frame_geometry::EffectPointer::default();
// --- 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 input = 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),
};
if scene_ref.as_ref().is_some_and(|s| !s.shader_effects.is_empty()) {
fx_pointer = crate::frame_geometry::effect_pointer(&g, &input);
}
let plan = crate::frame_geometry::plan_cursor(&g, &input).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`).
// 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 && g.webcam_shadow > 0.0 && !is_cutout && shape_fade > 0.0 {
let strength = WEBCAM_SHADOW_OPACITY * shape_fade * g.webcam_shadow;
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]));
}
}
// --- effets shader de l'agent, autour des textes selon leur cible (`docs/shader-effects.md`,
// D.1) : `image` avant les annotations et les sous-titres, `text` sur un calque des textes
// à part, `both` sur l'image finale.
let fx_inputs = crate::shader_fx::FxFrameInputs {
cursor: fx_pointer.cursor,
clicks: fx_pointer.clicks,
footage: g.footage_quad([self.rw(), self.rh()]),
footage_aspect: g.footage_aspect([self.rw(), self.rh()]),
camera: lp.has_webcam.then_some(w_dst),
};
let effects = scene_ref
.as_ref()
.map(|s| crate::shader_fx::active_effects(&s.shader_effects, source_t))
.unwrap_or_default();
let fx_context = |e: &SceneShaderEffect| {
crate::shader_fx::context(e, source_t, g.programme_t, [self.rw(), self.rh()], &fx_inputs)
};
let with_target = |target: ShaderEffectTarget| -> Vec<&SceneShaderEffect> {
effects.iter().copied().filter(|e| e.target == target).collect()
};
// L'enregistrement à sa résolution, peint une fois pour la frame si un effet le lit.
let footage = if effects.iter().any(|e| crate::shader_fx::reads_footage(e)) {
Some(self.fill_footage_copy(&sy, &suv, g.content_cut, stw, sth)?)
} else {
None
};
for e in with_target(ShaderEffectTarget::Image) {
self.apply_shader_effect(e, (&self.rt, &self.rtv), &fx_context(e), footage.as_ref());
}
// --- 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.
let text_effects = with_target(ShaderEffectTarget::Text);
if text_effects.is_empty() {
self.draw_annotations(scene_ref.as_ref(), source_t, s_ann, &g, false);
} else {
// Les textes sur un calque transparent, l'effet sur ce calque seul, puis le calque
// posé sur l'image (« over » prémultiplié) : l'image dessous reste intacte.
let (tex, rtv, srv) = self.text_layer()?;
self.bind_compose_state();
self.ctx.OMSetRenderTargets(Some(&[Some(rtv.clone())]), None);
self.ctx.ClearRenderTargetView(&rtv, &[0.0, 0.0, 0.0, 0.0]);
self.draw_annotations(scene_ref.as_ref(), source_t, s_ann, &g, false);
for e in text_effects {
self.apply_shader_effect(e, (&tex, &rtv), &fx_context(e), footage.as_ref());
}
self.ctx.OMSetRenderTargets(Some(&[Some(self.rtv.clone())]), None);
self.ctx.PSSetShaderResources(0, Some(&[Some(srv)]));
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.OMSetBlendState(&self.blend, None, 0xffffffff);
self.ctx.Draw(3, 0);
self.ctx.PSSetShaderResources(0, Some(&[None]));
self.bind_compose_state();
}
for e in with_target(ShaderEffectTarget::Both) {
self.apply_shader_effect(e, (&self.rt, &self.rtv), &fx_context(e), footage.as_ref());
}
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();
// La taille visible, comme le décodeur la pose : sans elle le métrage s'aplatit à une
// largeur nulle, et rien de ce qui s'y place (le pointeur des effets) n'y tombe.
frame.width = w as i32;
frame.height = h as i32;
(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));
}
/// Une scène à fond rouge plein, l'écran rétréci par le padding : les coins sont du fond.
fn shader_fx_scene(effects: serde_json::Value) -> Scene {
Scene::from_json(&shader_fx_json(effects).to_string()).expect("scène")
}
fn shader_fx_json(effects: serde_json::Value) -> serde_json::Value {
serde_json::json!({
"clips": [],
"layout": {"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false},
"effects": {"padding":0.5,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0},
"background": {"kind":"color","color":"#ff0000"},
"zoomRegions": [],
"cursor": {"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"},
"cropByClip": [],
"output": {"width":320,"height":180,"fps":null},
"shaderEffects": effects,
})
}
/// Un fragment d'effet de 1 s à 3 s, tel que l'app l'envoie.
fn fx(code: &str, target: &str) -> serde_json::Value {
serde_json::json!({
"clipIndex": 0, "startSec": 1.0, "endSec": 3.0, "target": target,
"contract": 1, "code": code,
"params": [{"name": "level", "type": "number"}, {"name": "tint", "type": "color"}],
"values": {"level": 1.0, "tint": [0.0, 1.0, 0.0, 1.0]},
})
}
const INVERT: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> {\n let c = frame(uv);\n return vec4<f32>(vec3<f32>(params.level) - c.rgb, 1.0);\n}\n";
const BLUE: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return vec4<f32>(0.0, 0.0, 1.0, 1.0); }";
const TINT: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return params.tint; }";
const SAME: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return frame(uv); }";
fn fx_cfg() -> crate::config::Cfg {
let mut cfg = crate::config::Cfg::c8();
cfg.bg_blur = 0.0;
cfg.mblur_n = 1;
cfg
}
/// Le pixel du coin haut-gauche (du fond) après une frame composée au temps source `t`.
fn corner_at(comp: &Compositor, gpu: &crate::d3d::Gpu, t: f32) -> [u8; 3] {
let (screen, _tex) = nv12_frame(gpu, 64, 64);
comp.set_timeline_time(Some(t));
comp.set_programme_time(Some(t));
unsafe { comp.compose_frame(&*screen, &*screen, 0.0, &fx_cfg()) }.expect("compose");
let (_, _, rgba) = unsafe { comp.readback_direct() }.expect("readback");
[rgba[0], rgba[1], rgba[2]]
}
/// Le coin à 2 s, dans la région, sous les effets donnés.
fn corner_under(effects: serde_json::Value) -> Option<[u8; 3]> {
let gpu = crate::d3d::Gpu::create_auto(false).ok()?;
let comp = Compositor::new_sized(&gpu, 320, 180).expect("compositeur");
comp.set_scene(Some(shader_fx_scene(effects)));
Some(corner_at(&comp, &gpu, 2.0))
}
/// La passe de l'agent repeint l'image composée, dans sa région et nulle part ailleurs. Le
/// compositeur par défaut est celui de l'export : il attend le shader, jamais de frame sans.
#[test]
fn a_shader_effect_repaints_the_composed_frame_inside_its_region() {
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");
comp.set_scene(Some(shader_fx_scene(serde_json::json!([fx(INVERT, "image")]))));
assert_eq!(corner_at(&comp, &gpu, 0.5), [255, 0, 0], "avant la région : le fond rouge");
assert_eq!(corner_at(&comp, &gpu, 2.0), [0, 255, 255], "dans la région : rouge inversé");
assert_eq!(corner_at(&comp, &gpu, 3.5), [255, 0, 0], "après la région : le fond rouge");
}
/// La preview ne bloque pas : elle saute l'effet tant qu'il compile, et `shader_fx_landed`
/// lui dit quand recomposer. Ensuite la frame est celle de l'export, au pixel.
#[test]
fn the_preview_shows_the_effect_once_it_landed() {
let 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");
comp.set_shader_fx_blocking(false);
comp.set_scene(Some(shader_fx_scene(serde_json::json!([fx(INVERT, "image")]))));
let start = std::time::Instant::now();
while !comp.shader_fx_landed() {
assert!(start.elapsed().as_secs() < 10, "la compilation n'a jamais abouti");
std::thread::sleep(std::time::Duration::from_millis(1));
}
eprintln!("effet prêt en {:.1} ms", start.elapsed().as_secs_f64() * 1000.0);
assert_eq!(corner_at(&comp, &gpu, 2.0), [0, 255, 255]);
}
/// Une source NV12 en colonnes d'un pixel, blanches aux x pairs, noires aux x impairs.
fn nv12_columns(gpu: &crate::d3d::Gpu, w: u32, h: u32) -> (Box<AVFrame>, ID3D11Texture2D) {
let (w_us, h_us) = (w as usize, h as usize);
let mut data = vec![128u8; w_us * h_us * 3 / 2];
for (i, y) in data[..w_us * h_us].iter_mut().enumerate() {
*y = if i % w_us % 2 == 0 { 235 } else { 16 };
}
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,
};
// Les deux plans se suivent dans les données initiales, au même pas : Y puis UV.
let init = D3D11_SUBRESOURCE_DATA { pSysMem: data.as_ptr().cast(), SysMemPitch: w, SysMemSlicePitch: 0 };
unsafe {
let mut tex: Option<ID3D11Texture2D> = None;
gpu.device.CreateTexture2D(&desc, Some(&init), 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.width = w as i32;
frame.height = h as i32;
(frame, tex)
}
}
/// `footage()` lit l'enregistrement à sa résolution, pas l'image composée : la source de 512 px
/// en colonnes d'un pixel est réduite à ~90 px sous le padding, où l'image composée ne les sépare
/// plus, mais chacune se lit blanche ou noire. Hors de 0..1, rien.
#[test]
fn footage_reads_the_recording_at_its_own_resolution() {
let Ok(gpu) = crate::d3d::Gpu::create_auto(false) else {
eprintln!("pas de device D3D11 — test sauté");
return;
};
let pixel = |code: &str| {
let comp = Compositor::new_sized(&gpu, 320, 180).expect("compositeur");
comp.set_scene(Some(shader_fx_scene(serde_json::json!([fx(code, "image")]))));
let (screen, _tex) = nv12_columns(&gpu, 512, 512);
comp.set_timeline_time(Some(2.0));
comp.set_programme_time(Some(2.0));
unsafe { comp.compose_frame(&*screen, &*screen, 0.0, &fx_cfg()) }.expect("compose");
let (_, _, rgba) = unsafe { comp.readback_direct() }.expect("readback");
[rgba[0], rgba[1], rgba[2], rgba[3]]
};
let at = |x: &str| format!("fn effect(uv: vec2<f32>) -> vec4<f32> {{ return footage(vec2<f32>({x}, 0.5)); }}");
let near = |got: [u8; 4], want: [u8; 4]| got.iter().zip(want).all(|(g, w)| g.abs_diff(w) <= 2);
let white = pixel(&at("10.5 / 512.0"));
let black = pixel(&at("11.5 / 512.0"));
assert!(near(white, [255, 255, 255, 255]), "colonne 10 : {white:?}");
assert!(near(black, [0, 0, 0, 255]), "colonne 11 : {black:?}");
assert_eq!(pixel(&at("1.5")), [0, 0, 0, 0], "hors de l'enregistrement");
// Le contrôle : l'image composée ne sépare plus deux colonnes voisines, à moitié de contraste près.
let composed = |x: &str| {
pixel(&format!("fn effect(uv: vec2<f32>) -> vec4<f32> {{ return frame(fx_from_footage(vec2<f32>({x}, 0.5))); }}"))
};
let (left, right) = (composed("10.5 / 512.0"), composed("11.5 / 512.0"));
assert!(left[0].abs_diff(right[0]) < 128, "l'image composée sépare les colonnes : {left:?} {right:?}");
}
/// La copie de l'enregistrement coûte une passe : un effet qui ne lit pas `footage()` ne la
/// fait jamais faire.
#[test]
fn an_effect_that_does_not_read_the_footage_never_paints_it() {
let 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");
comp.set_scene(Some(shader_fx_scene(serde_json::json!([fx(INVERT, "image")]))));
corner_at(&comp, &gpu, 2.0);
assert!(comp.footage_copy.borrow().is_none());
}
/// Un WGSL invalide, ou un contrat inconnu, ne casse pas le rendu : l'effet ne se dessine
/// pas, la frame reste celle de la composition.
#[test]
fn a_broken_or_unknown_effect_leaves_the_frame_untouched() {
let broken = fx("fn effect(uv: vec2<f32>) -> vec4<f32> { nope }", "image");
let mut future = fx(BLUE, "image");
future["contract"] = serde_json::json!(2);
for effect in [broken, future] {
let Some(corner) = corner_under(serde_json::json!([effect])) else { return };
assert_eq!(corner, [255, 0, 0]);
}
}
/// Les paramètres arrivent dans `params` au layout de la struct générée : la couleur `tint`
/// suit le nombre `level` dans le buffer, et se lit telle que l'app l'a écrite.
#[test]
fn a_color_parameter_reaches_the_shader() {
let Some(corner) = corner_under(serde_json::json!([fx(TINT, "image")])) else { return };
assert_eq!(corner, [0, 255, 0]);
}
/// `fx_to_footage` retrouve le point du métrage que le compositeur a dessiné sous un pixel,
/// à plat, sous un angle fixe (warp bilinéaire) et sous la caméra réelle (homographie), et
/// `fx_from_footage` le ramène sur ce pixel. En 1080p, l'arrondi 8 bits et le demi-pixel
/// tiennent sous 0,005 ; la pose orbit testée écarte l'homographie du bilinéaire de ~0,01.
#[test]
fn the_footage_plane_maps_back_to_what_the_compositor_drew() {
let Ok(gpu) = crate::d3d::Gpu::create_auto(false) else {
eprintln!("pas de device D3D11 — test sauté");
return;
};
const PLANE: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> {\n let p = fx_to_footage(uv);\n return vec4<f32>(p, distance(fx_from_footage(p), uv) * 100.0, 1.0);\n}\n";
for (rotation, projective) in [(None, false), (Some("left"), false), (Some("orbit"), true)] {
let mut json = shader_fx_json(serde_json::json!([fx(PLANE, "image")]));
json["clips"] = serde_json::json!([{"screenPath": "/s.mp4", "webcamPath": "", "sourceStartSec": 0,
"sourceEndSec": 10, "webcamOffsetSec": 0, "hasAudio": false}]);
json["layout"]["screenRect"] = serde_json::json!({"x": 0.1, "y": 0.1, "width": 0.8, "height": 0.8});
json["cropByClip"] = serde_json::json!([null]);
if let Some(rotation) = rotation {
json["zoomRegions"] = serde_json::json!([{"clipIndex": 0, "startSec": 0, "endSec": 10,
"scale": 1.5, "focusX": 0.5, "focusY": 0.5, "rotation": rotation}]);
}
let comp = Compositor::new_sized(&gpu, 1920, 1080).expect("compositeur");
let scene = Scene::from_json(&json.to_string()).expect("scène");
comp.set_live_params(live_params_from_scene(&scene));
comp.set_scene(Some(scene));
let (screen, _tex) = nv12_frame(&gpu, 64, 64);
comp.set_timeline_time(Some(2.0));
comp.set_programme_time(Some(2.0));
unsafe { comp.compose_frame(&*screen, &*screen, 0.0, &fx_cfg()) }.expect("compose");
let quad = comp.footage_quad().expect("le métrage de la frame");
assert_eq!(quad.projective, projective, "{rotation:?}");
let (w, h, rgba) = unsafe { comp.readback_direct() }.expect("readback");
let [tl, tr, br, bl] = quad.corners.map(|[x, y]| (x, y));
for (s, t) in [(0.25, 0.3), (0.7, 0.4), (0.4, 0.75)] {
let (x, y) = if projective {
crate::regions::square_to_quad(&[tl, tr, br, bl], s, t)
} else {
let top = (tl.0 + (tr.0 - tl.0) * s, tl.1 + (tr.1 - tl.1) * s);
let bottom = (bl.0 + (br.0 - bl.0) * s, bl.1 + (br.1 - bl.1) * s);
(top.0 + (bottom.0 - top.0) * t, top.1 + (bottom.1 - top.1) * t)
};
let i = ((y * h as f32) as usize * w as usize + (x * w as f32) as usize) * 4;
let got = (rgba[i] as f32 / 255.0, rgba[i + 1] as f32 / 255.0);
assert!(
(got.0 - s).abs() < 0.005 && (got.1 - t).abs() < 0.005,
"{rotation:?} ({s}, {t}) : lu {got:?}, coins {:?}",
quad.corners
);
assert!(rgba[i + 2] < 3, "{rotation:?} ({s}, {t}) : aller-retour à {}", rgba[i + 2]);
}
}
}
/// La scène de ces tests masque le curseur (`cursor.show` faux) : rien n'est dessiné, mais un
/// effet voit toujours la pointe et le clic de l'enregistrement (`effect_pointer`). Il peint
/// `ctx.cursor.z` en rouge et `ctx.clicks[0].w` en vert : jaune, il a vu les deux.
#[test]
fn a_hidden_cursor_still_hands_the_effect_its_pointer_and_clicks() {
let Ok(gpu) = crate::d3d::Gpu::create_auto(false) else {
eprintln!("pas de device D3D11 — test sauté");
return;
};
const SEES: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return vec4<f32>(ctx.cursor.z, ctx.clicks[0].w, 0.0, 1.0); }";
let comp = Compositor::new_sized(&gpu, 320, 180).expect("compositeur");
comp.set_scene(Some(shader_fx_scene(serde_json::json!([fx(SEES, "image")]))));
comp.set_cursor(crate::cursor::CursorTrack::new_with_visibility(
vec![(0.0, 0.5, 0.5), (4.0, 0.5, 0.5)],
vec![1.5],
vec![],
vec![(0.0, true)],
));
comp.set_cursor_time(Some(2.0));
assert_eq!(corner_at(&comp, &gpu, 2.0), [255, 255, 0]);
}
/// `text` ne touche que le calque des textes, posé ensuite sur l'image ; `image` et `both`
/// repeignent l'image. Sans annotation, le calque est transparent : un effet `text` qui le
/// rend tel quel laisse l'image intacte, un effet `text` opaque la recouvre.
#[test]
fn the_three_targets_keep_to_their_layer() {
let Some(image_only) = corner_under(serde_json::json!([fx(BLUE, "image")])) else { return };
assert_eq!(image_only, [0, 0, 255]);
let text_untouched = corner_under(serde_json::json!([fx(SAME, "text")])).unwrap();
assert_eq!(text_untouched, [255, 0, 0], "un calque transparent ne change pas l'image");
let text_opaque = corner_under(serde_json::json!([fx(TINT, "text")])).unwrap();
assert_eq!(text_opaque, [0, 255, 0], "le calque des textes, opaque, posé sur l'image");
let both = corner_under(serde_json::json!([fx(INVERT, "both")])).unwrap();
assert_eq!(both, [0, 255, 255], "`both` repeint l'image finale");
}
/// Calibre les paliers de coût : le surcoût par frame d'un effet qui lit `frame()` N fois,
/// à 1080p et en 4K, sur le GPU de la machine. Opt-in, comme les autres mesures :
///
/// set OPENSCREEN_FX_BENCH=1 && cargo test -p openscreen-compositor --release
/// shader_fx_tier_calibration -- --nocapture
#[test]
fn shader_fx_tier_calibration() {
if std::env::var_os("OPENSCREEN_FX_BENCH").is_none() {
eprintln!("OPENSCREEN_FX_BENCH absent — saute");
return;
}
let gpu = crate::d3d::Gpu::create_backend(crate::d3d::Backend::Hardware, false)
.expect("device D3D11");
let (screen, _tex) = nv12_frame(&gpu, 1920, 1080);
let cfg = fx_cfg();
let reads_effect = |n: u32| {
format!(
"fn effect(uv: vec2<f32>) -> vec4<f32> {{\n var acc = vec4<f32>(0.0);\n for (var i = 0; i < {n}; i++) {{\n let a = f32(i) * 2.399;\n acc += frame(uv + vec2<f32>(cos(a), sin(a)) * fx_px(f32(i)));\n }}\n return acc / {n}.0;\n}}\n"
)
};
let per_frame = |w: u32, h: u32, effects: serde_json::Value| -> f64 {
let comp = Compositor::new_sized(&gpu, w, h).expect("compositeur");
comp.set_scene(Some(shader_fx_scene(effects)));
comp.set_timeline_time(Some(2.0));
comp.set_programme_time(Some(2.0));
unsafe { comp.compose_frame(&*screen, &*screen, 0.0, &cfg) }.unwrap();
unsafe { comp.readback_direct() }.unwrap();
let n = 200;
let t0 = std::time::Instant::now();
for f in 0..n {
unsafe { comp.compose_frame(&*screen, &*screen, f as f32, &cfg) }.unwrap();
}
unsafe { comp.readback_direct() }.unwrap();
t0.elapsed().as_secs_f64() * 1000.0 / n as f64
};
for (w, h) in [(1920u32, 1080u32), (3840, 2160)] {
let base = (0..5).map(|_| per_frame(w, h, serde_json::json!([]))).fold(f64::MAX, f64::min);
for reads in [1u32, 8, 32, 128, 512] {
let code = reads_effect(reads);
let report = crate::shader_fx::analyze(&code, &[]).expect("analyse").report;
let with = (0..5)
.map(|_| per_frame(w, h, serde_json::json!([fx(&code, "image")])))
.fold(f64::MAX, f64::min);
eprintln!(
"{w}x{h} : {reads:>3} lectures ({:>10}) : +{:.3} ms/frame",
report.tier.name(),
with - base
);
}
}
}
}