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
//! Livraison de la preview par textures partagées : le thread de rendu copie chaque frame
//! composée dans l'une des textures d'un petit anneau, et Electron l'importe côté GPU
//! (`sharedTexture.importSharedTexture`) au lieu d'en recevoir les pixels. Plus de `Map`
//! qui attend le GPU puis recopie l'image en RAM, plus de `Vec<u8>` de plusieurs Mo par frame
//! à travers l'IPC : mesuré, ce transport coûtait à lui seul 37 à 55 % du thread principal
//! du renderer à 30 images/s.
//!
//! Deux moitiés :
//! - `SlotBook`, portable et sans GPU : quelle case porte la frame prête, lesquelles
//! Chromium tient encore. Partagé entre le thread de rendu (`claim`, `publish`) et le
//! thread Node (`take`, `release`).
//! - `SharedRing` (Windows, backend matériel) : les textures D3D11 et leurs handles NT.
//! macOS (IOSurface) et Linux (dmabuf) restent sur le readback.
use crate::frame_geometry::FootageQuad;
use crate::live::FramePosition;
use std::time::{Duration, Instant};
/// Cases de l'anneau : une prête, une en écriture, et celles que Chromium tient encore. Une case
/// relâchée reste tenue 40 ms de plus côté Electron (`SHARED_SLOT_RELEASE_DELAY_MS`), le temps
/// que le GPU ait copié la frame dans le canvas : à 60 images/s, trois à quatre cases sont alors
/// tenues en même temps. Avec quatre, le rendu attendait une case libre et sautait des frames ;
/// huit laissent de la marge jusqu'à ~150 images/s, pour 8 × (largeur × hauteur × 4) octets de
/// VRAM (66 Mo en 1080p).
pub const RING_SLOTS: u32 = 8;
/// Une case tenue plus longtemps que ça a perdu sa libération (renderer rechargé, import
/// é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.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SharedFrame {
/// Même compteur que les frames lues en RAM : le consommateur ne voit qu'une suite de
/// générations, quel que soit le transport.
pub gen: u64,
pub slot: u32,
/// Valeur du handle NT de la texture de la case, valable dans CE processus. Electron le
/// duplique à l'import : la case garde le sien.
pub handle: u64,
pub width: u32,
pub height: u32,
pub footage: Option<FootageQuad>,
pub position: FramePosition,
}
/// Une case prise par JS : la génération qu'elle porte et quand elle est partie.
#[derive(Debug, Clone, Copy)]
struct Held {
slot: u32,
gen: u64,
since: Instant,
}
/// Qui tient quelle case de l'anneau.
#[derive(Debug, Default)]
pub struct SlotBook {
/// La dernière frame publiée, que JS n'a pas encore prise.
ready: Option<SharedFrame>,
/// Les cases prises par JS, que Chromium n'a pas encore relâchées, plus anciennes d'abord.
held: Vec<Held>,
/// La case après la dernière prise : la recherche d'une case libre part de là.
next: u32,
}
impl SlotBook {
/// La case où écrire la prochaine frame. Une case libre d'abord, à tour de rôle à partir
/// de la dernière prise : la case que Chromium vient de relâcher est la dernière réécrite,
/// pas la première, puisque son GPU peut encore la copier dans le canvas (#1301). À défaut,
/// celle de la 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);
let slot = (0..slots)
.map(|i| (self.next + i) % slots)
.find(|slot| !is_held(*slot) && Some(*slot) != ready)
.or_else(|| self.ready.take().map(|frame| frame.slot))?;
self.next = (slot + 1) % slots;
Some(slot)
}
/// 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) {
self.ready = Some(frame);
}
/// La frame prête, si elle est plus récente que `since_gen`. Sa case reste tenue jusqu'à
/// `release` : le thread de rendu n'y écrira plus d'ici là.
pub fn take(&mut self, since_gen: u64, now: Instant) -> Option<SharedFrame> {
let frame = self.ready.filter(|frame| frame.gen > since_gen)?;
self.ready = None;
self.held.push(Held { slot: frame.slot, gen: frame.gen, since: now });
Some(frame)
}
/// Chromium a relâché la frame `gen` de la case `slot`. La génération évite qu'une
/// 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);
}
/// Oublie la frame prête : la vue repasse au readback, personne ne viendra la prendre.
pub fn clear_ready(&mut self) {
self.ready = None;
}
}
#[cfg(windows)]
pub use ring::SharedRing;
#[cfg(windows)]
mod ring {
use super::RING_SLOTS;
use crate::d3d::Gpu;
use anyhow::{bail, Result};
use std::time::{Duration, Instant};
use windows::core::{Interface, PCWSTR};
use windows::Win32::Foundation::{CloseHandle, BOOL, HANDLE};
use windows::Win32::Graphics::Direct3D11::{
ID3D11Device, ID3D11DeviceContext, ID3D11Query, ID3D11Texture2D,
D3D11_ASYNC_GETDATA_DONOTFLUSH, D3D11_BIND_RENDER_TARGET, D3D11_BIND_SHADER_RESOURCE,
D3D11_QUERY_DESC, D3D11_QUERY_EVENT, D3D11_RESOURCE_MISC_SHARED,
D3D11_RESOURCE_MISC_SHARED_NTHANDLE, D3D11_TEXTURE2D_DESC, D3D11_USAGE_DEFAULT,
};
use windows::Win32::Graphics::Dxgi::Common::{DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_SAMPLE_DESC};
use windows::Win32::Graphics::Dxgi::{
IDXGIResource1, DXGI_SHARED_RESOURCE_READ, DXGI_SHARED_RESOURCE_WRITE,
};
/// Au-delà, le GPU est bloqué ou perdu : on rend une erreur plutôt que de geler la vue.
const COPY_TIMEOUT: Duration = Duration::from_millis(500);
struct SlotTexture {
tex: ID3D11Texture2D,
handle: HANDLE,
width: u32,
height: u32,
}
impl Drop for SlotTexture {
fn drop(&mut self) {
// Electron importe un duplicata du handle : fermer le nôtre ne retire rien à une
// frame que Chromium affiche encore.
unsafe {
let _ = CloseHandle(self.handle);
}
}
}
/// Les textures partagées d'une vue live, créées à la demande à la taille du rendu.
pub struct SharedRing {
device: ID3D11Device,
context: ID3D11DeviceContext,
copied: ID3D11Query,
slots: Vec<Option<SlotTexture>>,
}
impl SharedRing {
pub fn new(gpu: &Gpu) -> Result<SharedRing> {
let desc = D3D11_QUERY_DESC { Query: D3D11_QUERY_EVENT, MiscFlags: 0 };
let mut copied = None;
unsafe { gpu.device.CreateQuery(&desc, Some(&mut copied))? };
Ok(SharedRing {
device: gpu.device.clone(),
context: gpu.context.clone(),
copied: copied.expect("CreateQuery a réussi sans requête"),
slots: (0..RING_SLOTS).map(|_| None).collect(),
})
}
/// Copie `src` (`width`×`height`, RGBA8) dans la case `slot` et rend le handle de sa
/// texture une fois le GPU arrivé au bout de la copie. Chromium la lit depuis son propre
/// device, sans keyed mutex : quand le handle part, plus rien ne doit y écrire. L'attente
/// est celle que faisait déjà le `Map` du readback, la recopie en RAM en moins.
///
/// La case ne doit être ni prête ni tenue (`SlotBook::claim`) : sa texture peut être
/// recréée ici quand la taille du rendu a changé.
pub unsafe fn write(
&mut self,
slot: u32,
src: &ID3D11Texture2D,
width: u32,
height: u32,
) -> Result<u64> {
let entry = &mut self.slots[slot as usize];
if !matches!(entry, Some(texture) if texture.width == width && texture.height == height) {
*entry = Some(create_slot(&self.device, width, height)?);
}
let target = entry.as_ref().expect("case créée juste au-dessus");
self.context.CopyResource(&target.tex, src);
self.context.End(&self.copied);
self.context.Flush();
let deadline = Instant::now() + COPY_TIMEOUT;
loop {
let mut done = BOOL(0);
self.context.GetData(
&self.copied,
Some(&mut done as *mut BOOL as *mut core::ffi::c_void),
std::mem::size_of::<BOOL>() as u32,
D3D11_ASYNC_GETDATA_DONOTFLUSH.0 as u32,
)?;
if done.as_bool() {
break;
}
if Instant::now() > deadline {
bail!("le GPU n'a pas fini de copier la frame en {COPY_TIMEOUT:?}");
}
std::thread::yield_now();
}
Ok(target.handle.0 as u64)
}
}
unsafe fn create_slot(device: &ID3D11Device, width: u32, height: u32) -> Result<SlotTexture> {
let desc = D3D11_TEXTURE2D_DESC {
Width: width,
Height: height,
MipLevels: 1,
ArraySize: 1,
// Le format du RT composé : la copie est un `CopyResource`, sans conversion.
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,
// Handle NT, le seul qu'Electron importe, sans keyed mutex : `write` attend la fin
// de la copie avant de le livrer.
MiscFlags: (D3D11_RESOURCE_MISC_SHARED.0 | D3D11_RESOURCE_MISC_SHARED_NTHANDLE.0) as u32,
};
let mut tex = None;
device.CreateTexture2D(&desc, None, Some(&mut tex))?;
let tex = tex.expect("CreateTexture2D a réussi sans texture");
let resource: IDXGIResource1 = tex.cast()?;
let handle = resource.CreateSharedHandle(
None,
DXGI_SHARED_RESOURCE_READ.0 | DXGI_SHARED_RESOURCE_WRITE.0,
PCWSTR::null(),
)?;
Ok(SlotTexture { tex, handle, width, height })
}
}
#[cfg(test)]
mod tests {
use super::*;
fn frame(gen: u64, slot: u32) -> SharedFrame {
SharedFrame {
gen,
slot,
handle: 0,
width: 2,
height: 2,
footage: None,
position: FramePosition { clip_index: 0, source_time_sec: 0.0 },
}
}
/// Toutes les cases prises par JS, la case `n` portant la génération `n + 1`.
fn all_held(now: Instant) -> SlotBook {
let mut book = SlotBook::default();
for slot in 0..RING_SLOTS {
book.publish(frame(u64::from(slot) + 1, slot));
assert!(book.take(u64::from(slot), now).is_some());
}
book
}
#[test]
fn claims_a_free_slot_before_a_ready_one() {
let now = Instant::now();
let mut book = SlotBook::default();
book.publish(frame(1, 0));
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)));
}
#[test]
fn a_released_slot_waits_its_turn_while_others_are_free() {
let now = Instant::now();
let mut book = SlotBook::default();
// Régime établi : chaque frame est prise par JS, et Chromium relâche la précédente.
let mut previous = None;
for gen in 1..=3 {
let slot = book.claim(RING_SLOTS).unwrap();
book.publish(frame(gen, slot));
book.take(gen - 1, now);
if let Some(slot) = previous {
book.release(slot, gen - 1);
}
previous = Some(slot);
}
// Les cases déjà relâchées peuvent encore être lues par le GPU de Chromium (#1301) :
// la suivante va plus loin dans l'anneau au lieu de reprendre la plus petite.
assert_eq!(book.claim(RING_SLOTS), Some(3));
}
#[test]
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), None, "Chromium tient toutes les cases");
book.release(2, 3);
assert_eq!(book.claim(RING_SLOTS), Some(2));
}
#[test]
fn a_frame_nobody_took_gives_its_slot_back_when_nothing_else_is_free() {
let now = Instant::now();
let mut book = SlotBook::default();
for slot in 0..RING_SLOTS - 1 {
book.publish(frame(u64::from(slot) + 1, slot));
book.take(u64::from(slot), now);
}
let last = RING_SLOTS - 1;
book.publish(frame(u64::from(RING_SLOTS) + 1, last));
assert_eq!(book.claim(RING_SLOTS), Some(last));
// Retirée : la livrer maintenant, pendant qu'on la réécrit, donnerait une image déchirée.
assert_eq!(book.take(0, now), None);
}
#[test]
fn take_hands_out_only_newer_generations() {
let now = Instant::now();
let mut book = SlotBook::default();
book.publish(frame(5, 1));
assert_eq!(book.take(5, now), None);
assert_eq!(book.take(4, now), Some(frame(5, 1)));
assert_eq!(book.take(0, now), None, "déjà prise");
}
#[test]
fn a_release_only_frees_the_generation_it_names() {
let now = Instant::now();
let mut book = SlotBook::default();
book.publish(frame(1, 0));
book.take(0, now);
book.release(3, 1);
book.release(0, 7);
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), Some(0));
}
#[test]
fn a_slot_whose_release_never_came_is_reported_lost_but_never_rewritten() {
let start = Instant::now();
let mut book = all_held(start);
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), Some(0));
}
}