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
perf(compositor): copy a static background instead of redrawing it on Linux
Etienne Lescotcafcdb666c21
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex d672f4f8a..06766e47f 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -101,6 +101,13 @@ struct BgDraw {bind: wgpu::BindGroup,}+/// Le fond tel que la passe 1 (et son flou) l'a laisse dans le RT, et tout ce qui l'a decide+/// (`key`, cf. `compose_frame`).+struct BgCache {+ key: Vec<u8>,+ tex: wgpu::Texture,+}+/// Une copie RT -> staging DEJA SOUMISE, dont le mapping est arme mais pas/// encore recolte. On garde `idx` (l'index de soumission rendu par/// `Queue::submit`) pour n'attendre QUE cette soumission-la, et les dimensions@@ -364,6 +371,9 @@ pub struct Compositor {/// touche depuis appartient au jeu actif et ne peut pas etre evince -- voir/// `cached_image`.img_frame_start: std::cell::Cell<u64>,+ /// Le dernier fond fixe compose. Un fond qui ne bouge pas est le meme a chaque frame : on le+ /// recopie au lieu de le redessiner (passe 1 de `compose_frame`).+ bg_cache: RefCell<Option<BgCache>>,/// Champs de distance des sprites de curseur (mode 15), R16F, par chemin, avec leur forme./// Pas d'eviction : seuls les sprites du theme en cours y passent (~2,6 Mo pour les seize).sdf_cache: RefCell<std::collections::HashMap<String, (wgpu::Texture, SpriteShape)>>,@@ -739,6 +749,7 @@ impl Compositor {sdf_cache: RefCell::new(std::collections::HashMap::new()),img_tick: std::cell::Cell::new(0),img_frame_start: std::cell::Cell::new(0),+ bg_cache: RefCell::new(None),ann_copy,ann_copy_view,ann_copy_mips,@@ -799,6 +810,7 @@ impl Compositor {ann_copy,ann_copy_view,ann_copy_mips,+ bg_cache: RefCell::new(None),..self})}@@ -867,7 +879,8 @@ impl Compositor {view_formats: &[],})};- let rt = mk("rt", wgpu::TextureUsages::COPY_SRC);+ // COPY_DST : le fond fixe y est recopie (`bg_cache`).+ let rt = mk("rt", wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST);let accum = mk("accum", wgpu::TextureUsages::empty());let rt_view = rt.create_view(&wgpu::TextureViewDescriptor::default());let accum_view = accum.create_view(&wgpu::TextureViewDescriptor::default());@@ -2353,8 +2366,37 @@ impl Compositor {)});+ // Tout ce qui decide du fond -- clear, calque, flou, taille -- ou `None` s'il bouge (fond+ // anime). Meme cle qu'a la frame d'avant : le fond est celui qu'elle a laisse, a l'octet+ // pres, et la passe 1 le recopie au lieu de le redessiner. Redessine, il coutait 1,7 ms+ // par frame 1080p sur une Radeon 610M (une image 4K echantillonnee sans mips), soit plus+ // que l'ecran lui-meme ; recopie, quelques dixiemes.+ let bg_key = match &bg_layer {+ None => Some(vec![0u8]),+ Some(BgLayer::Gradient(cb)) => (cb.fx[3] == 0.0).then(|| {+ let mut k = vec![1u8];+ k.extend_from_slice(layer_bytes(cb));+ k+ }),+ Some(BgLayer::Image(path, motion)) => (*motion == WallpaperMotion::None).then(|| {+ let mut k = vec![2u8];+ k.extend_from_slice(path.as_bytes());+ k+ }),+ }+ .map(|mut k| {+ for v in bg_clear.into_iter().chain([cfg.bg_blur, rw, rh]) {+ k.extend_from_slice(&v.to_le_bytes());+ }+ k+ });+ let bg_cached = bg_key+ .as_ref()+ .is_some_and(|k| self.bg_cache.borrow().as_ref().is_some_and(|c| c.key == *k));+ let bg_wanted = bg_layer.is_some();+// Fond (gradient mode 5 OU image mode 6), dessine dans la passe de fond.- let bg_draw = bg_layer.and_then(|bl| match bl {+ let bg_draw = bg_layer.filter(|_| !bg_cached).and_then(|bl| match bl {BgLayer::Gradient(cb) => {let (buf, bind) = self.make_bind(&cb, None, &dummy);Some(BgDraw { _buf: buf, _tex: None, _view: None, bind })@@ -3141,35 +3183,66 @@ impl Compositor {rpass.set_pipeline(&self.pipeline);self.draw_screen_group(&mut rpass, &screen_shadow, &window_frame, &screen_bind, &device_frame);}- // Passe 1 : fond (clear a `bg_clear` + gradient mode 5 eventuel).- {- let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {- label: Some("bg-pass"),- color_attachments: &[Some(wgpu::RenderPassColorAttachment {- view: &self.rt_view,- resolve_target: None,- ops: wgpu::Operations {- load: wgpu::LoadOp::Clear(wgpu::Color {- r: bg_clear[0] as f64,- g: bg_clear[1] as f64,- b: bg_clear[2] as f64,- a: bg_clear[3] as f64,- }),- store: wgpu::StoreOp::Store,- },- })],- depth_stencil_attachment: None,- timestamp_writes: None,- occlusion_query_set: None,- });- if let Some(bg) = &bg_draw {- rpass.set_pipeline(&self.pipeline);- rpass.set_bind_group(0, &bg.bind, &[]);- rpass.draw(0..4, 0..1);+ // Passe 1 : fond (clear a `bg_clear` + gradient mode 5 eventuel) puis son flou -- ou, s'il+ // n'a pas change (`bg_key`), la copie qu'en a gardee la frame d'avant.+ let extent = wgpu::Extent3d {+ width: self.render_w,+ height: self.render_h,+ depth_or_array_layers: 1,+ };+ if bg_cached {+ let cache = self.bg_cache.borrow();+ let tex = &cache.as_ref().expect("bg_cached").tex;+ encoder.copy_texture_to_texture(tex.as_image_copy(), self.rt.as_image_copy(), extent);+ } else {+ {+ let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("bg-pass"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: &self.rt_view,+ resolve_target: None,+ ops: wgpu::Operations {+ load: wgpu::LoadOp::Clear(wgpu::Color {+ r: bg_clear[0] as f64,+ g: bg_clear[1] as f64,+ b: bg_clear[2] as f64,+ a: bg_clear[3] as f64,+ }),+ store: wgpu::StoreOp::Store,+ },+ })],+ depth_stencil_attachment: None,+ timestamp_writes: None,+ occlusion_query_set: None,+ });+ if let Some(bg) = &bg_draw {+ rpass.set_pipeline(&self.pipeline);+ rpass.set_bind_group(0, &bg.bind, &[]);+ rpass.draw(0..4, 0..1);+ }+ }+ // Blur du fond (avant l'ecran), si active par la scene/l'inspector.+ self.blur_bg(&mut encoder, cfg.bg_blur);+ // Pas de cache pour un fond qui n'a pas pu se charger : la frame suivante reessaie.+ if let Some(key) = bg_key.filter(|_| bg_draw.is_some() == bg_wanted) {+ let mut cache = self.bg_cache.borrow_mut();+ let tex = match cache.take() {+ Some(c) if c.tex.size() == extent => c.tex,+ _ => self.gpu.device.create_texture(&wgpu::TextureDescriptor {+ label: Some("bg-cache"),+ size: extent,+ mip_level_count: 1,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: wgpu::TextureFormat::Rgba8Unorm,+ usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST,+ view_formats: &[],+ }),+ };+ encoder.copy_texture_to_texture(self.rt.as_image_copy(), tex.as_image_copy(), extent);+ *cache = Some(BgCache { key, tex });}}- // Blur du fond (avant l'ecran), si active par la scene/l'inspector.- self.blur_bg(&mut encoder, cfg.bg_blur);// Passe 2 : l'ecran, compose par-dessus le fond (eventuellement floute) avec// `LoadOp::Load`. Puis les flous de confidentialite, le curseur, la camera et les autres// annotations, dans cet ordre : celui de Windows et macOS.@@ -5389,6 +5462,66 @@ mod tests {assert!(right[2] > 200 && right[0] < 60 && right[1] < 60, "droite {right:?} : bleu attendu");}+ /// Le fond fixe est recopie d'une frame a l'autre (`bg_cache`) au lieu d'etre redessine, et+ /// un fond qui change ne laisse rien du precedent : un compositeur qui a rendu A, A, B puis A+ /// rend chacun a l'octet comme un compositeur neuf. Un fond anime n'est jamais repris.+ #[test]+ fn a_static_background_is_reused_and_a_changed_one_redrawn() {+ let Some(gpu) = gpu() else { return };+ let screen = FakeFrame::new(&gpu, 640, 360, |_, _| 60);+ let webcam = FakeFrame::new(&gpu, 64, 64, |_, _| 60);+ let render = |comp: &Compositor, background: &str| {+ let json = format!(+ r##"{{"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],+ "layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded",+ "webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false,+ "screenRect":{{"x":0.3,"y":0.3,"width":0.4,"height":0.4}}}},+ "effects":{{"padding":0.4,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},+ "background":{background},+ "zoomRegions":[],"annotations":[],+ "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,+ "clipToBounds":false,"theme":"default"}},+ "cropByClip":[null],+ "output":{{"width":640,"height":360,"fps":30}}}}"##+ );+ let scene = Scene::from_json(&json).expect("scene json");+ comp.set_live_params(live_params_from_scene(&scene));+ comp.set_has_webcam(false);+ comp.set_scene(Some(scene));+ let mut cfg = Cfg::c8();+ cfg.bg_blur = 0.0;+ cfg.zoom = false;+ cfg.layout_anim = false;+ cfg.cursor = false;+ cfg.shadow = false;+ cfg.mblur_n = 1;+ unsafe {+ comp.compose_frame(screen.as_ptr(), webcam.as_ptr(), 0.0, &cfg)+ .expect("compose_frame");+ comp.readback_direct().expect("readback_direct").2+ }+ };+ let fresh = || Compositor::new_sized(&gpu, 640, 360).expect("Compositor::new_sized");+ let a = r##"{"kind":"gradient","angleDeg":90,"stops":["rgb(255, 0, 0)","rgb(0, 0, 255)"],"offsets":[0,1]}"##;+ let b = r##"{"kind":"color","color":"#00ff00"}"##;++ let comp = fresh();+ let a1 = render(&comp, a);+ assert!(comp.bg_cache.borrow().is_some(), "un fond fixe doit etre garde");+ let a2 = render(&comp, a);+ let b1 = render(&comp, b);+ let a3 = render(&comp, a);+ assert!(a1 == a2, "le fond recopie doit etre celui qui a ete dessine");+ assert!(b1 == render(&fresh(), b), "un autre fond ne doit rien garder du precedent");+ assert!(a3 == a1, "revenir au premier fond doit le redessiner a l'identique");+ assert!(a1 != b1, "garde : les deux fonds different");++ let aurora = r##"{"kind":"gradient","angleDeg":90,"stops":["rgb(255, 0, 0)","rgb(0, 0, 255)"],"offsets":[0,1],"motion":"aurora"}"##;+ let comp = fresh();+ render(&comp, aurora);+ assert!(comp.bg_cache.borrow().is_none(), "un fond anime ne doit pas etre garde");+ }+/// Le cadre de fenetre (mode 14) se dessine sur Linux comme ailleurs : `"none"` rend/// l'image d'avant a l'octet, le theme clair ajoute une barre claire, droite comme/// inclinee, et les deux themes different. `OPENSCREEN_FRAME_OUT` recoit les PNG.