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
//! Un fond animé, dégradé (mode 5) ou image (mode 6), est une fonction pure du temps programme
//! (`fx.w`) : immobile, il ne dépend pas de l'instant ; animé, chaque mouvement donne une image
//! propre à chacun des trois instants fixes, et différente du fond immobile.
//!
//! Rend de vraies frames par le compositeur D3D11. Piloté par l'environnement, comme
//! `privacy_blur_under_zoom.rs`, dont il réutilise la source (n'importe quel MP4 d'au moins
//! 6 s convient) :
//!
//! ```powershell
//! $env:OPENSCREEN_PRIVACY_SECRET = "...\secret.mp4"
//! cargo test -p openscreen-compositor --test animated_background -- --nocapture
//! ```
//!
//! `OPENSCREEN_BACKGROUND_OUT` (facultatif) reçoit un PPM par cas, pour l'inspection à l'œil.
//! Les empreintes imprimées sont celles de CE GPU : le rendu « none » se compare à celui du
//! shader d'avant le fond animé en relançant le test sur l'ancien `shaders.hlsl`.
// Windows seulement : le readback et le décodage D3D11VA de ce harnais n'existent que là.
#![cfg(windows)]
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use openscreen_compositor::compositor::Compositor;
use openscreen_compositor::config;
use openscreen_compositor::d3d::Gpu;
use openscreen_compositor::frame_geometry::live_params_from_scene;
use openscreen_compositor::live::Player;
use openscreen_compositor::scene::Scene;
mod common;
use common::write_ppm;
const W: u32 = 960;
const H: u32 = 540;
/// Trois clips de 6 s du même fichier : le clip `k` lu à 3 s source tombe à `6k + 3` s de
/// programme. La frame vidéo est la même, seul le temps programme change.
const PROGRAMME_TIMES: [f32; 3] = [3.0, 9.0, 15.0];
/// Le fond, ouvert : `scene_json` y ajoute le mouvement puis referme l'accolade.
const GRADIENT: &str = r##"{"kind":"gradient","angleDeg":135,"stops":["#2b3a67","#b8577f"]"##;
/// Un fond image du catalogue, lu depuis `public/wallpapers` : le zoom et le déplacement que
/// chaque mouvement lui applique ne se vérifient que sur une vraie image.
fn image_background() -> String {
let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../../public/wallpapers/wallpaper3.jpg");
format!(r#"{{"kind":"image","path":"{}""#, path.replace('\\', "/"))
}
/// `background` : le fond ouvert (`GRADIENT`, `image_background`) ; `motion` : fragment JSON
/// inséré tel quel dedans (`""` = clé absente).
fn scene_json(source: &str, background: &str, motion: &str) -> String {
let s = source.replace('\\', "/");
let clip = format!(
r#"{{"screenPath":"{s}","webcamPath":"","sourceStartSec":0,"sourceEndSec":6,"webcamOffsetSec":0,"hasAudio":false}}"#
);
format!(
r##"{{
"clips": [{clip},{clip},{clip}],
"layout": {{"preset":"no-webcam","webcamSize":1.0,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},
"effects": {{"padding":1.0,"blur":false,"shadow":0.0,"roundnessFrac":0.02,"motionBlur":0.0}},
"background": {background}{motion}}},
"zoomRegions": [],
"speedRegions": [],
"cursor": {{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
"cropByClip": [null, null, null],
"output": {{"width":{W},"height":{H},"fps":30}}
}}"##
)
}
fn render(gpu: &Gpu, source: &str, background: &str, motion: &str, clip: usize) -> Vec<u8> {
let mut cfg = config::all().pop().expect("au moins une config");
cfg.zoom = false;
cfg.layout_anim = false;
let comp = Compositor::new_sized(gpu, W, H).expect("compositor");
let scene = Scene::from_json(&scene_json(source, background, motion)).expect("scene valide");
comp.set_live_params(live_params_from_scene(&scene));
comp.set_scene(Some(scene.clone()));
comp.clear_cursor();
unsafe {
let mut player = Player::open(source, "", gpu).expect("ouvrir la source");
player.set_programme_clock(Some(&scene), clip);
player.present_frame(&comp, &cfg, 3.0).expect("composer la frame");
let t = player.programme_time().expect("horloge programme");
assert!((t - PROGRAMME_TIMES[clip]).abs() < 0.05, "temps programme {t} pour le clip {clip}");
comp.readback_resized(W, H).expect("readback")
}
}
fn hash(rgba: &[u8]) -> u64 {
let mut h = DefaultHasher::new();
rgba.hash(&mut h);
h.finish()
}
#[test]
fn each_motion_is_a_distinct_pure_function_of_programme_time() {
let Ok(source) = std::env::var("OPENSCREEN_PRIVACY_SECRET") else {
println!("SKIP: definir OPENSCREEN_PRIVACY_SECRET (voir l'en-tete du fichier).");
return;
};
let out_dir = std::env::var("OPENSCREEN_BACKGROUND_OUT").ok().map(std::path::PathBuf::from);
if let Some(dir) = &out_dir {
std::fs::create_dir_all(dir).expect("creer le dossier de sortie");
}
let gpu = Gpu::create(false).expect("device d3d11");
for (kind, background) in [("gradient", GRADIENT.to_string()), ("image", image_background())] {
let shoot = |name: &str, motion: &str, clip: usize| {
let rgba = render(&gpu, &source, &background, motion, clip);
if let Some(dir) = &out_dir {
let file = format!("{kind}-{name}-t{:02}.ppm", PROGRAMME_TIMES[clip] as u32);
write_ppm(&dir.join(file), &rgba, W, H).expect("ecrire le ppm");
}
let h = hash(&rgba);
println!("{kind:<8} {name:<8} t={:>4} {h:016x}", PROGRAMME_TIMES[clip]);
h
};
// Immobile : clé absente, "none" et une valeur inconnue rendent la même image, à tout
// instant.
let still = shoot("absent", "", 0);
for clip in 0..3 {
let none = shoot("none", r#","motion":"none""#, clip);
assert_eq!(none, still, "{kind} : none au clip {clip}");
}
assert_eq!(shoot("unknown", r#","motion":"plasma""#, 2), still, "{kind} : inconnu");
for name in ["drift", "aurora", "waves"] {
let motion = format!(r#","motion":"{name}""#);
let hashes: Vec<u64> = (0..3).map(|clip| shoot(name, &motion, clip)).collect();
for (k, h) in hashes.iter().enumerate() {
let t = PROGRAMME_TIMES[k];
assert_ne!(*h, still, "{kind} {name} a t={t} rend le fond immobile");
}
assert!(
hashes[0] != hashes[1] && hashes[1] != hashes[2] && hashes[0] != hashes[2],
"{kind} {name} : deux instants rendent la meme image ({hashes:x?})"
);
// Fonction pure : le même instant recomposé par un autre compositeur donne le même
// octet.
let again = shoot(name, &motion, 1);
assert_eq!(again, hashes[1], "{kind} {name} n'est pas reproductible");
}
}
}