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
fix(compositor): resize the preview in place instead of rebuilding the compositor
EtienneLescotb469cb596289
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex e6a655dbd..561a59a15 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -632,30 +632,7 @@ impl Compositor {multiview: None,cache: None,});- let mk_pyr = |dw: u32, dh: u32, label: &str| {- gpu.device- .create_texture(&wgpu::TextureDescriptor {- label: Some(label),- size: wgpu::Extent3d {- width: dw.max(1),- height: dh.max(1),- depth_or_array_layers: 1,- },- mip_level_count: 1,- sample_count: 1,- dimension: wgpu::TextureDimension::D2,- format: wgpu::TextureFormat::Rgba8Unorm,- usage: wgpu::TextureUsages::RENDER_ATTACHMENT- | wgpu::TextureUsages::TEXTURE_BINDING,- view_formats: &[],- })- .create_view(&wgpu::TextureViewDescriptor::default())- };- let blur_half = mk_pyr(w / 2, h / 2, "blur-half");- let blur_qtr = mk_pyr(w / 4, h / 4, "blur-qtr");- let blur_oct = mk_pyr(w / 8, h / 8, "blur-oct");- let trail_view = mk_pyr(w, h, "screen-trail");-+ let (blur_half, blur_qtr, blur_oct, trail_view) = Self::make_blur_targets(&gpu, w, h);let (rt, rt_view, accum, accum_view, readback_bpr) = Self::make_targets(&gpu, w, h);let (ann_copy, ann_copy_view, ann_copy_mips) = Self::make_ann_copy(&gpu, w, h);// Profondeur 1 par defaut = chemin synchrone historique, a l'octet et a@@ -726,6 +703,87 @@ impl Compositor {})}+ /// Le meme compositeur, rasterisant a `w`x`h` : seules les cibles qui ont la taille du+ /// rendu sont reallouees. Cf. `compositor_windows::Compositor::resized`. Ici, reconstruire+ /// le compositeur entier refaisait en plus tous les shaders et pipelines wgpu.+ ///+ /// Les rings de relecture repartent vides a leur profondeur : leurs buffers ont l'ancienne+ /// taille, comme les cibles YUV, reconstruites a la premiere demande. Une copie encore en+ /// vol est perdue, comme avec la reconstruction ; la preview n'en laisse aucune+ /// (`readback_direct` draine).+ pub fn resized(self, w: u32, h: u32) -> Result<Compositor> {+ let (w, h) = Self::normalize_render_size(w, h);+ let gpu = &self.gpu;+ let (blur_half, blur_qtr, blur_oct, trail_view) = Self::make_blur_targets(gpu, w, h);+ let (rt, rt_view, accum, accum_view, readback_bpr) = Self::make_targets(gpu, w, h);+ let (ann_copy, ann_copy_view, ann_copy_mips) = Self::make_ann_copy(gpu, w, h);+ let depth = self.readback.borrow().depth;+ let readback = RefCell::new(ReadbackRing {+ depth,+ free: (0..depth).map(|_| Self::make_staging(gpu, readback_bpr, h)).collect(),+ pending: std::collections::VecDeque::new(),+ });+ let readback_yuv = RefCell::new(ReadbackRing {+ depth: self.readback_yuv.borrow().depth,+ free: Vec::new(),+ pending: std::collections::VecDeque::new(),+ });+ Ok(Compositor {+ render_w: w,+ render_h: h,+ blur_half,+ blur_qtr,+ blur_oct,+ trail_view,+ rt,+ rt_view,+ _accum: accum,+ accum_view,+ readback_bpr,+ readback,+ yuv: RefCell::new(None),+ readback_yuv,+ ann_copy,+ ann_copy_view,+ ann_copy_mips,+ ..self+ })+ }++ /// Pyramide du blur Kawase du fond (1/2, 1/4, 1/8 du rendu) et cible de la+ /// trainee de l'ecran (pleine taille), dans cet ordre.+ fn make_blur_targets(+ gpu: &Gpu,+ w: u32,+ h: u32,+ ) -> (wgpu::TextureView, wgpu::TextureView, wgpu::TextureView, wgpu::TextureView) {+ let mk = |dw: u32, dh: u32, label: &str| {+ gpu.device+ .create_texture(&wgpu::TextureDescriptor {+ label: Some(label),+ size: wgpu::Extent3d {+ width: dw.max(1),+ height: dh.max(1),+ depth_or_array_layers: 1,+ },+ mip_level_count: 1,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: wgpu::TextureFormat::Rgba8Unorm,+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT+ | wgpu::TextureUsages::TEXTURE_BINDING,+ view_formats: &[],+ })+ .create_view(&wgpu::TextureViewDescriptor::default())+ };+ (+ mk(w / 2, h / 2, "blur-half"),+ mk(w / 4, h / 4, "blur-qtr"),+ mk(w / 8, h / 8, "blur-oct"),+ mk(w, h, "screen-trail"),+ )+ }+/// RT RGBA8, cible d'accumulation de meme geometrie, et `bytes_per_row` de/// la relecture (padde a 256).///@@ -914,12 +972,9 @@ impl Compositor {/// Un buffer de staging de la ring. La taille depend de `bpr` (donc de la/// largeur de rendu) et de la hauteur : changer la geometrie de rendu impose- /// de les reallouer -- ce que fait `new_sized`, puisque la preview- /// RECONSTRUIT le compositeur au resize (`live.rs`) au lieu de le- /// redimensionner a chaud. Aucune copie ne peut donc etre en vol au moment- /// ou la taille change : l'ancien compositeur (et sa ring) est detruit- /// entier, wgpu gardant ses buffers vivants jusqu'a la fin des soumissions- /// qui les referencent.+ /// de les reallouer -- ce que fait `resized`, qui remplace la ring entiere.+ /// L'ancienne est detruite avec ses buffers, wgpu les gardant vivants+ /// jusqu'a la fin des soumissions qui les referencent.fn make_staging(gpu: &Gpu, bpr: u32, h: u32) -> wgpu::Buffer {gpu.device.create_buffer(&wgpu::BufferDescriptor {label: Some("readback"),@@ -3903,6 +3958,29 @@ mod tests {assert_eq!(got, pattern, "la memoire exportee ne porte pas ce que wgpu y a ecrit");}+ /// Un cran de padding en format Auto change la taille de rendu de la preview. `resized`+ /// realloue les cibles et garde le reste : le masque webcam, et la boite aux lettres ou le+ /// worker de segmentation depose les suivants.+ #[test]+ fn resizing_keeps_the_segmentation_and_reads_back_at_the_new_size() {+ let Some(gpu) = gpu() else { return };+ let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");+ let (w, h) = (crate::segmentation::MODEL_WIDTH, crate::segmentation::MODEL_HEIGHT);+ comp.set_webcam_mask(&vec![255u8; (w * h) as usize], w, h).expect("masque");+ let inbox = std::sync::Arc::clone(&comp.seg_inbox);++ let comp = comp.resized(181, 321).expect("resized");++ assert_eq!(comp.render_size(), (182, 322), "arrondi au pair, comme new_sized");+ assert!(comp.webcam_mask.borrow().is_some(), "le masque webcam s'est perdu");+ assert!(+ std::sync::Arc::ptr_eq(&inbox, &comp.seg_inbox),+ "le worker deposerait ses masques dans une boite que plus personne ne lit",+ );+ let (rw, rh, rgba) = unsafe { comp.readback_direct() }.expect("readback");+ assert_eq!((rw, rh, rgba.len()), (182, 322, 182 * 322 * 4));+ }+/// La disposition NV12 doit etre EXACTEMENT celle que le pilote produit pour/// une image NV12 lineaire, parce que c'est elle qu'on decrira a VAAPI dans/// un `AVDRMFrameDescriptor`. Les valeurs ci-dessous ne sont pas devinees :diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rsindex e7bde5a05..59e871154 100644--- a/crates/compositor/src/compositor_macos.rs+++ b/crates/compositor/src/compositor_macos.rs@@ -393,6 +393,138 @@ fn make_texture(device.new_texture(&desc)}+/// Tout ce qui a la taille du rendu, et rien d'autre : ce que `new_sized` alloue et que+/// `resized` réalloue. Cf. `compositor_windows::Targets`.+struct Targets {+ rt: metal::Texture,+ rt_read: metal::Texture,+ nv12_y: metal::Texture,+ nv12_uv: metal::Texture,+ nv12_read_y: metal::Texture,+ nv12_read_uv: metal::Texture,+ accum: metal::Texture,+ trail: metal::Texture,+ blur_half: metal::Texture,+ blur_quarter: metal::Texture,+ blur_eighth: metal::Texture,+ ann_copy: metal::Texture,+}++fn make_targets(device: &metal::Device, rw: u32, rh: u32) -> Targets {+ let rt_usage = metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead;++ let rt = make_texture(+ device,+ metal::MTLPixelFormat::RGBA8Unorm,+ rw,+ rh,+ metal::MTLStorageMode::Private,+ rt_usage,+ );+ let rt_read = make_texture(+ device,+ metal::MTLPixelFormat::RGBA8Unorm,+ rw,+ rh,+ metal::MTLStorageMode::Shared,+ metal::MTLTextureUsage::ShaderRead,+ );+ let nv12_y = make_texture(+ device,+ metal::MTLPixelFormat::R8Unorm,+ rw,+ rh,+ metal::MTLStorageMode::Private,+ rt_usage,+ );+ // NV12 : le plan chroma est entrelacé ET demi-résolution dans les deux axes.+ // Le dimensionner comme le plan luma — ce que faisait la première version —+ // produisait un UV 4x trop grand, donc un `read_nv12_scaled` qui lit au-delà+ // de ce que la passe a écrit.+ let nv12_uv = make_texture(+ device,+ metal::MTLPixelFormat::RG8Unorm,+ rw / 2,+ rh / 2,+ metal::MTLStorageMode::Private,+ rt_usage,+ );+ let nv12_read_y = make_texture(+ device,+ metal::MTLPixelFormat::R8Unorm,+ rw,+ rh,+ metal::MTLStorageMode::Shared,+ metal::MTLTextureUsage::ShaderRead,+ );+ let nv12_read_uv = make_texture(+ device,+ metal::MTLPixelFormat::RG8Unorm,+ rw / 2,+ rh / 2,+ metal::MTLStorageMode::Shared,+ metal::MTLTextureUsage::ShaderRead,+ );+ let accum = make_texture(+ device,+ metal::MTLPixelFormat::RGBA8Unorm,+ rw,+ rh,+ metal::MTLStorageMode::Private,+ rt_usage,+ );+ let trail = make_texture(+ device,+ metal::MTLPixelFormat::RGBA8Unorm,+ rw,+ rh,+ metal::MTLStorageMode::Private,+ rt_usage,+ );+ let mut pyramid = [2u32, 4, 8].map(|d| {+ make_texture(+ device,+ metal::MTLPixelFormat::RGBA8Unorm,+ (rw / d).max(1),+ (rh / d).max(1),+ metal::MTLStorageMode::Private,+ rt_usage,+ )+ });+ let blur_eighth = pyramid[2].clone();+ let blur_quarter = pyramid[1].clone();+ let blur_half = std::mem::replace(&mut pyramid[0], blur_quarter.clone());+ let ann_copy = {+ let d = metal::TextureDescriptor::new();+ d.set_texture_type(metal::MTLTextureType::D2);+ d.set_pixel_format(metal::MTLPixelFormat::RGBA8Unorm);+ d.set_width(rw as u64);+ d.set_height(rh as u64);+ d.set_storage_mode(metal::MTLStorageMode::Private);+ d.set_usage(rt_usage);+ // Assez de niveaux pour que `log2(rayon)` du mode 10 en trouve toujours un.+ d.set_mipmap_level_count(+ (32 - rw.max(rh).max(1).leading_zeros()).max(1) as u64,+ );+ device.new_texture(&d)+ };++ Targets {+ rt,+ rt_read,+ nv12_y,+ nv12_uv,+ nv12_read_y,+ nv12_read_uv,+ accum,+ trail,+ blur_half,+ blur_quarter,+ blur_eighth,+ ann_copy,+ }+}+/// Comment un draw se mélange à ce qui est déjà dans la cible.#[derive(Clone, Copy, PartialEq)]enum Blend {@@ -468,60 +600,20 @@ impl Compositor {let cache = CVMetalTextureCache::new(gpu.device.as_ptr() as *const std::ffi::c_void)?;let device = &gpu.device;- let rt_usage = metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead;-- let rt = make_texture(- device,- metal::MTLPixelFormat::RGBA8Unorm,- rw,- rh,- metal::MTLStorageMode::Private,- rt_usage,- );- let rt_read = make_texture(- device,- metal::MTLPixelFormat::RGBA8Unorm,- rw,- rh,- metal::MTLStorageMode::Shared,- metal::MTLTextureUsage::ShaderRead,- );- let nv12_y = make_texture(- device,- metal::MTLPixelFormat::R8Unorm,- rw,- rh,- metal::MTLStorageMode::Private,- rt_usage,- );- // NV12 : le plan chroma est entrelacé ET demi-résolution dans les deux axes.- // Le dimensionner comme le plan luma — ce que faisait la première version —- // produisait un UV 4x trop grand, donc un `read_nv12_scaled` qui lit au-delà- // de ce que la passe a écrit.- let nv12_uv = make_texture(- device,- metal::MTLPixelFormat::RG8Unorm,- rw / 2,- rh / 2,- metal::MTLStorageMode::Private,- rt_usage,- );- let nv12_read_y = make_texture(- device,- metal::MTLPixelFormat::R8Unorm,- rw,- rh,- metal::MTLStorageMode::Shared,- metal::MTLTextureUsage::ShaderRead,- );- let nv12_read_uv = make_texture(- device,- metal::MTLPixelFormat::RG8Unorm,- rw / 2,- rh / 2,- metal::MTLStorageMode::Shared,- metal::MTLTextureUsage::ShaderRead,- );+ let Targets {+ rt,+ rt_read,+ nv12_y,+ nv12_uv,+ nv12_read_y,+ nv12_read_uv,+ accum,+ trail,+ blur_half,+ blur_quarter,+ blur_eighth,+ ann_copy,+ } = make_targets(device, rw, rh);// --- Compilation MSL ---let msl_source = include_str!("shaders.metal");@@ -569,35 +661,6 @@ impl Compositor {metal::MTLPixelFormat::RGBA8Unorm,Blend::Add,)?;- let accum = make_texture(- device,- metal::MTLPixelFormat::RGBA8Unorm,- rw,- rh,- metal::MTLStorageMode::Private,- rt_usage,- );- let trail = make_texture(- device,- metal::MTLPixelFormat::RGBA8Unorm,- rw,- rh,- metal::MTLStorageMode::Private,- rt_usage,- );- let mut pyramid = [2u32, 4, 8].map(|d| {- make_texture(- device,- metal::MTLPixelFormat::RGBA8Unorm,- (rw / d).max(1),- (rh / d).max(1),- metal::MTLStorageMode::Private,- rt_usage,- )- });- let blur_eighth = pyramid[2].clone();- let blur_quarter = pyramid[1].clone();- let blur_half = std::mem::replace(&mut pyramid[0], blur_quarter.clone());let pipeline_kdown = make_pipeline(device, &library, "vs_fs", "ps_kawase_down",metal::MTLPixelFormat::RGBA8Unorm, Blend::Replace,@@ -606,20 +669,6 @@ impl Compositor {device, &library, "vs_fs", "ps_kawase_up",metal::MTLPixelFormat::RGBA8Unorm, Blend::Replace,)?;- let ann_copy = {- let d = metal::TextureDescriptor::new();- d.set_texture_type(metal::MTLTextureType::D2);- d.set_pixel_format(metal::MTLPixelFormat::RGBA8Unorm);- d.set_width(rw as u64);- d.set_height(rh as u64);- d.set_storage_mode(metal::MTLStorageMode::Private);- d.set_usage(rt_usage);- // Assez de niveaux pour que `log2(rayon)` du mode 10 en trouve toujours un.- d.set_mipmap_level_count(- (32 - rw.max(rh).max(1).leading_zeros()).max(1) as u64,- );- device.new_texture(&d)- };Ok(Compositor {gpu: Gpu {@@ -678,6 +727,44 @@ impl Compositor {})}+ /// Le même compositeur, rastérisant à `w`×`h` : seules les cibles (`Targets`) sont+ /// réallouées. Cf. `compositor_windows::Compositor::resized`. Ici, reconstruire le+ /// compositeur entier recompilait en plus `shaders.metal`.+ pub fn resized(self, w: u32, h: u32) -> Result<Compositor> {+ let (rw, rh) = Self::normalize_render_size(w, h);+ let Targets {+ rt,+ rt_read,+ nv12_y,+ nv12_uv,+ nv12_read_y,+ nv12_read_uv,+ accum,+ trail,+ blur_half,+ blur_quarter,+ blur_eighth,+ ann_copy,+ } = make_targets(&self.gpu.device, rw, rh);+ Ok(Compositor {+ render_w: rw,+ render_h: rh,+ rt,+ rt_read,+ nv12_y,+ nv12_uv,+ nv12_read_y,+ nv12_read_uv,+ accum,+ trail,+ blur_half,+ blur_quarter,+ blur_eighth,+ ann_copy,+ ..self+ })+ }+/// Arrondit `(w, h)` au multiple de 2 supérieur — nécessaire pour NV12 4:2:0.pub fn normalize_render_size(w: u32, h: u32) -> (u32, u32) {((w.max(1) + 1) & !1, (h.max(1) + 1) & !1)@@ -4170,4 +4257,30 @@ mod tests {let comp = super::Compositor::new_sized(&gpu, 640, 360).expect("Compositor::new_sized");assert_eq!(comp.render_size(), (640, 360));}++ /// 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(false) else {+ eprintln!("pas de device Metal — test sauté");+ return;+ };+ let comp = super::Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");+ let (w, h) = (crate::segmentation::MODEL_WIDTH, crate::segmentation::MODEL_HEIGHT);+ comp.set_webcam_mask(&vec![255u8; (w * h) as usize], w, h).expect("masque");+ let inbox = std::sync::Arc::clone(&comp.seg_inbox);++ let comp = comp.resized(181, 321).expect("resized");++ assert_eq!(comp.render_size(), (182, 322), "arrondi au pair, comme new_sized");+ assert!(comp.webcam_mask.borrow().is_some(), "le masque webcam s'est perdu");+ assert!(+ std::sync::Arc::ptr_eq(&inbox, &comp.seg_inbox),+ "le worker 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));+ }}diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rsindex 69567a620..77b2713dc 100644--- a/crates/compositor/src/compositor_windows.rs+++ b/crates/compositor/src/compositor_windows.rs@@ -257,6 +257,33 @@ struct ResizeTarget {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,+}+@@ -288,10 +315,8 @@ impl Compositor {/// 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 un événement qui n'arrive quasiment jamais- /// (l'utilisateur change de ratio, ou on bascule preview↔export). L'appelant- /// reconstruit le compositeur quand la sortie change ; c'est quelques dizaines- /// de ms, sur un changement rare.+ /// 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@@ -315,10 +340,72 @@ impl Compositor {(((w.max(2) + 1) & !1), ((h.max(2) + 1) & !1))}- unsafe fn new_inner(gpu: &Gpu, out_w: u32, out_h: u32) -> Result<Compositor> {- let dev = gpu.device.clone();- let ctx = gpu.context.clone();+ /// 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),+ live_readback_staging: RefCell::new(None),+ nv12_readback_staging: RefCell::new(None),+ ..self+ })+ }+ unsafe fn make_targets(dev: &ID3D11Device, out_w: u32, out_h: u32) -> Result<Targets> {// --- render target RGBA8 (gamma natif de la vidéo ; voir note couleur docs) ---let mut td = D3D11_TEXTURE2D_DESC {Width: out_w,@@ -347,65 +434,6 @@ impl Compositor {let mut staging: Option<ID3D11Texture2D> = None;dev.CreateTexture2D(&td, None, Some(&mut staging))?;- // --- 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))?;-- // shaders RGB->NV12- let mut vs_fs: Option<ID3D11VertexShader> = None;- dev.CreateVertexShader(shader!("vs_fs"), None, Some(&mut vs_fs))?;- let mut ps_y: Option<ID3D11PixelShader> = None;- dev.CreatePixelShader(shader!("ps_y"), None, Some(&mut ps_y))?;- let mut ps_uv: Option<ID3D11PixelShader> = None;- dev.CreatePixelShader(shader!("ps_uv"), None, Some(&mut ps_uv))?;-- // --- sampler bilinéaire clamp ---- let sd = D3D11_SAMPLER_DESC {- Filter: D3D11_FILTER_MIN_MAG_MIP_LINEAR,- AddressU: D3D11_TEXTURE_ADDRESS_CLAMP,- AddressV: D3D11_TEXTURE_ADDRESS_CLAMP,- AddressW: D3D11_TEXTURE_ADDRESS_CLAMP,- ComparisonFunc: D3D11_COMPARISON_NEVER,- MaxLOD: f32::MAX,- ..Default::default()- };- let mut sampler: Option<ID3D11SamplerState> = None;- dev.CreateSamplerState(&sd, Some(&mut sampler))?;-- // --- constant buffer dynamique ---- let bd = D3D11_BUFFER_DESC {- ByteWidth: std::mem::size_of::<LayerCB>() as u32,- Usage: D3D11_USAGE_DYNAMIC,- BindFlags: D3D11_BIND_CONSTANT_BUFFER.0 as u32,- CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,- ..Default::default()- };- let mut cbuf: Option<ID3D11Buffer> = None;- dev.CreateBuffer(&bd, None, Some(&mut cbuf))?;-- // --- blend alpha prémultiplié ---- let mut bl = D3D11_BLEND_DESC::default();- bl.RenderTarget[0] = D3D11_RENDER_TARGET_BLEND_DESC {- BlendEnable: true.into(),- SrcBlend: D3D11_BLEND_ONE,- DestBlend: D3D11_BLEND_INV_SRC_ALPHA,- BlendOp: D3D11_BLEND_OP_ADD,- SrcBlendAlpha: D3D11_BLEND_ONE,- DestBlendAlpha: D3D11_BLEND_INV_SRC_ALPHA,- BlendOpAlpha: D3D11_BLEND_OP_ADD,- RenderTargetWriteMask: D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8,- };- let mut blend: Option<ID3D11BlendState> = None;- dev.CreateBlendState(&bl, Some(&mut blend))?;-- // blend désactivé mais écriture ACTIVE (le défaut a WriteMask=0 -> rien n'est écrit)- let mut bl_none = D3D11_BLEND_DESC::default();- bl_none.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8;- let mut blend_none: Option<ID3D11BlendState> = None;- dev.CreateBlendState(&bl_none, Some(&mut blend_none))?;-// 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 {@@ -438,18 +466,6 @@ impl Compositor {let rtv_y = mk_rtv(DXGI_FORMAT_R8_UNORM)?;let rtv_uv = mk_rtv(DXGI_FORMAT_R8G8_UNORM)?;- // 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))?;-// 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 {@@ -483,7 +499,7 @@ impl Compositor {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) + blend additif pondéré (facteur = 1/N)+ // accumulateur pleine réso (RGBA)let ad = D3D11_TEXTURE2D_DESC {Width: out_w,Height: out_h,@@ -520,6 +536,132 @@ impl Compositor {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))?;++ // shaders RGB->NV12+ let mut vs_fs: Option<ID3D11VertexShader> = None;+ dev.CreateVertexShader(shader!("vs_fs"), None, Some(&mut vs_fs))?;+ let mut ps_y: Option<ID3D11PixelShader> = None;+ dev.CreatePixelShader(shader!("ps_y"), None, Some(&mut ps_y))?;+ let mut ps_uv: Option<ID3D11PixelShader> = None;+ dev.CreatePixelShader(shader!("ps_uv"), None, Some(&mut ps_uv))?;++ // --- sampler bilinéaire clamp ---+ let sd = D3D11_SAMPLER_DESC {+ Filter: D3D11_FILTER_MIN_MAG_MIP_LINEAR,+ AddressU: D3D11_TEXTURE_ADDRESS_CLAMP,+ AddressV: D3D11_TEXTURE_ADDRESS_CLAMP,+ AddressW: D3D11_TEXTURE_ADDRESS_CLAMP,+ ComparisonFunc: D3D11_COMPARISON_NEVER,+ MaxLOD: f32::MAX,+ ..Default::default()+ };+ let mut sampler: Option<ID3D11SamplerState> = None;+ dev.CreateSamplerState(&sd, Some(&mut sampler))?;++ // --- constant buffer dynamique ---+ let bd = D3D11_BUFFER_DESC {+ ByteWidth: std::mem::size_of::<LayerCB>() as u32,+ Usage: D3D11_USAGE_DYNAMIC,+ BindFlags: D3D11_BIND_CONSTANT_BUFFER.0 as u32,+ CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,+ ..Default::default()+ };+ let mut cbuf: Option<ID3D11Buffer> = None;+ dev.CreateBuffer(&bd, None, Some(&mut cbuf))?;++ // --- blend alpha prémultiplié ---+ let mut bl = D3D11_BLEND_DESC::default();+ bl.RenderTarget[0] = D3D11_RENDER_TARGET_BLEND_DESC {+ BlendEnable: true.into(),+ SrcBlend: D3D11_BLEND_ONE,+ DestBlend: D3D11_BLEND_INV_SRC_ALPHA,+ BlendOp: D3D11_BLEND_OP_ADD,+ SrcBlendAlpha: D3D11_BLEND_ONE,+ DestBlendAlpha: D3D11_BLEND_INV_SRC_ALPHA,+ BlendOpAlpha: D3D11_BLEND_OP_ADD,+ RenderTargetWriteMask: D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8,+ };+ let mut blend: Option<ID3D11BlendState> = None;+ dev.CreateBlendState(&bl, Some(&mut blend))?;++ // blend désactivé mais écriture ACTIVE (le défaut a WriteMask=0 -> rien n'est écrit)+ let mut bl_none = D3D11_BLEND_DESC::default();+ bl_none.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8;+ let mut blend_none: Option<ID3D11BlendState> = None;+ dev.CreateBlendState(&bl_none, Some(&mut blend_none))?;++ // shaders de flou + copie+ let mut ps_blur: Option<ID3D11PixelShader> = None;+ dev.CreatePixelShader(shader!("ps_blur"), None, Some(&mut ps_blur))?;+ let mut ps_tex: Option<ID3D11PixelShader> = None;+ dev.CreatePixelShader(shader!("ps_tex"), None, Some(&mut ps_tex))?;++ // shaders dual-Kawase+ let mut ps_kdown: Option<ID3D11PixelShader> = None;+ dev.CreatePixelShader(shader!("ps_kawase_down"), None, Some(&mut ps_kdown))?;+ let mut ps_kup: Option<ID3D11PixelShader> = None;+ dev.CreatePixelShader(shader!("ps_kawase_up"), None, Some(&mut ps_kup))?;++ // blend additif pondéré (facteur = 1/N) de l'accumulateurlet mut bla = D3D11_BLEND_DESC::default();bla.RenderTarget[0] = D3D11_RENDER_TARGET_BLEND_DESC {BlendEnable: true.into(),@@ -538,9 +680,9 @@ impl Compositor {dev,ctx,rt,- rtv: rtv.unwrap(),- rt_srv: rt_srv.unwrap(),- staging: staging.unwrap(),+ rtv,+ rt_srv,+ staging,vs: vs.unwrap(),ps: ps.unwrap(),vs_fs: vs_fs.unwrap(),@@ -566,10 +708,10 @@ impl Compositor {e_rtv,e_srv,ann_copy,- ann_copy_srv: ann_copy_srv.unwrap(),+ ann_copy_srv,accum,- accum_rtv: accum_rtv.unwrap(),- accum_srv: accum_srv.unwrap(),+ accum_rtv,+ accum_srv,blend_add: blend_add.unwrap(),trail_rtv,trail_srv,@@ -3088,4 +3230,30 @@ mod tests {cumule / 1048576);}++ /// 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));+ }}diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rsindex 4243a33d0..9114ff0f4 100644--- a/crates/compositor/src/live.rs+++ b/crates/compositor/src/live.rs@@ -1522,14 +1522,15 @@ unsafe fn render_thread(cursor_path,),}+ // Sans relecture, rien à reposer : un changement de taille garde le+ // curseur (`Compositor::resized`), et le relisser parcourt tout+ // l'enregistrement à chaque bascule d'un scrub.+ match &raw_cursor {+ Some(track) => comp.set_cursor(track.smoothed(0.0)),+ None => comp.clear_cursor(),+ }+ last_smoothing = -1.0;}- // Appliqué à chaque fois, y compris sans relecture : le compositeur peut- // avoir été reconstruit (changement de taille) et perdu son curseur.- match &raw_cursor {- Some(track) => comp.set_cursor(track.smoothed(0.0)),- None => comp.clear_cursor(),- }- last_smoothing = -1.0;clip_changed = true;}Err(e) => eprintln!("[live] set_active_clip: {e:#}"),@@ -1617,19 +1618,14 @@ unsafe fn render_thread(last_preview_size = (pw, ph);// Le compositeur rastérise à la géométrie de SORTIE (ramenée à la taille du- // canvas) et non plus dans un canvas 16:9 figé. Quand cette géométrie change- // — l'utilisateur change de ratio, ou redimensionne le panneau — on- // reconstruit le compositeur. Voir `Compositor::new_sized` pour le choix- // "reconstruire" plutôt que "redimensionner à chaud".+ // canvas) et non plus dans un canvas 16:9 figé. Cette géométrie change quand+ // l'utilisateur change de ratio, redimensionne le panneau, ou bouge le padding+ // d'un format Auto, dont la forme suit chaque cran. Seules les cibles du+ // compositeur sont alors réallouées (`Compositor::resized`) : scène, params,+ // curseur et segmentation webcam restent posés, donc rien à réappliquer.let want = preview_render_size(full_scene.as_ref(), pw, ph);if want != comp.render_size() {- comp = Compositor::new_sized(&gpu, want.0, want.1)?;- // Le compositeur neuf est vierge : on repasse par les mécanismes- // d'invalidation existants plutôt que de recopier l'état à la main —- // une seule façon d'appliquer la scène, les params et le curseur.- shared.scene_dirty.store(true, Ordering::Relaxed);- last_ip = None;- last_smoothing = -1.0;+ comp = comp.resized(want.0, want.1)?;first = true;continue;}