Skip to content

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

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.rs
index 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.rs
index 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.rs
index 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'accumulateur
let 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.rs
index 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;
}