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(preview): never rewrite a shared slot Chromium still holds
EtienneLescot7619e5f56a36
diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rsindex 8fd6a29e0..912741b2c 100644--- a/crates/compositor/src/live.rs+++ b/crates/compositor/src/live.rs@@ -1897,7 +1897,7 @@ unsafe fn render_thread(enum SharedPublish {/// Posée dans une case de l'anneau.Published,- /// Chromium tient toutes les cases : frame sautée.+ /// Chromium tient toutes les cases : la frame attend dans le RT qu'il en relâche une.NoFreeSlot,/// Transport partagé coupé ou indisponible : la frame repasse par le readback.Off,@@ -1940,12 +1940,17 @@ unsafe fn publish_shared(let Some(ring) = ring.as_mut() else {return SharedPublish::Off;};- let claimed = shared- .slot_book- .lock()- .ok()- .and_then(|mut book| book.claim(crate::shared_frames::RING_SLOTS, Instant::now()));+ let (claimed, lost) = match shared.slot_book.lock() {+ Ok(mut book) => (book.claim(crate::shared_frames::RING_SLOTS), book.lost(Instant::now())),+ Err(_) => (None, false),+ };let Some(slot) = claimed else {+ // Chromium relâche d'ordinaire une case dans la milliseconde. Une case perdue ne+ // reviendra plus : la réécrire déchirerait peut-être une image qu'il lit encore, et+ // l'attendre figerait la preview.+ if lost {+ return turn_off("une case jamais relâchée par Chromium".into());+ }return SharedPublish::NoFreeSlot;};let (width, height) = comp.render_size();diff --git a/crates/compositor/src/shared_frames.rs b/crates/compositor/src/shared_frames.rsindex bf0e1763a..421897131 100644--- a/crates/compositor/src/shared_frames.rs+++ b/crates/compositor/src/shared_frames.rs@@ -20,8 +20,8 @@ use std::time::{Duration, Instant};pub const RING_SLOTS: u32 = 4;/// Une case tenue plus longtemps que ça a perdu sa libération (renderer rechargé, import-/// échoué en route) : elle est reprise plutôt que de laisser l'anneau se vider et la preview-/// se figer. Même ordre que le délai d'Electron sur `sendSharedTexture` (1 s).+/// échoué en route) : Chromium relâche les autres dans la milliseconde. Même ordre que le+/// délai d'Electron sur `sendSharedTexture` (1 s).pub const LOST_SLOT_AFTER: Duration = Duration::from_secs(1);/// Une frame composée posée dans une case de l'anneau, telle que JS la reçoit.@@ -58,10 +58,10 @@ pub struct SlotBook {impl SlotBook {/// La case où écrire la prochaine frame. Une case libre d'abord ; à défaut, celle de la- /// frame prête que personne n'a prise, retirée puisqu'elle est périmée ; à défaut, une- /// case tenue depuis `LOST_SLOT_AFTER`. `None` quand Chromium tient légitimement toutes- /// les cases : la frame est sautée, la suivante passera.- pub fn claim(&mut self, slots: u32, now: Instant) -> Option<u32> {+ /// frame prête que personne n'a prise, retirée puisqu'elle est périmée. `None` quand+ /// Chromium tient toutes les cases : une case tenue n'est jamais réécrite, même perdue+ /// (`lost`), puisqu'il peut encore la lire.+ pub fn claim(&mut self, slots: u32) -> Option<u32> {let ready = self.ready.map(|frame| frame.slot);let is_held = |slot: u32| self.held.iter().any(|held| held.slot == slot);if let Some(free) = (0..slots).find(|slot| !is_held(*slot) && Some(*slot) != ready) {@@ -71,10 +71,12 @@ impl SlotBook {self.ready = None;return Some(stale);}- let lost = self.held.first().filter(|held| now.duration_since(held.since) >= LOST_SLOT_AFTER)?;- let slot = lost.slot;- self.held.remove(0);- Some(slot)+ None+ }++ /// Une case est tenue depuis `LOST_SLOT_AFTER` : sa libération ne viendra plus.+ pub fn lost(&self, now: Instant) -> bool {+ self.held.first().is_some_and(|held| now.duration_since(held.since) >= LOST_SLOT_AFTER)}pub fn publish(&mut self, frame: SharedFrame) {@@ -91,8 +93,7 @@ impl SlotBook {}/// Chromium a relâché la frame `gen` de la case `slot`. La génération évite qu'une- /// libération tardive, arrivée après que la case a été reprise, ne libère la frame- /// suivante.+ /// libération en double ne libère la frame suivante posée dans la même case.pub fn release(&mut self, slot: u32, gen: u64) {self.held.retain(|held| held.slot != slot || held.gen != gen);}@@ -261,7 +262,7 @@ mod tests {let now = Instant::now();let mut book = SlotBook::default();book.publish(frame(1, 0));- assert_eq!(book.claim(RING_SLOTS, now), Some(1));+ assert_eq!(book.claim(RING_SLOTS), Some(1));// La frame prête n'a pas bougé : JS peut toujours la prendre.assert_eq!(book.take(0, now), Some(frame(1, 0)));}@@ -270,9 +271,9 @@ mod tests {fn a_taken_slot_is_never_written_until_released() {let now = Instant::now();let mut book = all_held(now);- assert_eq!(book.claim(RING_SLOTS, now), None, "Chromium tient toutes les cases");+ assert_eq!(book.claim(RING_SLOTS), None, "Chromium tient toutes les cases");book.release(2, 3);- assert_eq!(book.claim(RING_SLOTS, now), Some(2));+ assert_eq!(book.claim(RING_SLOTS), Some(2));}#[test]@@ -284,7 +285,7 @@ mod tests {book.take(u64::from(slot), now);}book.publish(frame(9, 3));- assert_eq!(book.claim(RING_SLOTS, now), Some(3));+ assert_eq!(book.claim(RING_SLOTS), Some(3));// Retirée : la livrer maintenant, pendant qu'on la réécrit, donnerait une image déchirée.assert_eq!(book.take(0, now), None);}@@ -307,23 +308,21 @@ mod tests {book.take(0, now);book.release(3, 1);book.release(0, 7);- assert_eq!(book.claim(1, now), None, "ni la case 3 ni la génération 7 ne sont tenues");+ assert_eq!(book.claim(1), None, "ni la case 3 ni la génération 7 ne sont tenues");book.release(0, 1);- assert_eq!(book.claim(1, now), Some(0));+ assert_eq!(book.claim(1), Some(0));}#[test]- fn a_slot_whose_release_never_came_is_taken_back_after_a_second() {+ fn a_slot_whose_release_never_came_is_reported_lost_but_never_rewritten() {let start = Instant::now();let mut book = all_held(start);- assert_eq!(book.claim(RING_SLOTS, start + LOST_SLOT_AFTER / 2), None);- // La plus ancienne d'abord.- assert_eq!(book.claim(RING_SLOTS, start + LOST_SLOT_AFTER), Some(0));- // Sa libération tardive ne doit plus rien libérer : la case est déjà reprise.- book.release(0, 1);- book.publish(frame(10, 0));- assert!(book.take(9, start + LOST_SLOT_AFTER).is_some());+ assert!(!book.lost(start + LOST_SLOT_AFTER / 2));+ assert!(book.lost(start + LOST_SLOT_AFTER));+ // Chromium peut encore lire une case perdue : la réécrire déchirerait son image.+ assert_eq!(book.claim(RING_SLOTS), None);+ // Si sa libération finit par venir, la case sert de nouveau.book.release(0, 1);- assert_eq!(book.claim(RING_SLOTS, start + LOST_SLOT_AFTER), Some(1));+ assert_eq!(book.claim(RING_SLOTS), Some(0));}}diff --git a/technical-documentation/architecture/preview.md b/technical-documentation/architecture/preview.mdindex 6be0f7a54..8fa2d6fd5 100644--- a/technical-documentation/architecture/preview.md+++ b/technical-documentation/architecture/preview.md@@ -205,7 +205,9 @@ thread busy (measurements inD3D11 textures (`shared_frames.rs`, NT handles, no keyed mutex), waits for the GPU tofinish the copy, and publishes `{ gen, slot, handle }`. `SlotBook` tracks which slotholds the ready frame and which ones Chromium still holds; a frame nobody took gives- its slot back, and a slot whose release never came is reclaimed after 1 s.+ its slot back. A held slot is never rewritten, since Chromium may still read it: when+ every slot is held and one has waited 1 s for its release, the view falls back to+ read-back.- **Main process.** `readFrame` takes the frame (`readSharedFrame`), imports it with`sharedTexture.importSharedTexture`, sends it with `sharedTexture.sendSharedTexture` tothe frame that asked, drops its own reference and answers with a receipt