f67d38b35cc5
generators.rs
//! Synthetic media: Bars and Tone, Color Matte, Black/Transparent Video, Universal Counting Leader,
//! and procedural demo scenes (so the editor has beautiful moving footage with no files at all).
//!
//! Every generator is a pure function of (settings, media time, output scale): deterministic and
//! resolution-independent, so low-resolution playback renders directly at the reduced size.
//!
//! Counting Leader beeps last one source frame at each second mark. Use exact audio sample
//! positions and the rational source frame rate for the gate, without rounded timestamp boundaries.
use std::f32::consts::{PI, TAU};
use std::sync::Arc;
use filmcraft_color::ColorInfo;
use filmcraft_frame::{AudioBuffer, VideoFrame};
use filmcraft_time::{FrameRate, TICKS_PER_SECOND, Tick};
use rayon::prelude::*;
use serde::{Deserialize, Serialize};
use crate::digits::{Canvas, draw_text, text_width};
use crate::{AudioStreamInfo, FrameCache, FrameRequest, MediaError, MediaInfo, MediaKind, MediaSource, Result, VideoStreamInfo};
/// Generator frames are RGBA8 and cached. Keep one project-requested frame within the media
/// working-set budget before allocating it.
const MAX_GENERATOR_PIXELS: u64 = 1 << 25;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DemoScene {
Aurora,
OceanSunset,
CityNight,
Dunes,
Plasma,
Forest,
}
impl DemoScene {
pub const ALL: [DemoScene; 6] = [DemoScene::OceanSunset, DemoScene::Aurora, DemoScene::CityNight, DemoScene::Dunes, DemoScene::Forest, DemoScene::Plasma];
pub fn file_name(self) -> &'static str {
match self {
DemoScene::Aurora => "Aurora_Timelapse.mp4",
DemoScene::OceanSunset => "Ocean_Sunset.mp4",
DemoScene::CityNight => "City_Night_Drive.mp4",
DemoScene::Dunes => "Desert_Dunes.mp4",
DemoScene::Plasma => "Neon_Loop.mov",
DemoScene::Forest => "Misty_Forest.mp4",
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Generator {
BarsAndTone,
ColorMatte {
color: [f32; 4],
},
BlackVideo,
TransparentVideo,
CountingLeader,
Demo(DemoScene),
/// Pure audio tone (Hz, dBFS).
Tone {
hz: f32,
db: f32,
},
}
impl Generator {
pub fn label(&self) -> String {
match self {
Generator::BarsAndTone => "Bars and Tone".into(),
Generator::ColorMatte { .. } => "Color Matte".into(),
Generator::BlackVideo => "Black Video".into(),
Generator::TransparentVideo => "Transparent Video".into(),
Generator::CountingLeader => "Universal Counting Leader".into(),
Generator::Demo(d) => d.file_name().into(),
Generator::Tone { hz, .. } => format!("Tone {hz} Hz"),
}
}
fn has_audio(&self) -> bool {
matches!(self, Generator::BarsAndTone | Generator::CountingLeader | Generator::Demo(_) | Generator::Tone { .. })
}
fn has_video(&self) -> bool {
!matches!(self, Generator::Tone { .. })
}
}
/// A generator bound to a frame size/rate/duration.
pub struct GeneratorSource {
pub generator: Generator,
info: MediaInfo,
cache: FrameCache<(i64, u16)>,
}
impl GeneratorSource {
pub fn new(generator: Generator, width: u32, height: u32, rate: FrameRate, duration: Tick) -> Self {
let video = generator.has_video().then(|| VideoStreamInfo {
width,
height,
frame_rate: rate,
par: (1, 1),
codec: match &generator {
Generator::Demo(_) => "H.264 (synthetic)".into(),
_ => "Synthetic".into(),
},
pixel_format: "RGBA 8-bit".into(),
color: ColorInfo::SRGB_FULL,
has_alpha: matches!(generator, Generator::TransparentVideo),
bitrate: None,
hdr: None,
color_assumed: None,
});
let audio =
generator.has_audio().then(|| AudioStreamInfo { sample_rate: 48_000, channels: 2, codec: "PCM (synthetic)".into(), bits_per_sample: Some(32) });
let info = MediaInfo {
name: generator.label(),
kind: if matches!(generator, Generator::Demo(_)) { MediaKind::Movie } else { MediaKind::Synthetic },
duration,
video,
audio_streams: audio.into_iter().collect(),
container: if matches!(generator, Generator::Demo(_)) { "Synthetic MPEG-4".into() } else { "Synthetic".into() },
start_timecode: None,
file_size: None,
};
Self { generator, info, cache: FrameCache::new(256 << 20) }
}
pub fn with_name(mut self, name: &str) -> Self {
self.info.name = name.to_string();
self
}
/// The default demo clip for a scene (1080p, 23.976, 12–20 s).
pub fn demo(scene: DemoScene) -> Self {
let secs = match scene {
DemoScene::OceanSunset => 18,
DemoScene::Aurora => 16,
DemoScene::CityNight => 14,
DemoScene::Dunes => 15,
DemoScene::Plasma => 10,
DemoScene::Forest => 12,
};
Self::new(Generator::Demo(scene), 1920, 1080, FrameRate::FPS_23_976, Tick(secs * TICKS_PER_SECOND))
}
}
impl MediaSource for GeneratorSource {
fn info(&self) -> &MediaInfo {
&self.info
}
fn video_frame(&self, req: FrameRequest) -> Result<Arc<VideoFrame>> {
let v = self.info.video.as_ref().ok_or(MediaError::NoStream("video"))?;
let rate = v.frame_rate;
let frame = rate.frame_at(req.time.max(Tick::ZERO));
let scale = req.scale.clamp(1.0 / 64.0, 1.0);
let bucket = (scale * 64.0).round() as u16;
let s = bucket as f32 / 64.0;
let (w, h) = (((v.width as f32 * s).round() as u32).max(2), ((v.height as f32 * s).round() as u32).max(2));
let t = rate.tick_of(frame).seconds() as f32;
self.cache.get_or_insert_with((frame, bucket), || {
let px = render(&self.generator, w, h, t, frame, rate)?;
Ok(Arc::new(VideoFrame::rgba8(w, h, px).with_pts(rate.tick_of(frame))))
})
}
fn audio(&self, start: i64, frames: usize, sample_rate: u32) -> Result<AudioBuffer> {
if !self.generator.has_audio() {
return Err(MediaError::NoStream("audio"));
}
crate::validate_audio_buffer_shape(2, frames)?;
let mut out = AudioBuffer::silence(sample_rate, 2, frames);
let sr = f64::from(sample_rate.max(1));
let total = self.info.duration.to_units_floor(sample_rate as i64);
let frame_rate = self.info.frame_rate().sane();
for i in 0..frames {
let n = start + i as i64;
if n < 0 || n >= total {
continue;
}
// f64 time: in f32 a phase tens of seconds in has milliradians of error, heard as hiss
let t = n as f64 / sr;
let (l, r) = audio_sample(&self.generator, t, n, sample_rate, frame_rate);
out.channels[0][i] = l;
out.channels[1][i] = r;
}
Ok(out)
}
}
fn db(db: f32) -> f32 {
10f32.powf(db / 20.0)
}
/// `sin(2π · hz · t)` with the phase wrapped in f64, exact however late `t` is.
fn osc(hz: f64, t: f64) -> f32 {
((hz * t).fract() * std::f64::consts::TAU).sin() as f32
}
/// Band-limited noise: random values `rate` times a second, joined by a smooth curve, so it
/// rustles instead of hissing like per-sample white noise (#1265).
fn soft_noise(t: f64, rate: f64) -> f32 {
let x = t * rate;
let i = x.floor();
let f = (x - i) as f32;
let (a, b) = (hash(i as i64), hash(i as i64 + 1));
a + (b - a) * f * f * (3.0 - 2.0 * f)
}
fn hash(n: i64) -> f32 {
let mut x = n as u64 ^ 0x9E37_79B9_7F4A_7C15;
x = (x ^ (x >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
x = (x ^ (x >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
x ^= x >> 31;
(x >> 40) as f32 / (1u64 << 24) as f32 * 2.0 - 1.0
}
fn audio_sample(g: &Generator, t: f64, n: i64, sample_rate: u32, frame_rate: FrameRate) -> (f32, f32) {
match g {
Generator::BarsAndTone => {
let s = osc(1000.0, t) * db(-20.0);
(s, s)
}
Generator::Tone { hz, db: d } => {
let s = osc(f64::from(*hz), t) * db(*d);
(s, s)
}
Generator::CountingLeader => {
// 1 kHz beep for one frame at each second mark (the "2-pop" style beep).
let in_frame = sample_rate != 0
&& i128::from(n.rem_euclid(i64::from(sample_rate))) * i128::from(frame_rate.num) < i128::from(sample_rate) * i128::from(frame_rate.den);
let s = if in_frame { osc(1000.0, t) * db(-20.0) } else { 0.0 };
(s, s)
}
Generator::Demo(scene) => demo_audio(*scene, t),
_ => (0.0, 0.0),
}
}
fn demo_audio(scene: DemoScene, t: f64) -> (f32, f32) {
// A slow pad: chord tones with gentle detune + scene texture.
let chord: &[f32] = match scene {
DemoScene::OceanSunset => &[220.0, 277.18, 329.63, 440.0],
DemoScene::Aurora => &[196.0, 246.94, 293.66, 369.99],
DemoScene::CityNight => &[110.0, 164.81, 207.65, 246.94],
DemoScene::Dunes => &[146.83, 220.0, 261.63, 329.63],
DemoScene::Plasma => &[130.81, 196.0, 261.63, 311.13],
DemoScene::Forest => &[174.61, 220.0, 261.63, 349.23],
};
let env = 0.6 + 0.4 * osc(1.0 / 8.0, t);
let mut l = 0.0;
let mut r = 0.0;
for (i, f) in chord.iter().enumerate() {
let f = f64::from(*f);
let trem = 0.8 + 0.2 * osc(0.2 + i as f64 * 0.07, t);
l += osc(f * 1.002, t) * trem;
r += osc(f * 0.998, t) * trem;
}
// scene texture (surf, rustle, city hum): soft noise well below the pad
let noise = soft_noise(t, 600.0)
* match scene {
DemoScene::OceanSunset => 0.08 * (0.5 + 0.5 * osc(1.0 / 6.0, t)).powi(2),
DemoScene::Forest => 0.02,
DemoScene::CityNight => 0.03,
_ => 0.01,
};
// A soft kick in the city/plasma scenes to make waveforms interesting.
let beat = if matches!(scene, DemoScene::CityNight | DemoScene::Plasma) {
let bt = (t * 2.0).fract() / 2.0;
osc(55.0, bt) * (-bt as f32 * 18.0).exp() * 0.9
} else {
0.0
};
let g = 0.09 * env;
(l * g + noise + beat, r * g + noise * 0.9 + beat)
}
fn lerp3(a: [f32; 3], b: [f32; 3], t: f32) -> [f32; 3] {
[a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t]
}
fn smoothstep(e0: f32, e1: f32, x: f32) -> f32 {
let t = ((x - e0) / (e1 - e0)).clamp(0.0, 1.0);
t * t * (3.0 - 2.0 * t)
}
fn vnoise(x: f32, y: f32) -> f32 {
let (xi, yi) = (x.floor(), y.floor());
let (xf, yf) = (x - xi, y - yi);
let h = |a: f32, b: f32| hash((a as i64).wrapping_mul(73_856_093) ^ (b as i64).wrapping_mul(19_349_663));
let u = xf * xf * (3.0 - 2.0 * xf);
let v = yf * yf * (3.0 - 2.0 * yf);
let a = h(xi, yi);
let b = h(xi + 1.0, yi);
let c = h(xi, yi + 1.0);
let d = h(xi + 1.0, yi + 1.0);
(a + (b - a) * u) + ((c + (d - c) * u) - (a + (b - a) * u)) * v
}
fn fbm(x: f32, y: f32, oct: u32) -> f32 {
let mut s = 0.0;
let mut a = 0.5;
let (mut fx, mut fy) = (x, y);
for _ in 0..oct {
s += a * vnoise(fx, fy);
fx = fx * 2.03 + 1.7;
fy = fy * 2.01 + 9.2;
a *= 0.5;
}
s
}
fn to8(c: [f32; 3]) -> [u8; 4] {
[(c[0].clamp(0.0, 1.0) * 255.0) as u8, (c[1].clamp(0.0, 1.0) * 255.0) as u8, (c[2].clamp(0.0, 1.0) * 255.0) as u8, 255]
}
/// Render a generator frame as straight-alpha sRGB RGBA8.
pub fn render(g: &Generator, w: u32, h: u32, t: f32, frame: i64, rate: FrameRate) -> Result<Vec<u8>> {
let pixels = u64::from(w).checked_mul(u64::from(h)).ok_or_else(|| MediaError::Decode("generator frame dimensions overflow".into()))?;
if pixels > MAX_GENERATOR_PIXELS {
return Err(MediaError::Decode(format!("generator frame has {pixels} pixels; limit is {MAX_GENERATOR_PIXELS}")));
}
let (wu, hu) = (w as usize, h as usize);
let len = wu.checked_mul(hu).and_then(|n| n.checked_mul(4)).ok_or_else(|| MediaError::Decode("generator frame byte count overflows".into()))?;
let mut px = Vec::new();
px.try_reserve_exact(len).map_err(|_| MediaError::Decode("cannot allocate generator frame".into()))?;
px.resize(len, 0);
match g {
Generator::BarsAndTone => bars(&mut px, wu, hu),
Generator::ColorMatte { color } => {
let c = [(color[0] * 255.0) as u8, (color[1] * 255.0) as u8, (color[2] * 255.0) as u8, (color[3] * 255.0) as u8];
px.as_chunks_mut::<4>().0.iter_mut().for_each(|p| p.copy_from_slice(&c));
}
Generator::BlackVideo => px.as_chunks_mut::<4>().0.iter_mut().for_each(|p| p.copy_from_slice(&[0, 0, 0, 255])),
Generator::TransparentVideo | Generator::Tone { .. } => {}
Generator::CountingLeader => leader(&mut px, wu, hu, t, frame, rate),
Generator::Demo(scene) => {
let scene = *scene;
px.par_chunks_mut(wu * 4).enumerate().for_each(|(y, row)| {
let v = y as f32 / hu as f32;
for x in 0..wu {
let u = x as f32 / wu as f32;
let c = demo_pixel(scene, u, v, wu as f32 / hu as f32, t);
row[x * 4..x * 4 + 4].copy_from_slice(&to8(c));
}
});
}
}
Ok(px)
}
fn bars(px: &mut [u8], w: usize, h: usize) {
// SMPTE RP 219-style HD bars (75% bars, 40% grey side panels, ramp row, PLUGE row).
let g40 = [104, 104, 104, 255];
let bars75: [[u8; 4]; 7] =
[[191, 191, 191, 255], [191, 191, 0, 255], [0, 191, 191, 255], [0, 191, 0, 255], [191, 0, 191, 255], [191, 0, 0, 255], [0, 0, 191, 255]];
let side = w / 8;
let bw = (w - 2 * side) as f32 / 7.0;
let r1 = h * 7 / 12;
let r2 = r1 + h / 12;
let r3 = r2 + h / 12;
for y in 0..h {
for x in 0..w {
let c: [u8; 4] = if y < r1 {
if x < side || x >= w - side { g40 } else { bars75[(((x - side) as f32 / bw) as usize).min(6)] }
} else if y < r2 {
if x < side {
[0, 255, 255, 255]
} else if x >= w - side {
[0, 0, 255, 255]
} else if x < side + bw as usize {
[235, 235, 235, 255]
} else {
[191, 191, 191, 255]
}
} else if y < r3 {
if x < side {
[255, 255, 0, 255]
} else if x >= w - side {
[255, 0, 0, 255]
} else {
let v = ((x - side) as f32 / (w - 2 * side) as f32 * 255.0) as u8;
[v, v, v, 255]
}
} else {
let fx = x as f32 / w as f32;
let v: u8 = if fx < 0.125 {
38
} else if fx < 0.3 {
0
} else if fx < 0.5 {
255
} else if fx < 0.65 {
0
} else if fx < 0.68 {
5
} else if fx < 0.71 {
0
} else if fx < 0.74 {
10
} else if fx < 0.875 {
0
} else {
38
};
[v, v, v, 255]
};
px[(y * w + x) * 4..(y * w + x) * 4 + 4].copy_from_slice(&c);
}
}
}
fn leader(px: &mut [u8], w: usize, h: usize, t: f32, _frame: i64, _rate: FrameRate) {
// 8-second countdown: number = 8 - floor(t), sweep angle = fract(t).
let n = (8 - t.floor() as i64).clamp(2, 8);
let sweep = t.fract() * TAU;
let (cx, cy) = (w as f32 / 2.0, h as f32 / 2.0);
let r_out = h as f32 * 0.42;
px.par_chunks_mut(w * 4).enumerate().for_each(|(y, row)| {
for x in 0..w {
let dx = x as f32 - cx;
let dy = y as f32 - cy;
let d = (dx * dx + dy * dy).sqrt();
let ang = (dx.atan2(-dy) + TAU) % TAU;
let mut c = if ang < sweep { [0.55, 0.55, 0.55] } else { [0.78, 0.78, 0.78] };
let ring = |r: f32, wdt: f32| (d - r).abs() < wdt;
if ring(r_out, 3.0) || ring(r_out * 0.86, 2.0) || dx.abs() < 1.5 || dy.abs() < 1.5 {
c = [0.1, 0.1, 0.1];
}
if d > r_out + 3.0 {
c = [0.2, 0.2, 0.2];
}
row[x * 4..x * 4 + 4].copy_from_slice(&to8(c));
}
});
let dh = (h as i32) / 3;
let s = n.to_string();
let tw = text_width(dh, &s);
draw_text(&mut Canvas { buf: px, width: w, height: h }, (w as i32 - tw) / 2, (h as i32 - dh) / 2, dh, &s, [20, 20, 20, 255]);
}
fn demo_pixel(scene: DemoScene, u: f32, v: f32, aspect: f32, t: f32) -> [f32; 3] {
match scene {
DemoScene::OceanSunset => {
let horizon = 0.58;
let sun = [0.5 + 0.02 * (t * 0.05).sin(), 0.42 + t * 0.006];
if v < horizon {
let k = v / horizon;
let mut c = lerp3([0.16, 0.10, 0.32], [0.98, 0.52, 0.28], k.powf(1.6));
c = lerp3(c, [1.0, 0.82, 0.55], smoothstep(0.75, 1.0, k) * 0.6);
let dx = (u - sun[0]) * aspect;
let dy = v - sun[1];
let d = (dx * dx + dy * dy).sqrt();
let glow = (-d * 9.0).exp();
c = lerp3(c, [1.0, 0.93, 0.75], glow * 0.8);
if d < 0.055 {
c = [1.0, 0.95, 0.82];
}
// wispy clouds
let cl = fbm(u * 4.0 + t * 0.02, v * 14.0, 4);
let cm = smoothstep(0.15, 0.45, cl) * smoothstep(0.1, 0.45, v) * (1.0 - smoothstep(0.45, 0.55, v));
lerp3(c, [0.55, 0.28, 0.35], cm * 0.55)
} else {
let k = (v - horizon) / (1.0 - horizon);
let mut c = lerp3([0.35, 0.18, 0.28], [0.03, 0.05, 0.12], k.powf(0.7));
let wave = fbm(u * 18.0 * (1.0 - k * 0.6) + t * 0.3, (v - horizon) * 90.0 / (0.3 + k) - t * 1.4, 3);
let dx = (u - sun[0]) * aspect;
let path = (-dx * dx * 160.0 / (0.2 + k * 2.0)).exp();
let sparkle = smoothstep(0.05, 0.4, wave) * path;
c = lerp3(c, [1.0, 0.78, 0.5], sparkle * (1.0 - k * 0.5));
lerp3(c, [0.9, 0.5, 0.35], path * 0.25 * (1.0 - k))
}
}
DemoScene::Aurora => {
let mut c = lerp3([0.01, 0.02, 0.08], [0.02, 0.1, 0.18], v);
// stars
let sx = (u * 900.0).floor();
let sy = (v * 500.0).floor();
let st = hash((sx as i64) * 7919 + sy as i64 * 104_729);
if st > 0.994 && v < 0.7 {
let tw = 0.6 + 0.4 * (t * 3.0 + st * 100.0).sin();
c = lerp3(c, [0.9, 0.95, 1.0], tw);
}
// aurora curtains
for (i, col) in [[0.2, 1.0, 0.55], [0.55, 0.3, 1.0], [0.1, 0.9, 0.8]].iter().enumerate() {
let fi = i as f32;
let base = 0.28 + 0.08 * fi + 0.06 * (u * 3.0 + t * 0.15 + fi).sin() + 0.05 * fbm(u * 3.0 + t * 0.05, fi, 3);
let dy = v - base;
let ray = 0.5 + 0.5 * fbm(u * 40.0 + t * 0.4 + fi * 10.0, fi, 2);
let a = (-dy * dy * 90.0).exp() * if dy > 0.0 { 1.0 } else { (dy * 12.0).exp() } * ray;
c = lerp3(c, *col, (a * 0.8).min(1.0));
}
// mountains
let m = 0.72 + 0.08 * fbm(u * 3.0, 3.3, 5) + 0.05 * (u * 5.0).sin();
if v > m {
let snow = smoothstep(0.02, 0.0, v - m) * 0.3;
c = lerp3([0.02, 0.03, 0.05], [0.4, 0.5, 0.6], snow);
}
// reflection lake
if v > 0.9 {
c = lerp3(c, [0.05, 0.25, 0.2], 0.3 * (1.0 + (v * 400.0 + t * 4.0).sin()) * 0.5);
}
c
}
DemoScene::CityNight => {
let mut c = lerp3([0.05, 0.02, 0.15], [0.55, 0.2, 0.35], v.powf(2.2));
let layers = [(0.15, 0.55, [0.12, 0.08, 0.2], 0.02), (0.28, 0.62, [0.07, 0.05, 0.12], 0.05), (0.45, 0.7, [0.03, 0.02, 0.06], 0.12)];
for (li, (bw, base, col, speed)) in layers.iter().enumerate() {
let x = u * aspect / bw + t * speed;
let bi = x.floor();
let hgt = base - 0.32 * (0.5 + 0.5 * hash(bi as i64 * 31 + li as i64));
if v > hgt {
c = *col;
let wx = (x.fract() * 6.0).floor();
let wy = ((v - hgt) * 70.0).floor();
let lit = hash((bi as i64) * 1000 + wx as i64 * 37 + wy as i64 * 101 + li as i64);
if (x.fract() * 6.0).fract() < 0.55 && ((v - hgt) * 70.0).fract() < 0.5 && lit > 0.35 && x.fract() > 0.08 && x.fract() < 0.92 {
let warm = [1.0, 0.8 + 0.1 * lit, 0.45];
c = lerp3(c, warm, 0.35 + 0.35 * (li as f32 / 2.0));
}
}
}
// light trails on the road
if v > 0.86 {
c = [0.04, 0.03, 0.06];
for k in 0..6 {
let lane = 0.88 + k as f32 * 0.02;
let d = (v - lane).abs();
let streak = (u * 6.0 - t * (1.5 + k as f32 * 0.4) + k as f32).fract();
let col = if k % 2 == 0 { [1.0, 0.25, 0.2] } else { [1.0, 0.9, 0.7] };
c = lerp3(c, col, (-d * 900.0).exp() * smoothstep(0.0, 0.8, streak));
}
}
c
}
DemoScene::Dunes => {
let mut c = lerp3([0.35, 0.6, 0.9], [0.98, 0.85, 0.65], smoothstep(0.0, 0.5, v));
let sun_d = ((u - 0.75) * aspect).hypot(v - 0.22);
c = lerp3(c, [1.0, 0.97, 0.85], (-sun_d * 14.0).exp());
for k in 0..4 {
let fk = k as f32;
let x = u * (1.0 + fk * 0.6) + t * 0.01 * (fk + 1.0);
let ridge = 0.45 + fk * 0.12 + 0.06 * (x * 6.0 + fk).sin() + 0.03 * fbm(x * 4.0, fk, 3);
if v > ridge {
let shade = 0.5 + 0.5 * ((x * 6.0 + fk).cos());
let base = lerp3([0.78, 0.45, 0.22], [0.98, 0.72, 0.45], shade);
c = lerp3(base, [0.55, 0.28, 0.15], (v - ridge).min(0.2) * 2.0 * (fk / 3.0));
}
}
c
}
DemoScene::Plasma => {
let x = u * aspect * 3.0;
let y = v * 3.0;
let p = (x + t).sin() + (y * 1.3 - t * 0.7).sin() + ((x + y + t * 0.5).sin()) + ((x * x + y * y).sqrt() * 2.0 - t * 1.2).sin();
let h = p * 0.25 + t * 0.05;
[0.5 + 0.5 * (PI * h).sin(), 0.5 + 0.5 * (PI * h + 2.1).sin() * 0.6, 0.5 + 0.5 * (PI * h + 4.2).sin()]
}
DemoScene::Forest => {
let mut c = lerp3([0.75, 0.82, 0.8], [0.35, 0.45, 0.4], v);
// god rays
let ray = 0.5 + 0.5 * fbm(u * 8.0 - v * 3.0 + t * 0.05, 1.0, 2);
c = lerp3(c, [1.0, 0.97, 0.85], ray * (1.0 - v) * 0.35);
for k in 0..5 {
let fk = k as f32;
let depth = 1.0 - fk / 5.0;
let spacing = 0.12 + fk * 0.03;
let x = u / spacing + t * 0.03 * (fk + 1.0) + fk * 3.3;
let trunk_x = x.fract();
let tw = 0.08 + 0.05 * (1.0 - depth);
let id = x.floor();
if (trunk_x - 0.5).abs() < tw && hash(id as i64 * 13 + k) > -0.2 {
let dark = lerp3([0.45, 0.5, 0.48], [0.05, 0.07, 0.05], 1.0 - depth * 0.8);
c = lerp3(c, dark, 0.85);
}
}
let mist = smoothstep(0.55, 1.0, v) * (0.6 + 0.4 * fbm(u * 3.0 + t * 0.1, v * 5.0, 3));
lerp3(c, [0.85, 0.88, 0.86], mist * 0.6)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn deterministic_and_scaled() {
let g = GeneratorSource::demo(DemoScene::OceanSunset);
let a = g.video_frame(FrameRequest { time: Tick(TICKS_PER_SECOND), scale: 0.25 }).unwrap();
assert_eq!((a.width, a.height), (480, 270));
let b =
render(&Generator::Demo(DemoScene::OceanSunset), 480, 270, FrameRate::FPS_23_976.tick_of(23).seconds() as f32, 23, FrameRate::FPS_23_976).unwrap();
assert_eq!(a.to_rgba8(), b);
}
#[test]
fn bars_values() {
let px = render(&Generator::BarsAndTone, 800, 600, 0.0, 0, FrameRate::FPS_25).unwrap();
// first bar after the side panel is 75% white
let i = (10 * 800 + 150) * 4;
assert_eq!(&px[i..i + 4], &[191, 191, 191, 255]);
let g = GeneratorSource::new(Generator::BarsAndTone, 800, 600, FrameRate::FPS_25, Tick(TICKS_PER_SECOND));
let a = g.audio(0, 480, 48000).unwrap();
let peak = a.peaks()[0];
assert!((peak - db(-20.0)).abs() < 1e-3);
}
#[test]
fn hostile_audio_request_is_rejected_before_allocation() {
let g = GeneratorSource::new(Generator::BarsAndTone, 800, 600, FrameRate::FPS_25, Tick(TICKS_PER_SECOND));
// a project-stored speed of 1e12 on a 1 s block asks for this many source frames
assert!(g.audio(0, crate::MAX_AUDIO_BUFFER_BYTES, 48_000).is_err());
assert!(g.audio(0, usize::MAX / 8, 48_000).is_err());
assert!(g.audio(0, 480, 48_000).is_ok());
}
/// #1265: the demo sound is a pad with a soft texture, not hiss: per-sample white noise has a
/// second difference as large as the signal itself
#[test]
fn demo_audio_has_no_hiss() {
for scene in DemoScene::ALL {
let g = GeneratorSource::new(Generator::Demo(scene), 64, 36, FrameRate::FPS_24, Tick(60 * TICKS_PER_SECOND));
let a = g.audio(48_000, 48_000, 48_000).unwrap();
let x = &a.channels[0];
let rms = |v: &mut dyn Iterator<Item = f32>| {
let (s, n) = v.fold((0.0f64, 0usize), |(s, n), y| (s + f64::from(y * y), n + 1));
(s / n.max(1) as f64).sqrt()
};
let signal = rms(&mut x.iter().copied());
let rough = rms(&mut x.windows(3).map(|w| w[2] - 2.0 * w[1] + w[0]));
assert!(signal > 0.01 && rough / signal < 0.1, "{scene:?}: {rough} / {signal}");
}
}
/// Tones stay exact late in long media (f32 time put milliradians of phase noise in at 50 s).
#[test]
fn tone_phase_is_exact_late() {
let g = GeneratorSource::new(Generator::Tone { hz: 1000.0, db: 0.0 }, 0, 0, FrameRate::FPS_24, Tick(60 * TICKS_PER_SECOND));
let n0 = 48_000 * 50 + 7;
let a = g.audio(n0, 480, 48_000).unwrap();
for (i, y) in a.channels[0].iter().enumerate() {
let t = (n0 + i as i64) as f64 / 48_000.0;
let want = (std::f64::consts::TAU * 1000.0 * t).sin();
assert!((f64::from(*y) - want).abs() < 1e-4, "sample {i}: {y} vs {want}");
}
}
#[test]
fn counting_leader_beeps_last_exactly_one_source_frame() {
let sample_rate = 48_000;
for rate in [FrameRate::FPS_24, FrameRate::FPS_25, FrameRate::FPS_30, FrameRate::FPS_50, FrameRate::FPS_60, FrameRate::FPS_23_976, FrameRate::FPS_29_97]
{
let source = GeneratorSource::new(Generator::CountingLeader, 64, 36, rate, Tick(3 * TICKS_PER_SECOND));
let carrier = GeneratorSource::new(Generator::Tone { hz: 1000.0, db: -20.0 }, 64, 36, rate, Tick(3 * TICKS_PER_SECOND));
let frame_samples = (sample_rate as u64 * rate.den as u64).div_ceil(rate.num as u64) as usize;
for start in [0, sample_rate as i64, 2 * sample_rate as i64] {
let audio = source.audio(start, frame_samples + 8, sample_rate).unwrap();
let expected = carrier.audio(start, frame_samples, sample_rate).unwrap();
for (channel, carrier_channel) in audio.channels.iter().zip(&expected.channels) {
assert!(carrier_channel.iter().any(|s| s.abs() > 0.05), "{rate:?}, start {start}: carrier should be audible");
assert_eq!(
&channel[..frame_samples],
carrier_channel.as_slice(),
"{rate:?}, start {start}: in-frame beep differs from the ungated carrier"
);
assert!(channel[frame_samples..].iter().all(|s| *s == 0.0), "{rate:?}, start {start}: beep extends beyond one frame");
}
}
}
}
#[test]
fn counting_leader_custom_rate_stops_at_exact_sample_boundary() {
let sample_rate = 41_000;
let source = GeneratorSource::new(Generator::CountingLeader, 64, 36, FrameRate { num: 41, den: 1 }, Tick(3 * TICKS_PER_SECOND));
let carrier = GeneratorSource::new(Generator::Tone { hz: 1000.0, db: -20.0 }, 64, 36, FrameRate { num: 41, den: 1 }, Tick(3 * TICKS_PER_SECOND));
for start in [0, 41_000, 82_000] {
let audio = source.audio(start, 1_008, sample_rate).unwrap();
let expected = carrier.audio(start, 1_000, sample_rate).unwrap();
for (channel, carrier_channel) in audio.channels.iter().zip(&expected.channels) {
assert_eq!(&channel[..1_000], carrier_channel.as_slice(), "custom-rate beep stops before the frame boundary");
assert!(channel[1_000..].iter().all(|s| *s == 0.0), "sample exactly at frame boundary must be silent");
}
}
}
#[test]
fn counting_leader_gate_is_independent_of_request_boundaries() {
for sample_rate in [41_000u32, 44_100, 48_000] {
for rate in [FrameRate::FPS_24, FrameRate::FPS_60, FrameRate::FPS_23_976, FrameRate::FPS_29_97, FrameRate { num: 41, den: 1 }] {
let source = GeneratorSource::new(Generator::CountingLeader, 64, 36, rate, Tick(3 * TICKS_PER_SECOND));
let frame_samples = (u64::from(sample_rate) * rate.den as u64).div_ceil(rate.num as u64) as usize;
let start = i64::from(sample_rate) - 3;
let audio = source.audio(start, frame_samples + 8, sample_rate).unwrap();
for channel in &audio.channels {
assert!(channel[..3].iter().all(|s| *s == 0.0), "{rate:?}, {sample_rate}: previous second should be silent");
assert!(channel[3..3 + frame_samples].iter().any(|s| s.abs() > 0.05), "{rate:?}, {sample_rate}: missing beep");
assert!(channel[3 + frame_samples..].iter().all(|s| *s == 0.0), "{rate:?}, {sample_rate}: beep exceeds frame");
}
let first = source.audio(start, 5, sample_rate).unwrap();
let second = source.audio(start + 5, frame_samples + 3, sample_rate).unwrap();
for c in 0..2 {
let split: Vec<_> = first.channels[c].iter().chain(&second.channels[c]).copied().collect();
assert_eq!(split, audio.channels[c], "{rate:?}, {sample_rate}: split requests change samples");
}
let end = source.audio(i64::from(sample_rate) + frame_samples as i64 - 2, 6, sample_rate).unwrap();
assert!(end.channels.iter().all(|channel| channel[2..].iter().all(|s| *s == 0.0)), "{rate:?}, {sample_rate}: end-crossing block leaks");
}
}
}
#[test]
fn counting_leader_malformed_rates_use_default_frame_gate() {
let sample_rate = 48_000u32;
let default_rate = FrameRate::default();
let frame_samples = (u64::from(sample_rate) * default_rate.den as u64).div_ceil(default_rate.num as u64);
let start = frame_samples as i64 - 2;
let carrier = GeneratorSource::new(Generator::Tone { hz: 1000.0, db: -20.0 }, 64, 36, default_rate, Tick(3 * TICKS_PER_SECOND));
let expected = carrier.audio(start, 2, sample_rate).unwrap();
assert!(expected.channels.iter().all(|channel| channel.iter().any(|sample| sample.abs() > 0.05)));
for rate in [FrameRate { num: 41, den: 0 }, FrameRate { num: 0, den: 0 }, FrameRate { num: i64::MIN, den: 1 }, FrameRate { num: 1, den: i64::MIN }] {
let source = GeneratorSource::new(Generator::CountingLeader, 64, 36, rate, Tick(3 * TICKS_PER_SECOND));
let audio = source.audio(start, 8, sample_rate).unwrap();
for (channel, carrier_channel) in audio.channels.iter().zip(&expected.channels) {
assert_eq!(&channel[..2], carrier_channel.as_slice(), "{rate:?}: fallback beep stops before the frame boundary");
assert!(channel[2..].iter().all(|sample| *sample == 0.0), "{rate:?}: fallback gate exceeds one frame");
}
let fallback = GeneratorSource::new(Generator::CountingLeader, 64, 36, default_rate, Tick(3 * TICKS_PER_SECOND));
assert_eq!(audio.channels, fallback.audio(start, 8, sample_rate).unwrap().channels, "{rate:?}: changed fallback");
}
}
#[test]
fn counting_leader_gate_handles_zero_and_hostile_rates() {
let invalid = [FrameRate { num: 0, den: 0 }, FrameRate { num: i64::MIN, den: 1 }, FrameRate { num: 1, den: i64::MIN }, FrameRate { num: 41, den: 0 }];
let rates =
invalid.into_iter().chain([FrameRate { num: 1, den: i64::MAX }, FrameRate { num: i64::MAX, den: 1 }, FrameRate { num: i64::MAX, den: i64::MAX }]);
for rate in rates {
let source = GeneratorSource::new(Generator::CountingLeader, 64, 36, rate, Tick(3 * TICKS_PER_SECOND));
for sample_rate in [0, 1, 48_000, u32::MAX] {
for start in [-2, 0, 1] {
let audio = std::panic::catch_unwind(|| source.audio(start, 8, sample_rate)).unwrap().unwrap();
assert!(audio.channels.iter().flatten().all(|s| s.is_finite()), "{rate:?}, {sample_rate}: non-finite audio");
if sample_rate == 0 {
assert!(audio.channels.iter().flatten().all(|s| *s == 0.0));
}
if invalid.contains(&rate) {
let fallback = GeneratorSource::new(Generator::CountingLeader, 64, 36, FrameRate::default(), Tick(3 * TICKS_PER_SECOND));
assert_eq!(audio.channels, fallback.audio(start, 8, sample_rate).unwrap().channels, "{rate:?}: changed fallback");
}
}
}
}
}
#[test]
fn all_scenes_render() {
for s in DemoScene::ALL {
let px = render(&Generator::Demo(s), 64, 36, 1.5, 36, FrameRate::FPS_24).unwrap();
assert!(px.as_chunks::<4>().0.iter().any(|p| p[0] > 20 || p[1] > 20 || p[2] > 20));
}
let px = render(&Generator::CountingLeader, 64, 36, 1.5, 36, FrameRate::FPS_24).unwrap();
assert_eq!(px.len(), 64 * 36 * 4);
}
#[test]
fn oversized_generator_frames_are_rejected_before_allocation() {
let err = render(&Generator::BlackVideo, 32_768, 32_768, 0.0, 0, FrameRate::FPS_24).unwrap_err();
assert!(err.to_string().contains("limit"), "{err}");
}
/// #1947: the counting leader's beep at each second mark lasts one frame of its own rate,
/// not a fixed 1/24 s: 800 samples at 60 fps and 48 kHz, 2000 at 24 fps, 1920 at 25 fps.
#[test]
fn counting_leader_beep_lasts_one_frame_of_its_rate() {
for (rate, beep) in [(FrameRate::FPS_60, 800usize), (FrameRate::FPS_24, 2000), (FrameRate::FPS_25, 1920), (FrameRate::FPS_29_97, 1602)] {
let g = GeneratorSource::new(Generator::CountingLeader, 64, 36, rate, Tick(3 * TICKS_PER_SECOND));
let a = g.audio(0, 96_000, 48_000).unwrap();
let l = &a.channels[0];
let last_nonzero = |from: usize, to: usize| (from..to).rev().find(|&i| l[i] != 0.0);
// the first beep: sound up to its last sample, silence from there to the next second
assert!(
last_nonzero(0, 48_000).is_some_and(|i| i + 1 >= beep - 1 && i < beep),
"{rate}: first beep ends at {:?}, expected {beep}",
last_nonzero(0, 48_000)
);
assert!(l[beep..48_000].iter().all(|&v| v == 0.0), "{rate}: silence after the beep");
// the second beep too
assert!(l[48_000..48_000 + beep - 2].iter().any(|&v| v != 0.0), "{rate}: a beep at the second mark");
assert!(l[48_000 + beep..96_000].iter().all(|&v| v == 0.0), "{rate}: silence after it");
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.