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
//! Golden pixel de la refonte « le RT est le cadre de sortie ».
//!
//! Le filet unitaire de `compositor::tests` verrouille la GÉOMÉTRIE (un carré
//! atterrit carré, un calque centré reste centré). Il ne peut rien dire des
//! PIXELS : or le contrat le plus fort de la refonte est « le 16:9 ne doit pas
//! bouger d'un pixel ». D'où ce golden, qui rend de vraies frames.
//!
//! Il est **piloté par l'environnement** et se saute proprement quand les
//! sources manquent — pas de fixture vidéo dans le dépôt, et la machine de CI
//! n'a pas forcément de GPU D3D11 :
//!
//! ```powershell
//! $env:OPENSCREEN_GOLDEN_SCREEN = "...\recording-<id>.mp4"
//! $env:OPENSCREEN_GOLDEN_WEBCAM = "...\recording-<id>-webcam.webm"
//! cargo test --test output_geometry_golden -- --nocapture
//! ```
//!
//! Mode d'emploi de la refonte : lancer AVANT la phase 1, garder la sortie,
//! relancer APRÈS, comparer.
//! - le hash du 16:9 doit être **identique** (c'est le contrat 4 : en 16:9 la
//! compensation est déjà l'identité, donc rien ne doit changer) ;
//! - le hash des autres formats CHANGE — c'est le but ;
//! - `grad_y` (énergie de gradient vertical) doit **monter** sur les formats
//! portrait : c'est la mesure du détail regagné, aujourd'hui perdu parce
//! que le canvas plafonne à 1080 lignes et que `blit_resized` agrandit.
// Pas sur Linux : `Compositor::readback_resized` n'existe que dans
// `compositor_windows` et `compositor_macos`. Meme raison que dans
// `export_timing.rs` — les fichiers de `tests/` sont compiles sur toute
// plateforme, et sans cette porte le crate ne compile pas sous Linux.
#![cfg(not(target_os = "linux"))]
use openscreen_compositor::compositor::Compositor;
use openscreen_compositor::d3d::Gpu;
use openscreen_compositor::live::Player;
use openscreen_compositor::scene::Scene;
use openscreen_compositor::config;
mod common;
use common::write_ppm;
/// Instant fixe dans la source. Un seek explicite (`present_frame`) plutôt que
/// la lecture libre : le golden doit être reproductible à l'octet près.
const AT_SEC: f64 = 2.0;
/// Mêmes formats que le filet unitaire, pour que les deux racontent la même
/// histoire. `native *` rappelle que « native » n'est borné par aucune liste.
const FORMATS: &[(&str, u32, u32)] = &[
("16-9", 1920, 1080),
("9-16", 1080, 1920),
("1-1", 1920, 1920),
("4-5", 1536, 1920),
("native-ultrawide", 3440, 1440),
("4k-16-9", 3840, 2160),
];
fn fnv1a(bytes: &[u8]) -> u64 {
let mut h: u64 = 0xcbf2_9ce4_8422_2325;
for &b in bytes {
h ^= b as u64;
h = h.wrapping_mul(0x0000_0100_0000_01b3);
}
h
}
/// Énergie de gradient moyenne par axe (|Δluma| entre pixels adjacents).
/// Un agrandissement lisse les transitions et fait donc CHUTER cette valeur sur
/// l'axe agrandi — c'est exactement la perte que la phase 1 doit récupérer.
fn gradient_energy(rgba: &[u8], w: usize, h: usize) -> (f64, f64) {
let lum = |i: usize| {
0.299 * rgba[i * 4] as f64 + 0.587 * rgba[i * 4 + 1] as f64 + 0.114 * rgba[i * 4 + 2] as f64
};
let (mut gx, mut gy) = (0.0, 0.0);
let (mut nx, mut ny) = (0usize, 0usize);
for y in 0..h {
for x in 0..w {
let i = y * w + x;
if x + 1 < w {
gx += (lum(i + 1) - lum(i)).abs();
nx += 1;
}
if y + 1 < h {
gy += (lum(i + w) - lum(i)).abs();
ny += 1;
}
}
}
(gx / nx.max(1) as f64, gy / ny.max(1) as f64)
}
fn scene_json(screen: &str, webcam: &str, w: u32, h: u32) -> String {
// Chemins en slashes : le JSON n'échappe pas les backslashes Windows.
let (s, c) = (screen.replace('\\', "/"), webcam.replace('\\', "/"));
format!(
r##"{{
"clips": [{{"screenPath":"{s}","webcamPath":"{c}","sourceStartSec":0,"sourceEndSec":30,"webcamOffsetSec":0,"hasAudio":true}}],
"layout": {{"preset":"picture-in-picture","webcamSize":1.0,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},
"effects": {{"padding":0.1,"blur":true,"shadow":1.0,"roundnessFrac":0.0222,"motionBlur":0.0}},
"background": {{"kind":"gradient","angleDeg":135,"stops":["#eaebed","#bcc0c6"]}},
"zoomRegions": [],
"speedRegions": [],
"cursor": {{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
"cropByClip": [null],
"output": {{"width":{w},"height":{h},"fps":null}}
}}"##
)
}
#[test]
fn golden_frames_per_output_format() {
let (screen, webcam) = match (
std::env::var("OPENSCREEN_GOLDEN_SCREEN"),
std::env::var("OPENSCREEN_GOLDEN_WEBCAM"),
) {
(Ok(s), Ok(w)) => (s, w),
_ => {
println!(
"SKIP: definir OPENSCREEN_GOLDEN_SCREEN et OPENSCREEN_GOLDEN_WEBCAM \
(chemins d'un enregistrement reel) pour produire le golden."
);
return;
}
};
let out_dir = std::env::var("OPENSCREEN_GOLDEN_OUT")
.map(std::path::PathBuf::from)
.unwrap_or_else(|_| std::path::PathBuf::from("target/golden"));
std::fs::create_dir_all(&out_dir).expect("creer le dossier de sortie");
// C8 = tous les effets (ombres, coins, fond flouté, motion blur) : le golden
// doit couvrir les calques que les 9 correctifs ont touchés. Zoom et anim de
// layout coupés — ce sont les plannings FIXTURE, pas le contrat de scène
// (même neutralisation que `live::render_thread`).
let mut cfg = config::all().pop().expect("au moins une config");
cfg.zoom = false;
cfg.layout_anim = false;
let gpu = Gpu::create(false).expect("device d3d11");
println!("\n{:<18} {:>11} {:>18} {:>9} {:>9}", "format", "sortie", "hash", "grad_x", "grad_y");
println!("{}", "-".repeat(72));
for &(name, w, h) in FORMATS {
// Un compositeur PAR FORMAT, rastérisant à la géométrie de sortie — c'est
// exactement ce que fait le chemin d'export. Avant la refonte il n'y avait
// qu'un seul compositeur 1920x1080 pour tous les formats.
let comp = Compositor::new_sized(&gpu, w, h).expect("compositor");
let scene = Scene::from_json(&scene_json(&screen, &webcam, w, h)).expect("scene valide");
comp.set_scene(Some(scene));
comp.clear_cursor();
// Un Player par format : `present_frame` fait avancer les décodeurs, on
// repart donc d'un état propre pour que AT_SEC désigne bien la même
// image source d'un format à l'autre.
let rgba = unsafe {
let mut player = Player::open(&screen, &webcam, &gpu).expect("ouvrir les sources");
player.present_frame(&comp, &cfg, AT_SEC).expect("composer la frame");
comp.readback_resized(w, h).expect("readback")
};
assert_eq!(
rgba.len(),
(w as usize) * (h as usize) * 4,
"{name}: le readback ne fait pas w*h*4"
);
let (gx, gy) = gradient_energy(&rgba, w as usize, h as usize);
let hash = fnv1a(&rgba);
write_ppm(&out_dir.join(format!("{name}.ppm")), &rgba, w, h).expect("ecrire le ppm");
println!("{name:<18} {:>5}x{:<5} {hash:>18x} {gx:>9.3} {gy:>9.3}", w, h);
}
println!("\nFrames ecrites dans {}", out_dir.display());
println!(
"Apres la phase 1 : le hash du 16-9 doit etre INCHANGE ; grad_y doit MONTER \
sur 9-16, 1-1, 4-5 et 4k-16-9."
);
}
/// Rend le preset side-by-side avec un rect webcam en COLONNE — exactement ce que
/// produit `computeCompositeLayout` (branche dual-frame : `webcamRect = webcamSlot`,
/// un slot de largeur fixe et de pleine hauteur, sans aucun ajustement d'aspect).
///
/// C'est le cas qui étirait la caméra : le natif plaquait la frame entière sur ce
/// slot. Depuis `cover_crop_uv`, la coupe source suit le ratio de la boîte, donc la
/// caméra est rognée mais jamais déformée. Écrit un PPM pour inspection visuelle —
/// la propriété, elle, est verrouillée par les tests unitaires de `cover_crop_uv`.
#[test]
fn golden_side_by_side_webcam_is_not_stretched() {
let (screen, webcam) = match (
std::env::var("OPENSCREEN_GOLDEN_SCREEN"),
std::env::var("OPENSCREEN_GOLDEN_WEBCAM"),
) {
(Ok(s), Ok(w)) => (s, w),
_ => {
println!("SKIP: definir OPENSCREEN_GOLDEN_SCREEN / _WEBCAM");
return;
}
};
let out_dir = std::env::var("OPENSCREEN_GOLDEN_OUT")
.map(std::path::PathBuf::from)
.unwrap_or_else(|_| std::path::PathBuf::from("target/golden"));
std::fs::create_dir_all(&out_dir).expect("dossier de sortie");
let (w, h) = (1920u32, 1080u32);
let (s, c) = (screen.replace('\\', "/"), webcam.replace('\\', "/"));
// slot webcam : colonne droite, ~31% de large, pleine hauteur → ratio ~0.55,
// très loin du 16:9 de la caméra. Sans cover, la tête est visiblement étirée.
let scene_json = format!(
r##"{{
"clips": [{{"screenPath":"{s}","webcamPath":"{c}","sourceStartSec":0,"sourceEndSec":30,"webcamOffsetSec":0,"hasAudio":true}}],
"layout": {{"preset":"dual-frame","webcamSize":1.0,"webcamShape":"rectangle","webcamMirror":false,
"webcamRect":{{"x":0.66,"y":0.06,"width":0.31,"height":0.88}},"webcamReactiveZoom":false}},
"effects": {{"padding":0.0,"blur":true,"shadow":1.0,"roundnessFrac":0.0222,"motionBlur":0.0}},
"background": {{"kind":"gradient","angleDeg":135,"stops":["#b02a2a","#7a1414"]}},
"zoomRegions": [], "speedRegions": [],
"cursor": {{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
"cropByClip": [null],
"output": {{"width":{w},"height":{h},"fps":null}}
}}"##
);
let mut cfg = config::all().pop().expect("au moins une config");
cfg.zoom = false;
cfg.layout_anim = false;
let gpu = Gpu::create(false).expect("device d3d11");
let comp = Compositor::new_sized(&gpu, w, h).expect("compositor");
comp.set_scene(Some(Scene::from_json(&scene_json).expect("scene valide")));
comp.clear_cursor();
let rgba = unsafe {
let mut player = Player::open(&screen, &webcam, &gpu).expect("ouvrir les sources");
player.present_frame(&comp, &cfg, AT_SEC).expect("composer");
comp.readback_resized(w, h).expect("readback")
};
let path = out_dir.join("side-by-side.ppm");
write_ppm(&path, &rgba, w, h).expect("ecrire le ppm");
println!("side-by-side ecrit: {}", path.display());
}
/// Rend un clip RECADRÉ avec le `screenRect` que l'app résout — le chemin qui a
/// régressé. `compositor.rs::fit_screen` consomme ce rect TEL QUEL (il saute son
/// propre fit au ratio du crop, le rect étant censé y être déjà) : si le rect ne
/// porte pas le ratio du crop, la vidéo est étirée pour remplir une boîte mal
/// formée, sans rien en aval pour rattraper.
///
/// `SCREEN_RECT_AR` doit rester le ratio du crop (0.30*1920 / 0.89*1080 ≈ 0.599).
/// Le PPM permet de vérifier à l'œil que le texte n'est pas étiré.
#[test]
fn golden_cropped_clip_is_not_stretched() {
let (screen, webcam) = match (
std::env::var("OPENSCREEN_GOLDEN_SCREEN"),
std::env::var("OPENSCREEN_GOLDEN_WEBCAM"),
) {
(Ok(s), Ok(w)) => (s, w),
_ => {
println!("SKIP: definir OPENSCREEN_GOLDEN_SCREEN / _WEBCAM");
return;
}
};
let out_dir = std::env::var("OPENSCREEN_GOLDEN_OUT")
.map(std::path::PathBuf::from)
.unwrap_or_else(|_| std::path::PathBuf::from("target/golden"));
std::fs::create_dir_all(&out_dir).expect("dossier de sortie");
let (w, h) = (1920u32, 1080u32);
let (s, c) = (screen.replace('\\', "/"), webcam.replace('\\', "/"));
// Crop du rapport utilisateur : bande verticale 30% x 89% d'une source 16:9.
let (crop_w, crop_h) = (0.30f32, 0.89f32);
let crop_ar = (1920.0 * crop_w) / (1080.0 * crop_h); // ≈ 0.599
// Le rect que l'app DOIT produire : contain de ce ratio dans le cadre de sortie.
let rect_h = 0.94f32;
let rect_w = rect_h * crop_ar * (h as f32 / w as f32);
let scene_json = format!(
r##"{{
"clips": [{{"screenPath":"{s}","webcamPath":"{c}","sourceStartSec":0,"sourceEndSec":30,"webcamOffsetSec":0,"hasAudio":true}}],
"layout": {{"preset":"no-webcam","webcamSize":1.0,"webcamShape":"rectangle","webcamMirror":false,
"screenRect":{{"x":{sx},"y":{sy},"width":{rect_w},"height":{rect_h}}},"webcamReactiveZoom":false}},
"effects": {{"padding":0.0,"blur":true,"shadow":1.0,"roundnessFrac":0.0222,"motionBlur":0.0}},
"background": {{"kind":"gradient","angleDeg":135,"stops":["#1e3a5f","#0d1b2a"]}},
"zoomRegions": [], "speedRegions": [],
"cursor": {{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
"cropByClip": [{{"x":0.44,"y":0.06,"width":{crop_w},"height":{crop_h}}}],
"output": {{"width":{w},"height":{h},"fps":null}}
}}"##,
sx = 0.5 - rect_w * 0.5,
sy = 0.5 - rect_h * 0.5,
);
let mut cfg = config::all().pop().expect("au moins une config");
cfg.zoom = false;
cfg.layout_anim = false;
let gpu = Gpu::create(false).expect("device d3d11");
let comp = Compositor::new_sized(&gpu, w, h).expect("compositor");
comp.set_scene(Some(Scene::from_json(&scene_json).expect("scene valide")));
comp.clear_cursor();
let rgba = unsafe {
let mut player = Player::open(&screen, &webcam, &gpu).expect("ouvrir les sources");
player.present_frame(&comp, &cfg, AT_SEC).expect("composer");
comp.readback_resized(w, h).expect("readback")
};
let path = out_dir.join("cropped-clip.ppm");
write_ppm(&path, &rgba, w, h).expect("ecrire le ppm");
println!("crop ar={crop_ar:.3} rect={rect_w:.3}x{rect_h:.3} -> {}", path.display());
}