Merge upstream/main into the plane store branch (#3301)

# Conflicts:
#	Cargo.toml
This commit is contained in:
vangel76 committed 2026-11-17 11:10:07 +01:00
commit fc4eddf2d5
38 files changed
+1996 -1656

No files matched your search

+1 -1
View File
@@ -147,7 +147,7 @@ pub fn effects_markdown() -> String {
- **Status**: {} implemented in full, {partial} partial (what is missing is listed).\n\n",
r.len() - partial
));
s.push_str("Effects are addressed by id (`ec.<category>.<name>`) or display name in commands, scripts and the control channel, and every parameter by its id (`effects/#1/blurriness`).\n\n");
s.push_str("Effects are addressed by id (`ec.<category>.<name>`) or display name in commands, scripts and the control channel, and every parameter by its id (`effects/#1/blurriness`). A parameter that was renamed keeps its old name working in expressions of older projects: `effect(\"CC Ball Action\")(\"Instability State\")` still reads Scatter Motion.\n\n");
for cat in CATEGORIES {
let list: Vec<_> = r.iter().filter(|e| e.category == *cat).collect();
if list.is_empty() {
+44 -2
View File
@@ -44,6 +44,9 @@ pub const PARAM_ID_ALIASES: &[(&str, &str, &str)] = &[
("ec.key.innerouter", "additionalBackground", "additionalBackground/background1"),
// Generate: Radio Waves' growth speed was called Velocity; Velocity now moves the wave.
("ec.generate.radiowaves", "velocity", "waveMotion/expansion"),
// Simulation: CC Ball Action's Instability State is treated as the control After Effects
// 24.2 calls Scatter Motion (#3197; an assumption: 24.2 shows no Instability State).
("ec.sim.ccballaction", "instabilityState", "scatterMotion"),
];
/// Popup option labels renamed since they were first saved:
@@ -192,6 +195,14 @@ fn take_at(g: &mut PropGroup, id: &str) -> Option<Property> {
}
}
/// The position of the property at spec id `id` (`a/b/param`) among its siblings.
fn index_at(g: &PropGroup, id: &str) -> Option<usize> {
match id.split_once('/') {
None => g.children.iter().position(|c| matches!(c, Node::Prop(p) if p.match_id == id)),
Some((first, rest)) => index_at(g.sub(first)?, rest),
}
}
fn prop_at<'a>(g: &'a mut PropGroup, id: &str) -> Option<&'a mut Property> {
match id.split_once('/') {
None => g.get_mut(id),
@@ -279,6 +290,12 @@ pub fn upgrade_instance(spec: &EffectSpec, g: &mut PropGroup, ids: &mut Ids, lay
// before it moved into a twirl-down group.
let found = prop_at(g, ps.id).is_some();
if !found {
// A parameter renamed within its group keeps its place, so expressions that address
// it by index still read it.
let slot = PARAM_ID_ALIASES
.iter()
.filter(|(e, old, new)| *e == spec.id && *new == ps.id && old.rsplit_once('/').map(|(p, _)| p) == new.rsplit_once('/').map(|(p, _)| p))
.find_map(|(_, old, _)| index_at(g, old));
let moved = PARAM_ID_ALIASES.iter().filter(|(e, _, new)| *e == spec.id && *new == ps.id).find_map(|(_, old, _)| take_at(g, old)).or_else(|| {
let leaf = ps.id.rsplit('/').next().unwrap_or(ps.id);
// Not when the top-level leaf is an old id of another parameter (Radio
@@ -300,9 +317,13 @@ pub fn upgrade_instance(spec: &EffectSpec, g: &mut PropGroup, ids: &mut Ids, lay
pr
}
};
let at = |sub: &mut PropGroup| match slot {
Some(i) if i <= sub.children.len() => sub.children.insert(i, pr.into()),
_ => sub.children.push(pr.into()),
};
match path.and_then(|path| group_at(g, ids, path)) {
Some(sub) => sub.children.push(pr.into()),
None => g.children.push(pr.into()),
Some(sub) => at(sub),
None => at(g),
}
}
if let Some(pr) = prop_at(g, ps.id) {
@@ -631,6 +652,27 @@ mod tests {
assert_eq!((&pr.ui, &pr.value), (&ParamUi::Point, &Value::Vec2([20.0, -5.0])));
}
/// #3197 review: an old CC Ball Action saved Instability State as its 8th property; renamed to
/// Scatter Motion it keeps that place, so an expression that reads `effect(..)(8)` still gets
/// the same control (new controls are appended after it).
#[test]
fn upgrade_renames_a_param_in_place_and_keeps_its_index() {
let spec = find("ec.sim.ccballaction").unwrap();
let mut next = 1;
let mut g = instantiate(spec, &mut Ids(&mut next), "Ball Grid", [100.0, 50.0]);
// The layout an earlier version saved: eight parameters, Instability State last.
let old = ["scatter", "rotationAxis", "rotation", "twistProperty", "twistAngle", "gridSpacing", "ballSize", "scatterMotion"];
let mut kept: Vec<Property> = old.iter().map(|id| take_prop(&mut g, id).unwrap()).collect();
g.children.clear();
kept[7].match_id = "instabilityState".into();
kept[7].value = Value::Scalar(33.0);
g.children.extend(kept.into_iter().map(Node::from));
assert!(upgrade_instance(spec, &mut g, &mut Ids(&mut next), [100.0, 50.0]));
let ids: Vec<&str> = g.children.iter().take(8).map(|c| c.match_id()).collect();
assert_eq!(ids, ["scatter", "rotationAxis", "rotation", "twistProperty", "twistAngle", "gridSpacing", "ballSize", "scatterMotion"]);
assert_eq!(g.get("scatterMotion").unwrap().value, Value::Scalar(33.0));
}
#[test]
fn upgrade_moves_params_into_twirl_down_groups() {
let spec = find(crate::warp_stab::ID).unwrap();
+22
View File
@@ -93,6 +93,10 @@ pub enum Shape {
Disc,
/// Lit sphere (upper-left light, specular).
Sphere,
/// CC Ball Action's ball: [`Shape::Sphere`]'s light and shine scaled by `|shade|` (1 is the
/// sphere's look, 0 a flat disc; callers keep it finite, the GPU draws the same); a negative
/// `shade` mirrors the light's direction (lit from the lower right).
Ball { shade: f32 },
/// Disc fading linearly to its rim.
Faded,
/// Thin ring with a highlight.
@@ -277,6 +281,24 @@ fn sprite_shade(s: &Sprite, x: f32, y: f32) -> Option<Px> {
rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec];
cv
}
Shape::Ball { shade } => {
let d = (dx * dx + dy * dy).sqrt();
let cv = aa(r - d);
if cv <= 0.0 {
return None;
}
let (nx, ny) = (dx / r, dy / r);
let nz = (1.0 - nx * nx - ny * ny).max(0.0).sqrt();
let m = if shade < 0.0 { -1.0 } else { 1.0 };
let (lx, ly, lz) = (-0.48 * m, -0.58 * m, 0.66);
let diff = (nx * lx + ny * ly + nz * lz).max(0.0);
let rz = 2.0 * diff * nz - lz;
let st = shade.abs();
let spec = rz.max(0.0).powi(20) * 0.6 * st;
let k = (1.0 - st * 0.8 * (1.0 - diff)).max(0.0);
rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec];
cv
}
Shape::Bubble => {
let d = (dx * dx + dy * dy).sqrt() / r;
if d > 1.0 + 1.0 / r {
+113 -5
View File
@@ -4,10 +4,91 @@ use super::{Acc, Buf, EffectCtx, IntoParallelIterator, ParallelIterator, Post, S
// ------------------------------------------------------------------ CC Ball Action
/// CC Ball Action's Coloring: how a ball takes its colour from the layer under its grid cell.
/// An approximation: After Effects' own meaning is not published beyond "how smooth the
/// balls look". Crisp takes the nearest pixel, Medium keeps EffectCraft's earlier smooth
/// sample at the cell centre (for compatibility), Smooth averages 16 samples over the cell.
pub(super) const BALL_COLORING: &[&str] = &["Crisp", "Medium", "Smooth"];
pub(super) const BALL_COLORING_MEDIUM: u32 = 1;
/// CC Ball Action's default Shading: the lit sphere (`Shape::Sphere`); 0 draws flat discs.
pub(super) const BALL_SHADING_DEFAULT: f64 = -75.0;
/// CC Ball Action's Displace Property: what pushes a ball towards (high values) or away from
/// (low values) the camera. The option names come from public descriptions; what Radius,
/// Diamond and Spherize compute here is an assumption pending a comparison with After Effects.
pub(super) const BALL_DISPLACE_PROPERTIES: &[&str] = &["Red", "Green", "Blue", "Brightness", "Saturation", "RGB", "Radius", "Diamond", "Spherize"];
pub(super) const BALL_DISPLACE_BRIGHTNESS: u32 = 3;
pub(super) fn ball_action(ctx: &EffectCtx, b: Buf) -> Buf {
ball_action_plan(ctx, &b).finish(b)
}
/// A parameter's number, or `default` when the instance does not carry it.
fn f_or(ctx: &EffectCtx, id: &str, default: f64) -> f64 {
ctx.params.values.get(id).map(|v| v.as_f64()).unwrap_or(default)
}
/// The layer's straight colour and alpha for the ball of the grid cell centred on (`sx`, `sy`)
/// (buffer pixels, cell `cell` buffer pixels wide), by Coloring `coloring`.
fn ball_color(src: &effectcraft_raster::Image, sx: f64, sy: f64, cell: f64, coloring: u32) -> ([f32; 3], f32) {
match coloring {
// Crisp: the pixel under the cell centre.
0 => unpremul(src.get(sx.floor() as i64, sy.floor() as i64)),
// Smooth: the cell's average (4 × 4 samples, premultiplied).
2 => {
const N: u32 = 4;
let mut acc = [0.0f32; 4];
for j in 0..N {
for i in 0..N {
let ox = (f64::from(i) + 0.5) / f64::from(N) - 0.5;
let oy = (f64::from(j) + 0.5) / f64::from(N) - 0.5;
let p = src.sample_bilinear(sx + ox * cell, sy + oy * cell);
for (a, v) in acc.iter_mut().zip(p) {
*a += v;
}
}
}
let n = (N * N) as f32;
unpremul([acc[0] / n, acc[1] / n, acc[2] / n, acc[3] / n])
}
// Medium: a smooth sample at the cell centre.
_ => unpremul(src.sample_bilinear(sx, sy)),
}
}
/// CC Ball Action's Displace Property `prop` (0..1) for a ball of straight colour `c` at
/// (`gx`, `gy`) on a `lw` × `lh` layer (`maxr`: half its diagonal). Assumed meanings (not
/// compared with After Effects yet): Radius, Diamond and Spherize are shapes that peak at the
/// layer centre.
fn ball_displace_value(prop: u32, c: [f32; 3], gx: f32, gy: f32, lw: f32, lh: f32, maxr: f32) -> f32 {
let (cx, cy) = (lw * 0.5, lh * 0.5);
let v = match prop {
0 => c[0],
1 => c[1],
2 => c[2],
// Brightness: the brightest channel (HSB brightness).
3 => c[0].max(c[1]).max(c[2]),
// Saturation: HSB saturation.
4 => {
let mx = c[0].max(c[1]).max(c[2]);
let mn = c[0].min(c[1]).min(c[2]);
if mx > 0.0 { (mx - mn) / mx } else { 0.0 }
}
// RGB: the channels' mean.
5 => (c[0] + c[1] + c[2]) / 3.0,
// Radius: high at the centre, low at the corners.
6 => 1.0 - (gx - cx).hypot(gy - cy) / maxr.max(1.0),
// Diamond: high at the centre, falling linearly to the edge midpoints' diamond.
7 => 1.0 - ((gx - cx).abs() / cx.max(0.5) + (gy - cy).abs() / cy.max(0.5)) * 0.5,
// Spherize: a hemisphere over the largest centred circle.
_ => {
let rr = cx.min(cy).max(0.5);
let d = (gx - cx).hypot(gy - cy) / rr;
(1.0 - d * d).max(0.0).sqrt()
}
};
if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 }
}
/// CC Ball Action's balls (far to near), coloured by the layer's pixels.
fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
let pr = ctx.params;
@@ -18,7 +99,29 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
let twist = pr.f("twistAngle").to_radians();
let spacing = pr.f("gridSpacing").max(1.0) as f32;
let size = pr.f("ballSize") as f32 / 100.0;
let instab = pr.f("instabilityState").to_radians() as f32;
// Scatter Motion, treated as the renamed Instability State (an assumption: After Effects
// 24.2 shows Scatter Motion and no Instability State): turns each ball's scatter direction.
let instab = pr.f("scatterMotion").to_radians() as f32;
let coloring = pr.values.get("coloring").map(|v| v.as_enum()).unwrap_or(BALL_COLORING_MEDIUM);
let shading = f_or(ctx, "shading", BALL_SHADING_DEFAULT);
// Shading: -75 is the lit sphere as it always was, 0 flat discs; the magnitude scales the
// light and shine (strength 1 at 75) and the sign mirrors the light's direction (positive
// lights the balls from the lower right). How this compares with After Effects' sign
// (described as concave versus convex) is unverified, as is the -100..100 range.
let shape = if shading == BALL_SHADING_DEFAULT || !shading.is_finite() {
Shape::Sphere
} else if shading == 0.0 {
Shape::Disc
} else {
// Clamped: a huge value would reach the GPU as an infinite strength (and NaN colours).
Shape::Ball { shade: (-shading.clamp(-100.0, 100.0) / 75.0) as f32 }
};
// Displace: pushes each ball along z by its Displace Property (high values towards the
// camera, pivoting at the property's middle value); 100 moves the extremes by half the
// layer's diagonal. Scale, direction, pivot and range are EffectCraft's own choice,
// pending a comparison with After Effects. Clamped so huge values stay finite.
let displace = pr.f("displace").clamp(-1000.0, 1000.0) as f32;
let displace_prop = pr.values.get("displaceProperty").map(|v| v.as_enum()).unwrap_or(BALL_DISPLACE_BRIGHTNESS);
let seed = ctx.seed.wrapping_mul(0x2545f491);
let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
let s = b.scale as f32;
@@ -43,7 +146,7 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
let gx = (i % nx) as f32 * spacing + spacing * 0.5;
let gy = (i / nx) as f32 * spacing + spacing * 0.5;
let (sx, sy) = b.to_px([gx as f64, gy as f64]);
let (c, a) = unpremul(src.sample_bilinear(sx, sy));
let (c, a) = ball_color(src, sx, sy, f64::from(spacing * s), coloring);
if a <= 0.0 || size <= 0.0 {
return None;
}
@@ -54,11 +157,16 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
_ => crate::util::rgb3([c[0], c[1], c[2], 0.0]).iter().sum::<f32>() / 3.0,
} as f64;
let ang = rot + twist * tp;
// Scatter: random 3D offsets whose direction drifts with the instability state.
// Scatter: random 3D offsets whose direction drifts with Scatter Motion.
let ph = h(i, 1, seed) * std::f32::consts::TAU + instab;
let sc = scatter * h(i, 2, seed);
let off = [(sc * ph.cos()) as f64, (sc * ph.sin()) as f64, (scatter * hs(i, 3, seed)) as f64];
let p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]];
let mut p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]];
// Only when set, so Displace 0 leaves every depth (and the far-to-near order) as is.
if displace != 0.0 && displace.is_finite() {
let v = ball_displace_value(displace_prop, c, gx, gy, lw, lh, maxr);
p0[2] -= f64::from(displace / 100.0 * (v - 0.5) * 2.0 * maxr);
}
let m = rot_axis(ax, ang);
let q: [f64; 3] = std::array::from_fn(|k| m[k][0] * p0[0] + m[k][1] * p0[1] + m[k][2] * p0[2]);
if d + q[2] <= d * 0.05 {
@@ -67,7 +175,7 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
let persp = d / (d + q[2]);
let (bx, by) = b.to_px([cx + q[0] * persp, cy + q[1] * persp]);
let r = spacing * 0.5 * size * persp as f32 * s;
Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], Shape::Sphere)))
Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], shape)))
})
.collect();
balls.sort_by(|a, b| b.0.total_cmp(&a.0));
+15 -6
View File
@@ -1,5 +1,7 @@
use super::foam::{FOAM_TEXTURES, foam};
use super::pixels::{ball_action, pixel_polly, scatterize};
use super::pixels::{
BALL_COLORING, BALL_COLORING_MEDIUM, BALL_DISPLACE_BRIGHTNESS, BALL_DISPLACE_PROPERTIES, BALL_SHADING_DEFAULT, ball_action, pixel_polly, scatterize,
};
use super::shatter::{CD_PROPS, CD_SOURCES, SHATTER_PATTERNS, SHATTER_TEXTURE_MODES, card_dance, shatter};
use super::surfaces::{caustics, wave_world};
use super::{EffectSpec, ParamUi, Value, col, num, p, pct, popup, pt, slider, spec};
@@ -80,15 +82,22 @@ pub fn specs() -> Vec<EffectSpec> {
spec(
"ec.sim.ccballaction",
"Ball Grid",
// After Effects' order and defaults since 24.2 (#3197). Scatter Motion is treated as
// the renamed Instability State (an assumption, `migrate::PARAM_ID_ALIASES`). The
// Shading range is not published; -100..100 is an assumption.
vec![
p("gridSpacing", "Grid Spacing", num(5.0), slider(1.0, 200.0, 1.0, 50.0, 0)),
p("ballSize", "Ball Size", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
p("coloring", "Coloring", Value::Enum(BALL_COLORING_MEDIUM), popup(BALL_COLORING)),
p("shading", "Shading", num(BALL_SHADING_DEFAULT), slider(-100.0, 100.0, -100.0, 100.0, 1)),
p("scatter", "Scatter", num(0.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
p("scatterMotion", "Scatter Motion", num(0.0), ParamUi::Angle),
p("displace", "Displace", num(0.0), slider(-1000.0, 1000.0, 0.0, 100.0, 1)),
p("displaceProperty", "Displace Property", Value::Enum(BALL_DISPLACE_BRIGHTNESS), popup(BALL_DISPLACE_PROPERTIES)),
p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle),
p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])),
p("rotationAxis", "Rotation Axis", Value::Enum(0), popup(&["X Axis", "Y Axis", "Z Axis", "XY Axis", "XZ Axis", "YZ Axis", "XYZ Axis"])),
p("rotation", "Rotation", num(0.0), ParamUi::Angle),
p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])),
p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle),
p("gridSpacing", "Grid Spacing", num(4.0), slider(1.0, 200.0, 1.0, 50.0, 0)),
p("ballSize", "Ball Size", num(40.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
p("instabilityState", "Instability State", num(0.0), ParamUi::Angle),
],
ball_action,
),
+132
View File
@@ -46,6 +46,138 @@ fn ball_action_draws_balls() {
assert!(sum_diff(&a, &sc) > 1.0);
}
/// #3197: CC Ball Action has After Effects' controls (since 24.2), in its order, with its
/// defaults: Coloring, Shading, Scatter Motion (formerly Instability State), Displace and
/// Displace Property were missing.
#[test]
fn ball_action_has_after_effects_controls() {
let spec = crate::find("ec.sim.ccballaction").unwrap();
let names: Vec<&str> = spec.params.iter().map(|p| p.name).collect();
assert_eq!(
names,
[
"Grid Spacing",
"Ball Size",
"Coloring",
"Shading",
"Scatter",
"Scatter Motion",
"Displace",
"Displace Property",
"Twist Angle",
"Twist Property",
"Rotation Axis",
"Rotation"
]
);
let sp = |id: &str| spec.params.iter().find(|p| p.id == id).unwrap_or_else(|| panic!("no {id}"));
assert_eq!(sp("gridSpacing").default, num(5.0));
assert_eq!(sp("ballSize").default, num(100.0));
assert_eq!(sp("coloring").default, Value::Enum(1));
assert_eq!(sp("coloring").ui, ParamUi::Popup { options: vec!["Crisp".into(), "Medium".into(), "Smooth".into()] });
assert_eq!(sp("shading").default, num(-75.0));
assert!(matches!(sp("shading").ui, ParamUi::Slider { min, max, .. } if min <= -100.0 && max >= 100.0));
assert_eq!(sp("scatterMotion").default, num(0.0));
assert_eq!(sp("scatterMotion").ui, ParamUi::Angle);
assert_eq!(sp("displace").default, num(0.0));
let ParamUi::Popup { options } = &sp("displaceProperty").ui else { panic!("Displace Property is a popup") };
let Value::Enum(d) = sp("displaceProperty").default else { panic!("Displace Property defaults to an option") };
assert_eq!(options.get(d as usize).map(String::as_str), Some("Brightness"));
// Old projects' Instability State becomes Scatter Motion through `PARAM_ID_ALIASES`; the
// engine test `opening_an_old_project_upgrades_effect_instances` covers every alias.
}
/// #3197: the new controls at After Effects' defaults draw exactly what CC Ball Action drew
/// before (the lit sphere, a smooth colour sample, no displacement).
#[test]
fn ball_action_new_controls_at_defaults_keep_the_render() {
let base = [("ballSize", num(80.0)), ("scatter", num(6.0)), ("rotationAxis", Value::Enum(1)), ("rotation", num(25.0))];
let a = run("ec.sim.ccballaction", &base, ramp(32, 32), 0.0);
let mut explicit = base.to_vec();
explicit.extend([
("coloring", Value::Enum(1)),
("shading", num(-75.0)),
("scatterMotion", num(0.0)),
("displace", num(0.0)),
("displaceProperty", Value::Enum(3)),
]);
assert_eq!(a, run("ec.sim.ccballaction", &explicit, ramp(32, 32), 0.0));
}
/// #3197: Shading 0 removes the built-in light: every ball is the layer's flat colour. The
/// default (-75) shades it; a smaller magnitude shades less, a positive value lights the balls
/// from the other side.
#[test]
fn ball_action_shading_zero_is_flat() {
let c = [0.6, 0.3, 0.2, 1.0];
let shade = |v: f64| run("ec.sim.ccballaction", &[("ballSize", num(100.0)), ("gridSpacing", num(8.0)), ("shading", num(v))], Image::filled(32, 32, c), 0.0);
let flat = shade(0.0);
let covered: Vec<&[f32; 4]> = flat.data.iter().filter(|p| p[3] > 0.999).collect();
assert!(!covered.is_empty(), "balls drawn");
for p in &covered {
for k in 0..3 {
assert!((p[k] / p[3] - c[k]).abs() < 1e-4, "flat colour: {p:?}");
}
}
let lit = shade(-75.0);
assert!(lit.data.iter().any(|p| p[3] > 0.999 && (0..3).any(|k| (p[k] / p[3] - c[k]).abs() > 0.05)), "the default shading lights and darkens the balls");
let soft = shade(-30.0);
assert!(sum_diff(&flat, &soft) > 0.1 && sum_diff(&flat, &soft) < sum_diff(&flat, &lit), "less shading, closer to flat");
assert!(sum_diff(&shade(75.0), &lit) > 1.0, "the sign moves the light");
}
/// #3197: Coloring Crisp takes the pixel under each ball's cell centre; Medium samples
/// smoothly between pixels. Grid Spacing 4 puts the cell centres on pixel corners (with the
/// default 5 they fall on pixel centres, where Medium's sample equals Crisp's).
#[test]
fn ball_action_coloring_crisp_takes_the_pixel() {
let mut src = Image::new(32, 32);
for y in 0..32u32 {
for x in 0..32u32 {
src.set(x, y, [x as f32 / 32.0, y as f32 / 32.0, ((x * 7 + y * 3) % 5) as f32 / 4.0, 1.0]);
}
}
let col = |m: u32| {
let v = [("gridSpacing", num(4.0)), ("ballSize", num(100.0)), ("shading", num(0.0)), ("coloring", Value::Enum(m))];
run("ec.sim.ccballaction", &v, src.clone(), 0.0)
};
let crisp = col(0);
// Flat, opaque balls of radius 2 centred on (4i + 2, 4j + 2): the pixel to the lower right
// of each centre is fully covered by its ball alone.
for j in 0..8i64 {
for i in 0..8i64 {
let (x, y) = (4 * i + 2, 4 * j + 2);
let (got, want) = (crisp.get(x, y), src.get(x, y));
assert!((0..4).all(|k| (got[k] - want[k]).abs() < 1e-5), "ball ({i}, {j}): {got:?} vs the pixel {want:?}");
}
}
assert!(sum_diff(&crisp, &col(1)) > 1.0, "medium blends the pixels");
}
/// #3197: a huge Shading (typed or from an expression) is clamped, so the balls stay finite.
#[test]
fn ball_action_huge_shading_stays_finite() {
for v in [1e45, -1e45, f64::MAX] {
let o = run("ec.sim.ccballaction", &[("gridSpacing", num(8.0)), ("shading", num(v))], ramp(32, 32), 0.0);
assert!(o.data.iter().all(|p| p.iter().all(|c| c.is_finite())), "shading {v}");
assert!(o.data.iter().any(|p| p[3] > 0.0), "shading {v}: balls drawn");
}
}
/// #3197: Displace pushes the balls along z by the chosen property (Radius: the centre comes
/// towards the camera and grows); 0 leaves them in the layer's plane.
#[test]
fn ball_action_displace_moves_balls_in_depth() {
let flat = run("ec.sim.ccballaction", &[("ballSize", num(80.0))], ramp(32, 32), 0.0);
let d = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(60.0)), ("displaceProperty", Value::Enum(6))], ramp(32, 32), 0.0);
assert_eq!(d, run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(60.0)), ("displaceProperty", Value::Enum(6))], ramp(32, 32), 0.0));
assert!(sum_diff(&flat, &d) > 1.0);
for prop in 0..9 {
let o = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(400.0)), ("displaceProperty", Value::Enum(prop))], ramp(32, 32), 0.0);
assert!(o.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "property {prop}");
}
}
#[test]
fn pixel_polly_breaks_after_start() {
let v = [("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0))];
+21 -21
View File
@@ -192,7 +192,7 @@ fn cases() -> Vec<(&'static str, Vec<Set>)> {
vec![
vec![],
vec![("scatter", n(20.0)), ("rotationAxis", e(6)), ("rotation", n(40.0)), ("twistProperty", e(3)), ("twistAngle", n(90.0))],
vec![("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("instabilityState", n(45.0)), ("twistProperty", e(2)), ("twistAngle", n(30.0))],
vec![("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("scatterMotion", n(45.0)), ("twistProperty", e(2)), ("twistAngle", n(30.0))],
],
),
(
@@ -538,26 +538,26 @@ const GOLDEN: &[(&str, u64)] = &[
("ec.sim.particleplayground/8/32bpc/t1.5", 0xb5b7f0281f26baad),
("ec.sim.particleplayground/8/32bpc/t0.8", 0x8b6934363ef4dcfd),
("ec.sim.particleplayground/8/32bpc/t2.2", 0x0a31c17e8e34b9f5),
("ec.sim.ccballaction/0/8bpc/t0.5", 0x12698ec8353be38c),
("ec.sim.ccballaction/0/8bpc/t1.5", 0x12698ec8353be38c),
("ec.sim.ccballaction/0/8bpc/t0.8", 0x12698ec8353be38c),
("ec.sim.ccballaction/0/8bpc/t2.2", 0x12698ec8353be38c),
("ec.sim.ccballaction/0/32bpc/t0.5", 0x3fb733487e120261),
("ec.sim.ccballaction/0/32bpc/t1.5", 0x3fb733487e120261),
("ec.sim.ccballaction/0/32bpc/t0.8", 0x3fb733487e120261),
("ec.sim.ccballaction/0/32bpc/t2.2", 0x3fb733487e120261),
("ec.sim.ccballaction/0/8bpc/half/t0.5", 0x4946070917cc0945),
("ec.sim.ccballaction/0/8bpc/half/t1.5", 0x4946070917cc0945),
("ec.sim.ccballaction/0/8bpc/half/t0.8", 0x4946070917cc0945),
("ec.sim.ccballaction/0/8bpc/half/t2.2", 0x4946070917cc0945),
("ec.sim.ccballaction/1/8bpc/t0.5", 0xf34b3be38a4dd468),
("ec.sim.ccballaction/1/8bpc/t1.5", 0xf34b3be38a4dd468),
("ec.sim.ccballaction/1/8bpc/t0.8", 0xf34b3be38a4dd468),
("ec.sim.ccballaction/1/8bpc/t2.2", 0xf34b3be38a4dd468),
("ec.sim.ccballaction/1/32bpc/t0.5", 0x503b7238edf2912c),
("ec.sim.ccballaction/1/32bpc/t1.5", 0x503b7238edf2912c),
("ec.sim.ccballaction/1/32bpc/t0.8", 0x503b7238edf2912c),
("ec.sim.ccballaction/1/32bpc/t2.2", 0x503b7238edf2912c),
("ec.sim.ccballaction/0/8bpc/t0.5", 0x5f7401d3d1e5a513),
("ec.sim.ccballaction/0/8bpc/t1.5", 0x5f7401d3d1e5a513),
("ec.sim.ccballaction/0/8bpc/t0.8", 0x5f7401d3d1e5a513),
("ec.sim.ccballaction/0/8bpc/t2.2", 0x5f7401d3d1e5a513),
("ec.sim.ccballaction/0/32bpc/t0.5", 0x9cf15a7756ab88ed),
("ec.sim.ccballaction/0/32bpc/t1.5", 0x9cf15a7756ab88ed),
("ec.sim.ccballaction/0/32bpc/t0.8", 0x9cf15a7756ab88ed),
("ec.sim.ccballaction/0/32bpc/t2.2", 0x9cf15a7756ab88ed),
("ec.sim.ccballaction/0/8bpc/half/t0.5", 0xe2e3a624434f8e88),
("ec.sim.ccballaction/0/8bpc/half/t1.5", 0xe2e3a624434f8e88),
("ec.sim.ccballaction/0/8bpc/half/t0.8", 0xe2e3a624434f8e88),
("ec.sim.ccballaction/0/8bpc/half/t2.2", 0xe2e3a624434f8e88),
("ec.sim.ccballaction/1/8bpc/t0.5", 0x07382912d068a625),
("ec.sim.ccballaction/1/8bpc/t1.5", 0x07382912d068a625),
("ec.sim.ccballaction/1/8bpc/t0.8", 0x07382912d068a625),
("ec.sim.ccballaction/1/8bpc/t2.2", 0x07382912d068a625),
("ec.sim.ccballaction/1/32bpc/t0.5", 0xa1e843936e72815f),
("ec.sim.ccballaction/1/32bpc/t1.5", 0xa1e843936e72815f),
("ec.sim.ccballaction/1/32bpc/t0.8", 0xa1e843936e72815f),
("ec.sim.ccballaction/1/32bpc/t2.2", 0xa1e843936e72815f),
("ec.sim.ccballaction/2/8bpc/t0.5", 0x0b6bf26753ee4582),
("ec.sim.ccballaction/2/8bpc/t1.5", 0x0b6bf26753ee4582),
("ec.sim.ccballaction/2/8bpc/t0.8", 0x0b6bf26753ee4582),
+1 -1
View File
@@ -192,7 +192,7 @@ fn an_overridden_lut_file_renders_again() {
#[test]
fn ocio_files_render_again_from_warm_caches() {
let dir = tempfile::tempdir().unwrap();
let (lut, config, grade) = (dir.path().join("file.cube"), dir.path().join("config.ocio"), dir.path().join("luts/grade.cube"));
let (lut, config, grade) = (dir.path().join("file.cube"), dir.path().join("config.ocio"), dir.path().join("luts").join("grade.cube"));
std::fs::create_dir_all(dir.path().join("luts")).unwrap();
write(&lut, BLACK, 1_000);
write(&grade, BLACK, 1_000);
+1 -1
View File
@@ -11,6 +11,7 @@ workspace = true
[dependencies]
effectcraft-time = { workspace = true }
effectcraft-effects = { workspace = true }
effectcraft-geom = { workspace = true }
effectcraft-keyframe = { workspace = true }
serde_json = { workspace = true }
@@ -25,5 +26,4 @@ boa_engine = { workspace = true, features = ["js"] }
[dev-dependencies]
effectcraft-color = { workspace = true }
effectcraft-effects = { workspace = true }
effectcraft-text = { workspace = true }
+15
View File
@@ -7,6 +7,7 @@
//! the answers and runs the script again. Expressions are pure functions of these answers, so
//! re-running is exact, and the runtime stays free of borrowed state.
use effectcraft_effects::migrate::PARAM_ID_ALIASES;
use effectcraft_geom::{Mat3, Mat4};
use effectcraft_keyframe::Value;
use effectcraft_project::ae_order::{self, AeChild};
@@ -300,10 +301,24 @@ fn find_child<'g>(g: &'g PropGroup, key: &Key) -> Option<&'g Node> {
// An effect by its After Effects match name, an imported placeholder's effect id
// (`effect("Pseudo/0.25")`; its match id is one path segment, `Pseudo_0_25`).
.or_else(|| g.children.iter().find(|n| matches!(n.as_group().map(|g| &g.kind), Some(GroupKind::Effect { effect }) if effect == name)))
// Last, so a legacy name never shadows a current one.
.or_else(|| legacy_effect_child(g, &c))
}
}
}
/// A parameter of an effect instance addressed by a name it had when the project was saved
/// ([`PARAM_ID_ALIASES`]): `effect("CC Ball Action")("Instability State")` keeps reading the
/// parameter that is now Scatter Motion. `c` is the compacted (lowercase, no spaces) name. Only
/// renames inside the instance's own top-level group count; moves into twirl-downs do not.
fn legacy_effect_child<'g>(g: &'g PropGroup, c: &str) -> Option<&'g Node> {
let GroupKind::Effect { effect } = &g.kind else { return None };
PARAM_ID_ALIASES
.iter()
.filter(|(e, old, new)| e == effect && !old.contains('/') && !new.contains('/') && compact(old) == c)
.find_map(|(_, _, new)| g.children.iter().find(|n| n.match_id() == *new))
}
impl<'a> Resolver<'a> {
fn comp(&self, c: u64) -> Option<&'a Comp> {
if c == self.ctx.comp_id.0 { Some(self.ctx.comp) } else { self.ctx.project.comp(ItemId(c)) }
+83
View File
@@ -2145,6 +2145,89 @@ fn bench_evaluation() {
}
}
/// Layer A with an old-format CC Ball Action: Scatter Motion saved as `instabilityState`
/// ("Instability State"), opened through the migration (#3197). Scatter Motion is 37 and keyed
/// 10 at 0 s, 50 at 2 s.
fn old_ball_action() -> Fx {
let mut f = fx();
let spec = effectcraft_effects::find("ec.sim.ccballaction").unwrap();
let mut g = group_push(&mut f.p, |ids| effectcraft_effects::instantiate(spec, ids, "CC Ball Action", [20.0, 20.0]));
let sm = g.prop_mut("scatterMotion").unwrap();
sm.value = Value::Scalar(37.0);
sm.keys = vec![Keyframe::new(Tick::ZERO, Value::Scalar(10.0)), Keyframe::new(secs(2.0), Value::Scalar(50.0))];
sm.match_id = "instabilityState".into();
sm.name = "Instability State".into();
let mut next = f.p.next_id;
assert!(effectcraft_effects::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [20.0, 20.0]));
f.p.next_id = next;
assert!(g.prop("scatterMotion").is_some(), "the migration renamed the parameter");
f.p.comp_mut(f.cid).unwrap().layers[0].props.sub_mut("effects").unwrap().children.push(g.into());
f
}
#[test]
fn old_parameter_names_still_resolve_in_expressions() {
let f = old_ball_action();
for name in ["Instability State", "instabilityState", "instability state", "InstabilityState"] {
// Keyframes still apply: the keyed value at 0 s, not the stored 37.
assert_close!(f.num(&format!("effect('CC Ball Action')('{name}')"), 0.0), 10.0);
assert_close!(f.num(&format!("effect('CC Ball Action')('{name}')"), 2.0), 50.0);
assert_close!(f.num(&format!("effect('CC Ball Action')('{name}').valueAtTime(2)"), 0.0), 50.0);
}
// Current names read the same property, unchanged.
for name in ["Scatter Motion", "scatterMotion"] {
assert_close!(f.num(&format!("effect('CC Ball Action')('{name}')"), 0.0), 10.0);
}
}
#[test]
fn old_parameter_name_follows_the_parameter_expression() {
let mut f = old_ball_action();
let p = f.p.comp_mut(f.cid).unwrap().layers[0].props.prop_mut("effects/#2/scatterMotion");
let p = match p {
Some(p) => p,
None => panic!("scatterMotion at effects/#2"),
};
p.expr = Some(Expression { text: "123".into(), enabled: true });
assert_close!(f.num("effect('CC Ball Action')('Instability State')", 0.0), 123.0);
}
#[test]
fn unknown_parameter_names_still_fail() {
let f = old_ball_action();
assert!(f.ev(f.a, ROT, "effect('CC Ball Action')('No Such Thing')", 0.0).is_err());
// Old names only exist on the effect they were renamed on.
assert!(f.ev(f.a, ROT, "effect('Slider Control')('Instability State')", 0.0).is_err());
}
/// Every in-group rename in the alias table keeps resolving by its old id and display name.
#[test]
fn every_in_group_alias_resolves_by_its_old_name() {
let mut n = 0;
for (effect, old, new) in effectcraft_effects::migrate::PARAM_ID_ALIASES {
if old.contains('/') || new.contains('/') {
continue;
}
let Some(spec) = effectcraft_effects::find(effect) else { continue };
let mut f = fx();
let g = group_push(&mut f.p, |ids| effectcraft_effects::instantiate(spec, ids, "Probe", [20.0, 20.0]));
f.p.comp_mut(f.cid).unwrap().layers[0].props.sub_mut("effects").unwrap().children.push(g.into());
let (new_name, kind) = {
let l = &f.p.comp(f.cid).unwrap().layers[0];
let p = l.props.prop(&format!("effects/#2/{new}")).unwrap();
(p.name.clone(), p.value.clone())
};
if !matches!(kind, Value::Scalar(_)) {
continue;
}
let a = f.ev(f.a, ROT, &format!("effect('Probe')('{old}')"), 0.0).unwrap();
let b = f.ev(f.a, ROT, &format!("effect('Probe')('{new_name}')"), 0.0).unwrap();
assert_eq!(a, b, "{effect}: {old}");
n += 1;
}
assert!(n >= 1);
}
/// Viewport clipping must never affect layer-space expression reads (#1388).
#[test]
fn sample_image_reads_3d_shape_behind_camera_before_and_after_effects() {
+2
View File
@@ -228,6 +228,8 @@ pub(crate) fn sprite_layer(e: &mut Enc, src: &GpuImage, plan: &SpritePlan) -> Op
Shape::Square => (6.0, 0.0, 0.0),
Shape::Tri => (7.0, 0.0, 0.0),
Shape::Line { dx, dy } => (8.0, dx, dy),
// The strength rides in the (otherwise unused) first segment slot.
Shape::Ball { shade } => (9.0, shade, 0.0),
};
let mut rec = [kind, s.x, s.y, s.r, s.c[0], s.c[1], s.c[2], s.c[3], s.rot, dx, dy, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
match plan.tints.get(i).copied().unwrap_or(Tint::Fixed) {
+21
View File
@@ -145,6 +145,27 @@ fn fxm_sprite(at: u32, x: f32, y: f32) -> FxmShade {
}
cov = fxm_aa(m);
}
// sim::Shape::Ball (CC Ball Action's Shading): the sphere's light and shine scaled by
// |shade| (data[at + 9]), lit from the lower right when shade < 0.
case 9u: {
let d = sqrt(dx * dx + dy * dy);
let cv = fxm_aa(r - d);
if (cv <= 0.0) {
return fxm_none();
}
let shade = data[at + 9u];
let nx = dx / r;
let ny = dy / r;
let nz = sqrt(max(1.0 - nx * nx - ny * ny, 0.0));
let m = select(1.0, -1.0, shade < 0.0);
let diff = max(nx * (-0.48 * m) + ny * (-0.58 * m) + nz * 0.66, 0.0);
let rz = 2.0 * diff * nz - 0.66;
let st = abs(shade);
let spec = powz(max(rz, 0.0), 20.0) * 0.6 * st;
let k = max(1.0 - st * 0.8 * (1.0 - diff), 0.0);
rgb = rgb * k + spec;
cov = cv;
}
default: {
let lx = data[at + 9u];
let ly = data[at + 10u];
+16 -1
View File
@@ -141,7 +141,22 @@ fn ball_action_pixel_polly_scatterize() {
0.0,
0.0,
);
case("ec.sim.ccballaction", &[("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("instabilityState", n(45.0)), ("twistProperty", e(2))], 0.0, 0.0);
case("ec.sim.ccballaction", &[("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("scatterMotion", n(45.0)), ("twistProperty", e(2))], 0.0, 0.0);
// #3197: Shading (flat, weaker, stronger, lit from the other side), Coloring, Displace.
for shading in [0.0, -30.0, -100.0, 60.0, 1e45] {
case("ec.sim.ccballaction", &[("ballSize", n(80.0)), ("shading", n(shading))], 0.0, 0.0);
}
for coloring in [0, 2] {
case("ec.sim.ccballaction", &[("ballSize", n(80.0)), ("coloring", e(coloring))], 0.0, 0.0);
}
for prop in [3, 6, 8] {
case(
"ec.sim.ccballaction",
&[("ballSize", n(80.0)), ("rotationAxis", e(1)), ("rotation", n(30.0)), ("displace", n(40.0)), ("displaceProperty", e(prop))],
0.0,
0.0,
);
}
for object in 0..4 {
case("ec.sim.ccpixelpolly", &[("object", e(object)), ("gridSpacing", n(6.0))], 0.6, 0.0);
}
+2 -1
View File
@@ -54,6 +54,7 @@ fn still(p: &mut fp::Project, path: &str) -> fp::ItemId {
codec: "png".into(),
pixel_format: String::new(),
color: Default::default(),
color_assumed: None,
has_alpha: false,
bitrate: None,
hdr: None,
@@ -75,7 +76,7 @@ fn still(p: &mut fp::Project, path: &str) -> fp::ItemId {
identity: None,
};
let name = path.rsplit('/').next().unwrap().to_string();
p.add_item(&name, fp::Label::Iris, fp::ItemKind::Media(clip), None)
p.add_item(&name, fp::Label::Iris, fp::ItemKind::Media(Box::new(clip)), None)
}
/// V1: red for 2 s; V2: blue at 50 % opacity and 50 % scale; a cross dissolve from red to green
+1
View File
@@ -10,6 +10,7 @@ rust-version.workspace = true
workspace = true
[dependencies]
craft-timeline = { workspace = true }
effectcraft-time = { workspace = true }
effectcraft-color = { workspace = true }
effectcraft-keyframe = { workspace = true }
+16 -3
View File
@@ -365,7 +365,7 @@ impl Exporter<'_> {
let mut clip = media_clip(fp::MediaRef::File { path: path.clone() }, info);
clip.offline = f.missing;
let bin = self.bin(it.and_then(|i| i.parent));
let id = self.fp.add_item(&name, fp::Label::Iris, fp::ItemKind::Media(clip), bin);
let id = self.fp.add_item(&name, fp::Label::Iris, fp::ItemKind::Media(Box::new(clip)), bin);
self.media.insert(path, id);
id
}
@@ -384,7 +384,7 @@ impl Exporter<'_> {
Some(b)
}
};
let id = self.fp.add_item(name, fp::Label::Violet, fp::ItemKind::Media(clip), bin);
let id = self.fp.add_item(name, fp::Label::Violet, fp::ItemKind::Media(Box::new(clip)), bin);
self.media.insert(r.path.clone(), id);
id
}
@@ -405,7 +405,7 @@ impl Exporter<'_> {
);
let clip = media_clip(fp::MediaRef::Generator(Generator::ColorMatte { color: [color[0], color[1], color[2], 1.0] }), info);
let bin = self.bin(it.and_then(|i| i.parent));
let id = self.fp.add_item(&name, fp::Label::Rose, fp::ItemKind::Media(clip), bin);
let id = self.fp.add_item(&name, fp::Label::Rose, fp::ItemKind::Media(Box::new(clip)), bin);
self.media.insert(key, id);
id
}
@@ -540,6 +540,9 @@ impl Exporter<'_> {
comment: if m.chapter.is_empty() { String::new() } else { m.comment.clone() },
kind: if m.chapter.is_empty() { fp::MarkerKind::Comment } else { fp::MarkerKind::Chapter },
color: fp::Label::Green,
custom_color: None,
author: String::new(),
url: m.url.clone(),
})
.collect();
if let Some(seq) = self.fp.sequence_mut(sid) {
@@ -733,6 +736,7 @@ fn media_info(name: &str, kind: MediaKind, duration: Tick, video: Option<VideoSp
codec,
pixel_format: String::new(),
color: Default::default(),
color_assumed: None,
has_alpha,
bitrate: None,
hdr: None,
@@ -755,6 +759,15 @@ fn media_clip(media: fp::MediaRef, info: MediaInfo) -> fp::MediaClip {
mod tests {
use super::*;
#[test]
fn synthesized_video_metadata_does_not_claim_an_inferred_color_profile() {
let info = media_info("clip", MediaKind::Movie, Tick::ZERO, Some((1920, 1080, FrameRate::new(24, 1), 1.0, "raw".into(), true)), false);
let video = info.video.unwrap();
assert_eq!((video.width, video.height), (1920, 1080));
assert!(video.color_assumed.is_none());
assert!(video.has_alpha);
}
/// A folder's bin is the same one each time it is asked for (a cached folder once answered
/// `None`, so a folder's second item went to the project root); a non-item has no bin.
#[test]
+6 -75
View File
@@ -49,78 +49,7 @@ pub struct ImportResult {
/// a few levels per nested sequence; parsing several thousand levels overflowed the stack.
pub const MAX_DEPTH: usize = 256;
/// The deepest element nesting of an XML document (a quick scan that skips comments, CDATA,
/// processing instructions, declarations and quoted attribute values).
pub(crate) fn xml_depth(b: &[u8]) -> usize {
let (mut i, mut depth, mut max) = (0usize, 0usize, 0usize);
let skip_to = |from: usize, end: &[u8]| b.get(from..).and_then(|r| r.windows(end.len()).position(|w| w == end)).map_or(b.len(), |p| from + p + end.len());
while let Some(&c) = b.get(i) {
if c != b'<' {
i += 1;
continue;
}
let rest = b.get(i..).unwrap_or_default();
if rest.starts_with(b"<!--") {
i = skip_to(i + 4, b"-->");
} else if rest.starts_with(b"<![CDATA[") {
i = skip_to(i + 9, b"]]>");
} else if rest.starts_with(b"<?") {
i = skip_to(i + 2, b"?>");
} else if rest.starts_with(b"<!") {
i = skip_to(i + 2, b">");
} else if rest.starts_with(b"</") {
depth = depth.saturating_sub(1);
i = skip_to(i + 2, b">");
} else {
// A start tag: find its end outside quotes; `/>` closes it at once.
let mut j = i + 1;
let mut quote = None;
while let Some(&c) = b.get(j) {
match quote {
Some(q) if c == q => quote = None,
Some(_) => {}
None if c == b'"' || c == b'\'' => quote = Some(c),
None if c == b'>' => break,
None => {}
}
j += 1;
}
if b.get(j.wrapping_sub(1)) != Some(&b'/') {
depth += 1;
max = max.max(depth);
}
i = j + 1;
}
}
max
}
/// The deepest array / object nesting of a JSON document (strings skipped).
pub(crate) fn json_depth(b: &[u8]) -> usize {
let (mut depth, mut max, mut in_str, mut esc) = (0usize, 0usize, false, false);
for &c in b {
if in_str {
if esc {
esc = false;
} else if c == b'\\' {
esc = true;
} else if c == b'"' {
in_str = false;
}
continue;
}
match c {
b'"' => in_str = true,
b'[' | b'{' => {
depth += 1;
max = max.max(depth);
}
b']' | b'}' => depth = depth.saturating_sub(1),
_ => {}
}
}
max
}
pub(crate) use craft_timeline::preflight::{json_depth, xml_depth};
pub fn import(
project: &mut Project,
@@ -201,8 +130,8 @@ const EDL_MEDIA_TIME_NOTE: &str = "EDL source timecodes were imported as media t
/// The largest start timecode, in frames, a file may have: a day at 1000 fps.
const MAX_FILE_TIMECODE: i64 = 24 * 3600 * 1000;
/// The paths an EDL reader guessed (media it flags offline: a line without `SOURCE FILE` names
/// only its clip) that are not inside the list's folder: a clip name of `../x.mov` or an absolute
/// The paths an EDL reader guessed (identified by its `Tape Name` metadata: a line without
/// `SOURCE FILE` names only its clip) that are not inside the list's folder: a clip name of `../x.mov` or an absolute
/// one would link a file elsewhere on the disk. They stay placeholders. A `SOURCE FILE` path is
/// the list's own choice and is kept, also when another clip guesses the same path.
fn guessed_outside(project: &fp::Project, base_dir: Option<&str>) -> HashSet<String> {
@@ -219,7 +148,9 @@ fn guessed_outside(project: &fp::Project, base_dir: Option<&str>) -> HashSet<Str
if let fp::ItemKind::Media(m) = &it.kind
&& let fp::MediaRef::File { path } = &m.media
{
if m.offline && !inside(path) {
// Film reserves `offline` for an explicit user action now. Its EDL reader sets
// Tape Name only on reel/clip-name guesses, never on SOURCE FILE references.
if it.metadata.contains_key("Tape Name") && !inside(path) {
guessed.insert(path.clone());
} else {
named.insert(path.clone());
+16 -1
View File
@@ -34,6 +34,7 @@ fn info(kind: filmcraft_media::MediaKind, video: bool, audio: bool) -> filmcraft
codec: "png".into(),
pixel_format: String::new(),
color: Default::default(),
color_assumed: None,
has_alpha: false,
bitrate: None,
hdr: None,
@@ -60,7 +61,7 @@ fn media(p: &mut fp::Project, name: &str, path: &str, kind: filmcraft_media::Med
proxy: None,
identity: None,
};
p.add_item(name, fp::Label::Iris, fp::ItemKind::Media(clip), bin)
p.add_item(name, fp::Label::Iris, fp::ItemKind::Media(Box::new(clip)), bin)
}
fn rate() -> filmcraft_time::FrameRate {
@@ -882,3 +883,17 @@ fn import_finds_each_clips_transitions_without_scanning_the_track() {
let mid = m.layers.iter().find(|l| near(l.in_point, t(100.0 - 0.08))).expect("clip 250 extended into its incoming transition");
assert!(near(mid.out_point, t(100.4 + 0.08)), "{}", mid.out_point.seconds());
}
#[test]
fn edl_explicit_source_file_allows_the_same_path_as_an_outside_guess() {
let edl = b"TITLE: CUT\nFCM: NON-DROP FRAME\n\n001 A001 V C 00:00:00:00 00:00:01:00 00:00:00:00 00:00:01:00\n* FROM CLIP NAME: ../shared.mov\n\n002 A002 V C 00:00:00:00 00:00:01:00 00:00:01:00 00:00:02:00\n* FROM CLIP NAME: named.mov\n* SOURCE FILE: /shared.mov\n";
let mut asked = Vec::new();
let mut probe_all = |path: &str| {
asked.push(path.to_string());
probe(path)
};
let mut p = Project::default();
let opts = ImportOptions { name: "hand.edl".into(), edl_frame_rate: Some(25.0), base_dir: Some("/work".into()) };
import(&mut p, edl, None, &opts, &mut probe_all).unwrap();
assert_eq!(asked, ["/shared.mov"], "explicit SOURCE FILE permits the shared path, probed once");
}
+31
View File
@@ -0,0 +1,31 @@
# Synthetic AAC layout fixture
`pce61-ffmpeg.aac-fixture` contains only original mathematical sine tones generated for these tests by Dylan M. Taylor. No recorded audio or third-party source/assets were copied; the generated fixture is covered by this repository's license. FFmpeg is a generation tool, not a runtime test dependency.
Generator: FFmpeg 7.1.5 (Debian 7.1.5-0+deb13u1, AAC encoder Lavc61.19.101).
SHA-256: `07c460636dce4aa4163df8ef35f3b76f1214c38bf217aacd23243e608d87071e`.
The seven PCM inputs are FL500Hz, FR700Hz, FC300Hz, LFE60Hz, BC900Hz, SL1100Hz, SR1300Hz, each amplitude0.25 at48kHz for2seconds. The real encoder emits its own PCE and matching element tags; unlike the previous synthetic configuration rewrite, no LFE element is mislabeled as an unlisted SCE.
Reproduce using FFmpeg/ffprobe and Python3:
```sh
ffmpeg -hide_banner -loglevel error -f lavfi -i 'aevalsrc=0.25*sin(2*PI*500*t)|0.25*sin(2*PI*700*t)|0.25*sin(2*PI*300*t)|0.25*sin(2*PI*60*t)|0.25*sin(2*PI*900*t)|0.25*sin(2*PI*1100*t)|0.25*sin(2*PI*1300*t):s=48000:d=2:c=6.1' -c:a aac -b:a 672k pce61.m4a
ffprobe -v error -show_streams -show_packets -show_data -of json pce61.m4a > pce61.json
python3 - <<'PY'
import json, struct
x = json.load(open('pce61.json'))
def raw(text):
return bytes.fromhex(''.join(line.split(': ', 1)[1].split(' ', 1)[0].replace(' ', '')
for line in text.strip().splitlines()))
asc = raw(x['streams'][0]['extradata'])
units = [raw(p['data']) for p in x['packets']]
assert len(units) == 95
output = bytearray(b'PCE1')
for record in [asc, *units]:
output += struct.pack('>I', len(record)) + record
open('pce61-ffmpeg.aac-fixture', 'wb').write(output)
PY
```
Envelope: ASCII `PCE1`, then a big-endian32-bit length and ASC bytes, then95 length-prefixed raw AAC access units. Container priming trim is deliberately not retained, matching the existing tests' encoder units; measurements start0.5seconds into decoded audio. Other encoder versions can yield different bytes; preserve actual PCE/AU consistency and all existing tone-gain assertions.
Binary file not shown.
@@ -0,0 +1,7 @@
asset: pce61-ffmpeg.aac-fixture
title: Synthetic seven-channel AAC PCE tone fixture
author: Dylan M. Taylor
source: crates/media/tests/fixtures/README.md (reproducible generation recipe)
license: MIT OR Apache-2.0
added: 2026-11-16
notes: Original sine-wave signals, no recorded audio or copied assets. Encoded using FFmpeg 7.1.5. SHA-256 07c460636dce4aa4163df8ef35f3b76f1214c38bf217aacd23243e608d87071e.
+37 -26
View File
@@ -1,7 +1,8 @@
//! Multichannel AAC reaches stereo by where each channel plays, whatever order its channel
//! configuration decodes in (#1701). Fixtures are tones encoded with craft-audio's AAC encoder (no
//! ffmpeg needed, so nothing is skipped), with the configuration rewritten where the coded
//! elements fit another: configurations 11 and 12 code the same elements as the encoder's 7- and
//! configuration decodes in (#1701). Fixtures are tones encoded with craft-audio's AAC encoder,
//! plus a checked-in genuine FFmpeg-generated 6.1-channel fixture (no external tool at test time, nothing skipped).
//! The configuration is rewritten only where the coded elements fit another: configurations 11
//! and 12 code the same elements as the encoder's 7- and
//! 8-channel output, and a program config element can name any of them.
use std::f64::consts::PI;
@@ -9,7 +10,7 @@ use std::io::Cursor;
use std::path::PathBuf;
use std::sync::Arc;
use craft_audio::aac::{AudioSpecificConfig, Encoder, EncoderConfig, ProgramConfig};
use craft_audio::aac::{AudioSpecificConfig, Encoder, EncoderConfig};
use effectcraft_media::{MediaPool, probe, probe_bytes};
use effectcraft_time::Tick;
@@ -59,13 +60,6 @@ fn lc(config: u8) -> Option<AudioSpecificConfig> {
Some(AudioSpecificConfig::lc(3, config))
}
fn pce(front: Vec<(bool, u8)>, side: Vec<(bool, u8)>, back: Vec<(bool, u8)>, lfe: Vec<u8>, comment: &[u8]) -> Option<AudioSpecificConfig> {
let pce = ProgramConfig { object_type: 1, sf_index: 3, front, side, back, lfe, comment: comment.to_vec(), ..Default::default() };
let mut asc = AudioSpecificConfig::lc(3, 0);
asc.pce = Some(pce);
Some(asc)
}
use Ch::*;
fn cases() -> Vec<Case> {
@@ -80,15 +74,9 @@ fn cases() -> Vec<Case> {
Case { name: "config12", content: &[C, L, R, Ls, Rs, Ls, Rs, Lfe], asc: lc(12) },
// the encoder's own 6.1: a PCE listing the centre first
Case { name: "pce61-centre-first", content: &[C, L, R, Ls, Rs, Cs, Lfe], asc: None },
// ffmpeg's 6.1 PCE: front pair and centre, a side SCE, a back pair and SCE, no LFE
// element, its channels in ffmpeg's order L R C LFE Cs Ls Rs. The decoder places the
// encoder's SCE 0 in the front SCE, pair 0 front, pair 1 back, SCE 1 in the back SCE (tag
// 1) and the LFE in the side SCE left over (tag 5).
Case {
name: "pce61-ffmpeg",
content: &[C, L, R, Cs, Ls, Rs, Lfe],
asc: pce(vec![(true, 0), (false, 0)], vec![(false, 5)], vec![(true, 1), (false, 1)], vec![], b"Lavc62.28.102"),
},
// A genuine FFmpeg-generated 6.1-channel PCE and matching coded elements; rewriting only the ASC of
// our encoder's LFE0 stream to claim a side SCE5 would make an invalid access unit.
Case { name: "pce61-ffmpeg", content: &[C, L, R, Cs, Ls, Rs, Lfe], asc: None },
]
}
@@ -110,6 +98,32 @@ fn encode(content: &[Ch], adts: bool) -> (Vec<u8>, Vec<Vec<u8>>) {
(enc.audio_specific_config(), units)
}
/// Preserve the fixture's real element types/tags instead of changing only its ASC.
/// The envelope and reproducible tone-generation recipe are in `tests/fixtures/README.md`.
fn encode_case(case: &Case) -> (Vec<u8>, Vec<Vec<u8>>) {
if case.name == "pce61-ffmpeg" {
let bytes = include_bytes!("../fixtures/pce61-ffmpeg.aac-fixture");
assert_eq!(&bytes[..4], b"PCE1");
let mut rest = &bytes[4..];
let mut record = || {
let len = u32::from_be_bytes(rest[..4].try_into().unwrap()) as usize;
let (data, tail) = rest[4..].split_at(len);
rest = tail;
data.to_vec()
};
let asc = record();
let mut units = Vec::new();
// The generated fixture contains 95 access units (including encoder priming).
for _ in 0..95 {
units.push(record());
}
assert!(rest.is_empty(), "fixture has no unparsed records");
return (asc, units);
}
let (asc, units) = encode(case.content, false);
(case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC")), units)
}
fn mp4(asc: Vec<u8>, channels: u32, units: &[Vec<u8>]) -> Vec<u8> {
mp4_after(None, asc, channels, units)
}
@@ -211,8 +225,7 @@ fn lfe_is_coded(case: &Case, bytes: Vec<u8>) {
#[test]
fn every_aac_layout_mixes_by_speaker_in_mp4() {
for case in cases() {
let (asc, units) = encode(case.content, false);
let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC"));
let (asc, units) = encode_case(&case);
let bytes = mp4(asc, case.content.len() as u32, &units);
lfe_is_coded(&case, bytes.clone());
let p = write(&format!("{}.mp4", case.name), &bytes);
@@ -228,8 +241,7 @@ fn every_aac_layout_mixes_by_speaker_in_mp4() {
#[test]
fn matroska_aac_layouts_mix_by_speaker() {
for case in cases().into_iter().filter(|c| matches!(c.name, "config12" | "pce61-centre-first" | "pce61-ffmpeg")) {
let (asc, units) = encode(case.content, false);
let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC"));
let (asc, units) = encode_case(&case);
let p = write(&format!("{}.mkv", case.name), &mkv(asc, case.content.len() as u32, &units));
check(case.name, case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe")));
}
@@ -254,8 +266,7 @@ fn an_empty_audio_track_lends_its_configuration_to_no_other() {
let case = cases().into_iter().find(|c| c.name == name).expect("case");
let n = case.content.len() as u32;
let empty = Some((AudioSpecificConfig::lc(3, empty).to_bytes().expect("ASC"), n));
let (asc, units) = encode(case.content, false);
let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC"));
let (asc, units) = encode_case(&case);
let p = write(&format!("{name}-after-empty.mp4"), &mp4_after(empty.clone(), asc.clone(), n, &units));
check(&format!("{name} MP4"), case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe")));
let p = write(&format!("{name}-after-empty.mkv"), &mkv_after(empty, asc, n, &units));
+1
View File
@@ -14,5 +14,6 @@ effectcraft-geom = { workspace = true }
effectcraft-keyframe = { workspace = true }
effectcraft-raster = { workspace = true }
kurbo = { workspace = true }
log = { workspace = true }
tiny-skia = { workspace = true }
linesweeper = "0.5"
+49 -5
View File
@@ -351,14 +351,28 @@ fn round_sub(sub: &Sub, r: f64, out: &mut BezPath) {
/// join. `copies` copies are made, copy *i* (0-based) offset by `amount · (i + 1 + copy_offset)`,
/// all returned in the same compound path.
pub fn offset(paths: &[BezPath], amount: f64, join: Join, miter_limit: f64, copies: f64, copy_offset: f64) -> Vec<BezPath> {
let n = copies.round().clamp(1.0, 1000.0) as usize;
offset_within(paths, amount, join, miter_limit, copies, copy_offset, MAX_OPERATOR_SEGMENTS)
}
/// [`offset`] with each path's result held to `max` elements (its first copy aside).
fn offset_within(paths: &[BezPath], amount: f64, join: Join, miter_limit: f64, copies: f64, copy_offset: f64, max: usize) -> Vec<BezPath> {
let n = pieces_within_budget(paths, copies.round().clamp(1.0, 1000.0) as usize);
paths
.iter()
.map(|p| {
let mut out = BezPath::new();
for i in 0..n {
let d = amount * (i as f64 + 1.0 + copy_offset);
out.extend(crate::offset::offset_path(p, d, join, miter_limit).elements().iter().copied());
let copy = crate::offset::offset_path(p, d, join, miter_limit);
// The budget is spent on what `offset_path` returns (an open subpath comes back as
// a closed outline of many segments; a zero offset as the path itself): the first
// copy is always kept, and a copy that would pass the budget is not made, so the
// work stays within a small multiple of it.
if i > 0 && out.elements().len().saturating_add(copy.elements().len()) > max {
log::warn!("path: Offset Paths made {i} of {n} copies; more would pass {max} segments");
break;
}
out.extend(copy.elements().iter().copied());
}
out
})
@@ -387,6 +401,14 @@ pub fn twist(paths: &[BezPath], angle_deg: f64, center: [f64; 2]) -> Vec<BezPath
return paths.to_vec();
}
let k = a / rmax;
// The pieces a segment asks for; the uniform cap applies only when the requests together
// would pass the budget (long segments keep their detail next to many short ones otherwise).
let want = |len: f64| ((a.abs() * len / rmax) / 0.15 + len / 50.0).ceil().clamp(1.0, 64.0) as usize;
let requested = paths
.iter()
.flat_map(subs)
.fold(0usize, |n, sub| sub.segs.iter().fold(n.saturating_add(overhead_of(&sub)), |n, seg| n.saturating_add(want(seg.arclen(ACC)))));
let most = if requested <= MAX_OPERATOR_SEGMENTS { 64 } else { pieces_within_budget(paths, 64) };
let rot = |v: Vec2, th: f64| {
let (s, co) = th.sin_cos();
Vec2::new(v.x * co - v.y * s, v.x * s + v.y * co)
@@ -414,7 +436,7 @@ pub fn twist(paths: &[BezPath], angle_deg: f64, center: [f64; 2]) -> Vec<BezPath
for seg in &sub.segs {
let cb = seg.to_cubic();
let len = seg.arclen(ACC);
let m = ((a.abs() * len / rmax) / 0.15 + len / 50.0).ceil().clamp(1.0, 64.0) as usize;
let m = want(len).min(most);
for i in 0..m {
let q = cb.subsegment(i as f64 / m as f64..(i + 1) as f64 / m as f64);
let (p0, p3) = (map(q.p0), map(q.p3));
@@ -442,6 +464,28 @@ struct Sample {
len_next: f64,
}
/// Most segments an expanding operator (Zig Zag, Wiggle Paths, Twist, Offset Paths' copies)
/// makes from its input. Operators stack, each expanding the previous one's output; capping each
/// output keeps a short stack from multiplying a simple path into billions of points.
pub const MAX_OPERATOR_SEGMENTS: usize = 1 << 20;
/// Elements a subpath adds besides its segments: a `MoveTo`, and a `ClosePath` only when closed.
fn overhead_of(sub: &Sub) -> usize {
if sub.closed { 2 } else { 1 }
}
/// `want` pieces (or copies) per input segment, reduced so the whole output (segments times
/// pieces, plus per-subpath overhead) stays within [`MAX_OPERATOR_SEGMENTS`] (never below 1, so the input itself always passes through).
fn pieces_within_budget(paths: &[BezPath], want: usize) -> usize {
// Count what is subdivided (drawn segments) and keep room for each subpath's own MoveTo/Close.
let (mut segs, mut overhead) = (0usize, 0usize);
for sub in paths.iter().flat_map(subs) {
segs = segs.saturating_add(sub.segs.len());
overhead = overhead.saturating_add(overhead_of(&sub));
}
want.min(MAX_OPERATOR_SEGMENTS.saturating_sub(overhead) / segs.max(1)).max(1)
}
/// Split every segment into `m` pieces of equal arc length. Original vertices get the average of
/// their incoming and outgoing tangents (so a corner's normal is its bisector).
fn resample(sub: &Sub, m: usize) -> Vec<Sample> {
@@ -503,7 +547,7 @@ fn emit(samples: &[Sample], disp: &[Vec2], closed: bool, smooth: bool, handle: f
/// `smooth` makes rounded waves instead of sharp zig zags. A closed path with `n` segments ends up
/// with `n · (ridges + 1)` vertices (open: one more).
pub fn zigzag(paths: &[BezPath], size: f64, ridges: f64, smooth: bool) -> Vec<BezPath> {
let m = ridges.round().clamp(0.0, 1000.0) as usize + 1;
let m = pieces_within_budget(paths, ridges.round().clamp(0.0, 1000.0) as usize + 1);
paths
.iter()
.map(|p| {
@@ -586,7 +630,7 @@ pub fn wiggle(paths: &[BezPath], w: &WiggleParams, time_s: f64) -> Vec<BezPath>
if w.size == 0.0 {
return paths.to_vec();
}
let m = w.detail.round().clamp(0.0, 1000.0) as usize + 1;
let m = pieces_within_budget(paths, w.detail.round().clamp(0.0, 1000.0) as usize + 1);
let seed = w.seed.round() as i64 as u64;
let t = time_s * w.speed + w.phase_deg / 360.0;
let corr = (w.correlation / 100.0).clamp(0.0, 1.0);
+80
View File
@@ -182,6 +182,25 @@ fn offset_copies() {
assert!(close(o[0].bounding_box().width(), 140.0, 1e-3));
}
#[test]
fn offset_copies_are_budgeted_by_the_output_they_return() {
// An open one-segment subpath comes back as a closed outline of several elements, so the copies
// stop when the returned elements pass the budget, not when the input segments would.
let line = || {
let mut p = BezPath::new();
p.move_to((0.0, 0.0));
p.line_to((50.0, 0.0));
p
};
let one = offset_within(&[line()], 5.0, Join::Round, 4.0, 1.0, 0.0, usize::MAX)[0].elements().len();
assert!(one > 4, "{one}");
let o = offset_within(&[line()], 5.0, Join::Round, 4.0, 50.0, 0.0, one * 3);
let moves = o[0].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count();
assert!((1..50).contains(&moves) && o[0].elements().len() <= one * 4, "{moves} contours, {} elements", o[0].elements().len());
// The first copy always comes back, however small the budget.
assert!(!offset_within(&[line()], 5.0, Join::Round, 4.0, 5.0, 0.0, 0)[0].elements().is_empty());
}
#[test]
fn offset_open_path_outlines() {
let mut l = BezPath::new();
@@ -246,6 +265,22 @@ fn twist_of_centred_circle_keeps_it_round() {
assert_eq!(id[0], sq(0.0, 0.0, 5.0));
}
#[test]
fn twist_keeps_requested_detail_when_the_whole_request_fits_the_budget() {
// One long segment asks for 64 pieces; 20,000 tiny ones ask for one each. Together that is
// far under the budget, so the long one is not cut to what a uniform 64 per segment would allow.
let mut long = BezPath::new();
long.move_to((0.0, 0.0));
long.line_to((5000.0, 0.0));
let mut tiny = BezPath::new();
tiny.move_to((0.0, 1.0));
for i in 1..=20_000 {
tiny.line_to((i as f64 * 1e-3, 1.0));
}
let t = twist(&[long, tiny], 90.0, [0.0, 0.0]);
assert_eq!(t[0].elements().len(), 1 + 64);
}
// ---------------------------------------------------------------- zig zag
#[test]
@@ -417,3 +452,48 @@ fn normalize_and_filled_area() {
let n = crate::boolean::normalize(&p, FillRule::EvenOdd);
assert!(close(n.area().abs(), 10000.0, 1e-6));
}
// ---------------------------------------------------------------- operator budget
#[test]
fn stacked_expanding_operators_stay_within_the_segment_budget() {
// Three Zig Zags at 1000 ridges would turn a square into 4 · 1001³ segments; each output
// is held to the budget instead, and the last operators still pass the geometry through.
let mut p = vec![sq(0.0, 0.0, 100.0)];
for _ in 0..3 {
p = zigzag(&p, 1.0, 1000.0, false);
let n: usize = p.iter().map(|q| q.elements().len()).sum();
assert!(n <= 2 * MAX_OPERATOR_SEGMENTS, "{n}");
}
let w = wiggle(&p, &WiggleParams { detail: 1000.0, ..Default::default() }, 0.0);
let n: usize = w.iter().map(|q| q.elements().len()).sum();
assert!(n <= 2 * MAX_OPERATOR_SEGMENTS, "{n}");
let o = offset(&[sq(0.0, 0.0, 100.0)], 1.0, Join::Miter, 4.0, 1000.0, 0.0);
assert!(!o[0].elements().is_empty());
// Within the budget nothing changes: 4 segments × 11 pieces.
assert_eq!(vertex_count(&zigzag(&[sq(0.0, 0.0, 100.0)], 1.0, 10.0, false)[0]), 44);
}
#[test]
fn many_short_open_paths_keep_their_requested_detail_within_the_budget() {
// 1000 open lines at 1000 ridges: 1,001,000 segments fit the budget, so nothing is reduced.
let lines: Vec<BezPath> = (0..1000)
.map(|i| {
let mut p = BezPath::new();
p.move_to((0.0, i as f64));
p.line_to((100.0, i as f64));
p
})
.collect();
let z = zigzag(&lines, 1.0, 1000.0, false);
assert!(z.iter().all(|q| q.elements().len() == 1 + 1001));
}
#[test]
fn open_subpaths_reserve_one_element_of_overhead() {
// 349,525 open lines: the move-to is the only extra element, so 2 copies fit the budget
// (a closed subpath's extra close-path would leave room for 1).
let line = BezPath::from_vec(vec![PathEl::MoveTo((0.0, 0.0).into()), PathEl::LineTo((1.0, 0.0).into())]);
let lines = vec![line; 349_525];
assert_eq!(pieces_within_budget(&lines, 3), 2);
}
+29 -39
View File
@@ -134,46 +134,36 @@ impl Psd {
/// Undo ZIP prediction in place; the 32-bit scratch row is charged to `budget`.
pub(crate) fn unpredict(&self, v: &mut [u8], w: usize, h: usize, budget: &mut Budget) -> Result<()> {
match self.depth {
16 => {
for row in v.chunks_exact_mut(w * 2).take(h) {
let mut prev = 0u16;
for c in row.as_chunks_mut::<2>().0 {
let x = u16::from_be_bytes([c[0], c[1]]).wrapping_add(prev);
c.copy_from_slice(&x.to_be_bytes());
prev = x;
}
}
}
32 => {
// One scratch row for the whole plane, charged: a wide, short layer passes the
// decode's peak check and would otherwise allocate it on top.
let mut planar = budget.filled(w.checked_mul(4).ok_or_else(|| too_large(w, h))?, 0u8)?;
#[cfg(test)]
counters::bump(&counters::SCRATCH);
for row in v.chunks_exact_mut(w * 4).take(h) {
for i in 1..row.len() {
row[i] = row[i].wrapping_add(row[i - 1]);
}
// Bytes are stored plane by plane (all first bytes, then all second bytes…).
planar.copy_from_slice(row);
for x in 0..w {
for b in 0..4 {
row[x * 4 + b] = planar[b * w + x];
}
}
}
budget.release(planar.len() as u64);
}
_ => {
for row in v.chunks_exact_mut(w).take(h) {
for i in 1..row.len() {
row[i] = row[i].wrapping_add(row[i - 1]);
}
}
}
// Preserve the reader's recovery behavior: decode only complete rows, at most h.
// The fallback depths historically used byte-wise prediction rather than packed bits.
let depth = match self.depth {
16 => 16,
32 => 32,
_ => 8,
};
let rowb = w.checked_mul(usize::from(depth / 8)).ok_or_else(|| too_large(w, h))?;
if rowb == 0 {
return Ok(());
}
Ok(())
let rows = (v.len() / rowb).min(h);
let layout = craft_psd::compression::PlaneLayout {
planes: 1,
width: w,
height: rows,
depth,
version: if self.psb { craft_psd::Version::Psb } else { craft_psd::Version::Psd },
};
let mut scratch = if depth == 32 {
let scratch = budget.filled(rowb, 0u8)?;
#[cfg(test)]
counters::bump(&counters::SCRATCH);
scratch
} else {
Vec::new()
};
let result = craft_psd::compression::unpredict_with_scratch(&mut v[..rows * rowb], &layout, &mut scratch);
budget.release(scratch.len() as u64);
result.map_err(|e| Error::Invalid(e.to_string()))
}
/// Hand every sample of `raw` (`w`×`h`, row-major, in order) to `f` as a float. Samples a short
+18
View File
@@ -650,3 +650,21 @@ fn placed_bake_solves_the_quad_once() {
so.map([1.0, 1.0], 20.0, 10.0);
assert_eq!(counters::take(&QUAD), 1);
}
#[test]
fn shared_unpredict_keeps_tail_bytes_and_refuses_unbudgeted_scratch() {
for depth in [8u16, 16, 32] {
let p = Psd { depth, ..base() };
let (w, h) = (3, 2);
let row = w * usize::from(depth / 8);
let mut actual: Vec<u8> = (0..row * 3 + 1).map(|i| (i * 31 % 251) as u8).collect();
let mut expected = actual.clone();
ref_unpredict(depth, &mut expected, w, h);
p.unpredict(&mut actual, w, h, &mut Budget::new(u64::MAX)).unwrap();
assert_eq!(actual, expected, "complete extra rows and partial tails stay untouched");
}
let p = Psd { depth: 32, ..base() };
let mut bytes = vec![0x31; 24];
assert!(p.unpredict(&mut bytes, 3, 2, &mut Budget::new(11)).is_err());
assert_eq!(bytes, vec![0x31; 24], "budget refusal precedes mutation");
}
+6 -1
View File
@@ -94,6 +94,11 @@ fn generates(l: &Layer) -> bool {
audio_effect_groups(l).any(|(id, _)| audio_fx::generates_audio(id))
}
/// Does an enabled audio effect (Backwards) play the layer's [in, out) span reversed?
pub fn plays_backwards(l: &Layer) -> bool {
audio_effect_groups(l).any(|(id, _)| audio_fx::reverses(id))
}
/// Does the layer contribute to the mix (Audio switch on and something to hear)?
pub fn audible(project: &Project, l: &Layer) -> bool {
l.switches.audio
@@ -291,7 +296,7 @@ impl MixEnv<'_> {
if fx.is_empty() {
return self.layer_raw(l, i0, n, false);
}
let reversed = fx.iter().any(|(id, _, _)| audio_fx::reverses(id));
let reversed = plays_backwards(l);
let pre_s: f64 = fx.iter().map(|(id, _, p)| audio_fx::preroll(id, p)).sum::<f64>().clamp(0.0, MAX_PREROLL_SECONDS);
let pre = (pre_s * self.rate as f64).ceil() as usize;
let b0 = i0 - pre as i64;
+16 -246
View File
@@ -1,250 +1,7 @@
//! CSS colour values (CSS Color Module Level 3): keywords, `#rgb[a]`, `#rrggbb[aa]`, `rgb[a]()`,
//! `hsl[a]()`.
//! SVG paint colours use the shared precision-preserving compatibility parser.
//! Paint references (`none`, `currentColor`, `url`) remain app policy.
/// The CSS colour keywords (CSS Color Module Level 3, §4.3 extended colour keywords).
const NAMED: &[(&str, u32)] = &[
("aliceblue", 0xF0F8FF),
("antiquewhite", 0xFAEBD7),
("aqua", 0x00FFFF),
("aquamarine", 0x7FFFD4),
("azure", 0xF0FFFF),
("beige", 0xF5F5DC),
("bisque", 0xFFE4C4),
("black", 0x000000),
("blanchedalmond", 0xFFEBCD),
("blue", 0x0000FF),
("blueviolet", 0x8A2BE2),
("brown", 0xA52A2A),
("burlywood", 0xDEB887),
("cadetblue", 0x5F9EA0),
("chartreuse", 0x7FFF00),
("chocolate", 0xD2691E),
("coral", 0xFF7F50),
("cornflowerblue", 0x6495ED),
("cornsilk", 0xFFF8DC),
("crimson", 0xDC143C),
("cyan", 0x00FFFF),
("darkblue", 0x00008B),
("darkcyan", 0x008B8B),
("darkgoldenrod", 0xB8860B),
("darkgray", 0xA9A9A9),
("darkgreen", 0x006400),
("darkgrey", 0xA9A9A9),
("darkkhaki", 0xBDB76B),
("darkmagenta", 0x8B008B),
("darkolivegreen", 0x556B2F),
("darkorange", 0xFF8C00),
("darkorchid", 0x9932CC),
("darkred", 0x8B0000),
("darksalmon", 0xE9967A),
("darkseagreen", 0x8FBC8F),
("darkslateblue", 0x483D8B),
("darkslategray", 0x2F4F4F),
("darkslategrey", 0x2F4F4F),
("darkturquoise", 0x00CED1),
("darkviolet", 0x9400D3),
("deeppink", 0xFF1493),
("deepskyblue", 0x00BFFF),
("dimgray", 0x696969),
("dimgrey", 0x696969),
("dodgerblue", 0x1E90FF),
("firebrick", 0xB22222),
("floralwhite", 0xFFFAF0),
("forestgreen", 0x228B22),
("fuchsia", 0xFF00FF),
("gainsboro", 0xDCDCDC),
("ghostwhite", 0xF8F8FF),
("gold", 0xFFD700),
("goldenrod", 0xDAA520),
("gray", 0x808080),
("grey", 0x808080),
("green", 0x008000),
("greenyellow", 0xADFF2F),
("honeydew", 0xF0FFF0),
("hotpink", 0xFF69B4),
("indianred", 0xCD5C5C),
("indigo", 0x4B0082),
("ivory", 0xFFFFF0),
("khaki", 0xF0E68C),
("lavender", 0xE6E6FA),
("lavenderblush", 0xFFF0F5),
("lawngreen", 0x7CFC00),
("lemonchiffon", 0xFFFACD),
("lightblue", 0xADD8E6),
("lightcoral", 0xF08080),
("lightcyan", 0xE0FFFF),
("lightgoldenrodyellow", 0xFAFAD2),
("lightgray", 0xD3D3D3),
("lightgreen", 0x90EE90),
("lightgrey", 0xD3D3D3),
("lightpink", 0xFFB6C1),
("lightsalmon", 0xFFA07A),
("lightseagreen", 0x20B2AA),
("lightskyblue", 0x87CEFA),
("lightslategray", 0x778899),
("lightslategrey", 0x778899),
("lightsteelblue", 0xB0C4DE),
("lightyellow", 0xFFFFE0),
("lime", 0x00FF00),
("limegreen", 0x32CD32),
("linen", 0xFAF0E6),
("magenta", 0xFF00FF),
("maroon", 0x800000),
("mediumaquamarine", 0x66CDAA),
("mediumblue", 0x0000CD),
("mediumorchid", 0xBA55D3),
("mediumpurple", 0x9370DB),
("mediumseagreen", 0x3CB371),
("mediumslateblue", 0x7B68EE),
("mediumspringgreen", 0x00FA9A),
("mediumturquoise", 0x48D1CC),
("mediumvioletred", 0xC71585),
("midnightblue", 0x191970),
("mintcream", 0xF5FFFA),
("mistyrose", 0xFFE4E1),
("moccasin", 0xFFE4B5),
("navajowhite", 0xFFDEAD),
("navy", 0x000080),
("oldlace", 0xFDF5E6),
("olive", 0x808000),
("olivedrab", 0x6B8E23),
("orange", 0xFFA500),
("orangered", 0xFF4500),
("orchid", 0xDA70D6),
("palegoldenrod", 0xEEE8AA),
("palegreen", 0x98FB98),
("paleturquoise", 0xAFEEEE),
("palevioletred", 0xDB7093),
("papayawhip", 0xFFEFD5),
("peachpuff", 0xFFDAB9),
("peru", 0xCD853F),
("pink", 0xFFC0CB),
("plum", 0xDDA0DD),
("powderblue", 0xB0E0E6),
("purple", 0x800080),
("rebeccapurple", 0x663399),
("red", 0xFF0000),
("rosybrown", 0xBC8F8F),
("royalblue", 0x4169E1),
("saddlebrown", 0x8B4513),
("salmon", 0xFA8072),
("sandybrown", 0xF4A460),
("seagreen", 0x2E8B57),
("seashell", 0xFFF5EE),
("sienna", 0xA0522D),
("silver", 0xC0C0C0),
("skyblue", 0x87CEEB),
("slateblue", 0x6A5ACD),
("slategray", 0x708090),
("slategrey", 0x708090),
("snow", 0xFFFAFA),
("springgreen", 0x00FF7F),
("steelblue", 0x4682B4),
("tan", 0xD2B48C),
("teal", 0x008080),
("thistle", 0xD8BFD8),
("tomato", 0xFF6347),
("turquoise", 0x40E0D0),
("violet", 0xEE82EE),
("wheat", 0xF5DEB3),
("white", 0xFFFFFF),
("whitesmoke", 0xF5F5F5),
("yellow", 0xFFFF00),
("yellowgreen", 0x9ACD32),
];
/// Parse a CSS colour into RGBA 0..1 (`transparent` is RGBA 0). `None` for anything else
/// (`none`, `currentColor` and `url()` are handled by the caller).
pub fn parse_color(s: &str) -> Option<[f64; 4]> {
let s = s.trim();
let lower = s.to_ascii_lowercase();
if lower == "transparent" {
return Some([0.0; 4]);
}
if let Some(h) = lower.strip_prefix('#') {
let d: Vec<u32> = h.chars().map(|c| c.to_digit(16)).collect::<Option<_>>()?;
let v = |i: usize| d[i] as f64 / 15.0;
let w = |i: usize| (d[i] * 16 + d[i + 1]) as f64 / 255.0;
return Some(match d.len() {
3 => [v(0), v(1), v(2), 1.0],
4 => [v(0), v(1), v(2), v(3)],
6 => [w(0), w(2), w(4), 1.0],
8 => [w(0), w(2), w(4), w(6)],
_ => return None,
});
}
if let Some(args) = func(&lower, "rgba").or_else(|| func(&lower, "rgb")) {
let a: Vec<&str> = split_args(args);
if a.len() < 3 {
return None;
}
let comp = |t: &str| -> Option<f64> {
Some(if let Some(p) = t.strip_suffix('%') {
p.trim().parse::<f64>().ok().filter(|v| v.is_finite())? / 100.0
} else {
t.parse::<f64>().ok().filter(|v| v.is_finite())? / 255.0
})
};
let alpha = a.get(3).map_or(Some(1.0), |t| alpha(t))?;
return Some([comp(a[0])?.clamp(0.0, 1.0), comp(a[1])?.clamp(0.0, 1.0), comp(a[2])?.clamp(0.0, 1.0), alpha]);
}
if let Some(args) = func(&lower, "hsla").or_else(|| func(&lower, "hsl")) {
let a: Vec<&str> = split_args(args);
if a.len() < 3 {
return None;
}
let h = a[0].trim_end_matches("deg").parse::<f64>().ok().filter(|v| v.is_finite())?.rem_euclid(360.0) / 360.0;
let s = a[1].trim_end_matches('%').parse::<f64>().ok().filter(|v| v.is_finite())?.clamp(0.0, 100.0) / 100.0;
let l = a[2].trim_end_matches('%').parse::<f64>().ok().filter(|v| v.is_finite())?.clamp(0.0, 100.0) / 100.0;
let al = a.get(3).map_or(Some(1.0), |t| alpha(t))?;
let [r, g, b] = hsl(h, s, l);
return Some([r, g, b, al]);
}
NAMED.iter().find(|(n, _)| *n == lower).map(|(_, v)| [((v >> 16) & 255) as f64 / 255.0, ((v >> 8) & 255) as f64 / 255.0, (v & 255) as f64 / 255.0, 1.0])
}
fn func<'a>(s: &'a str, name: &str) -> Option<&'a str> {
s.strip_prefix(name)?.trim_start().strip_prefix('(')?.strip_suffix(')')
}
fn split_args(s: &str) -> Vec<&str> {
s.split(|c: char| c == ',' || c == '/' || c.is_whitespace()).filter(|t| !t.is_empty()).collect()
}
fn alpha(t: &str) -> Option<f64> {
Some(
if let Some(p) = t.strip_suffix('%') {
p.parse::<f64>().ok().filter(|v| v.is_finite())? / 100.0
} else {
t.parse::<f64>().ok().filter(|v| v.is_finite())?
}
.clamp(0.0, 1.0),
)
}
/// CSS HSL → RGB (CSS Color 3 §4.2.4).
fn hsl(h: f64, s: f64, l: f64) -> [f64; 3] {
let m2 = if l <= 0.5 { l * (s + 1.0) } else { l + s - l * s };
let m1 = l * 2.0 - m2;
let hue = |mut h: f64| {
if h < 0.0 {
h += 1.0;
}
if h > 1.0 {
h -= 1.0;
}
if h * 6.0 < 1.0 {
m1 + (m2 - m1) * h * 6.0
} else if h * 2.0 < 1.0 {
m2
} else if h * 3.0 < 2.0 {
m1 + (m2 - m1) * (2.0 / 3.0 - h) * 6.0
} else {
m1
}
};
[hue(h + 1.0 / 3.0), hue(h), hue(h - 1.0 / 3.0)]
}
pub use craft_svg::color::parse_rgba_compat as parse_color;
#[cfg(test)]
mod tests {
@@ -280,3 +37,16 @@ mod tests {
assert_eq!(parse_color("nonsense"), None);
}
}
#[cfg(test)]
mod shared_precision_tests {
use super::parse_color;
#[test]
fn shared_parser_keeps_float_channels_and_legacy_clamping() {
assert_eq!(parse_color("rgb(100%,50%,0%)"), Some([1.0, 0.5, 0.0, 1.0]));
assert_eq!(parse_color("rgba(0,0,255,0.123456789123)"), Some([0.0, 0.0, 1.0, 0.123456789123]));
assert_eq!(parse_color("rgb(300,-1,0)"), Some([1.0, 0.0, 0.0, 1.0]));
assert_eq!(parse_color("# fff"), None);
}
}
+9 -251
View File
@@ -425,186 +425,12 @@ enum PaintRef {
Current,
}
/// The most selectors (each entry of a comma list counts) the `<style>` sheets of a document may
/// hold (#2140).
const MAX_CSS_SELECTORS: usize = 20_000;
/// The most declarations the `<style>` sheets of a document may hold, each block counted once.
const MAX_CSS_DECLARATIONS: usize = 50_000;
#[cfg(test)]
use craft_svg::simple_css::{MAX_CSS_DECLARATIONS, MAX_CSS_SELECTORS};
use craft_svg::simple_css::{MAX_CSS_WORK, StyleSheet};
/// The most matching work (candidate rules checked plus declarations applied) the elements of a
/// document may cost, `<use>` copies included: a bound on elements x rules x declarations.
const MAX_CSS_WORK: usize = 50_000_000;
/// A CSS rule: selector (type, class, id; `*`) with its specificity and declaration block.
#[derive(Clone, Debug)]
struct Rule {
tag: Option<String>,
classes: Vec<String>,
id: Option<String>,
specificity: u32,
order: usize,
/// Index into [`StyleSheet::blocks`]: every selector of a comma list shares one block.
block: usize,
}
/// The rules of a document's `<style>` sheets, indexed by the part of the selector an element
/// must have (id, else first class, else type) so an element only checks rules that can match.
#[derive(Default, Debug)]
struct StyleSheet {
/// Distinct selector rules in source order.
rules: Vec<Rule>,
/// Declaration blocks; comma-list selectors share one block.
blocks: Vec<Vec<(String, String)>>,
/// Declarations over all blocks.
decls: usize,
/// Rules keyed by their id selector.
by_id: HashMap<String, Vec<usize>>,
/// Rules keyed by their first class selector.
by_class: HashMap<String, Vec<usize>>,
/// Rules keyed by their type selector.
by_tag: HashMap<String, Vec<usize>>,
/// Rules with no id, class or type to index on.
universal: Vec<usize>,
}
impl StyleSheet {
/// Build the id, class, tag and universal lookup buckets from `rules`.
fn index(&mut self) {
for (i, r) in self.rules.iter().enumerate() {
let bucket = if let Some(id) = &r.id {
self.by_id.entry(id.clone()).or_default()
} else if let Some(c) = r.classes.first() {
self.by_class.entry(c.clone()).or_default()
} else if let Some(t) = &r.tag {
self.by_tag.entry(t.clone()).or_default()
} else {
&mut self.universal
};
bucket.push(i);
}
}
}
fn parse_decls(s: &str) -> Vec<(String, String)> {
s.split(';')
.filter_map(|d| {
let (k, v) = d.split_once(':')?;
let v = v.trim().trim_end_matches("!important").trim();
Some((k.trim().to_ascii_lowercase(), v.to_string()))
})
.filter(|(k, _)| !k.is_empty())
.collect()
}
fn strip_comments(s: &str) -> String {
let mut out = String::new();
let mut rest = s;
while let Some(i) = rest.find("/*") {
out.push_str(&rest[..i]);
match rest[i + 2..].find("*/") {
Some(j) => rest = &rest[i + 2 + j + 2..],
None => return out,
}
}
out.push_str(rest);
out
}
/// Splits one simple selector (`tag.class#id`) into its tag, classes and id.
fn parse_compound(one: &str) -> (Option<String>, Vec<String>, Option<String>) {
let mut tag = None;
let mut classes = vec![];
let mut id = None;
let mut cur = String::new();
let mut kind = 't';
let flush = |kind: char, cur: &mut String, tag: &mut Option<String>, classes: &mut Vec<String>, id: &mut Option<String>| {
if !cur.is_empty() {
match kind {
'.' => classes.push(std::mem::take(cur)),
'#' => *id = Some(std::mem::take(cur)),
_ => {
if cur != "*" {
*tag = Some(std::mem::take(cur));
}
cur.clear();
}
}
}
};
for c in one.chars() {
if c == '.' || c == '#' {
flush(kind, &mut cur, &mut tag, &mut classes, &mut id);
kind = c;
} else {
cur.push(c);
}
}
flush(kind, &mut cur, &mut tag, &mut classes, &mut id);
(tag, classes, id)
}
/// Add the rules of one `<style>` sheet. Errs once the sheets exceed [`MAX_CSS_SELECTORS`] or
/// [`MAX_CSS_DECLARATIONS`] (#2140).
fn parse_css(css: &str, sheet: &mut StyleSheet) -> Result<(), Error> {
let css = strip_comments(css);
let mut rest = css.as_str();
while let Some(open) = rest.find('{') {
let sel = rest[..open].trim();
if sel.starts_with('@') {
// Skip the whole at-rule block, matching nested braces by depth.
let mut depth = 0usize;
let mut end = None;
for (i, c) in rest[open..].char_indices() {
match c {
'{' => depth = depth.saturating_add(1),
'}' => {
depth = depth.saturating_sub(1);
if depth == 0 {
end = Some(open + i + 1);
break;
}
}
_ => {}
}
}
let Some(end) = end else { break };
rest = &rest[end..];
continue;
}
let Some(close) = rest[open..].find('}') else { break };
let body = &rest[open + 1..open + close];
rest = &rest[open + close + 1..];
let mut decls = parse_decls(body);
sheet.decls = sheet.decls.saturating_add(decls.len());
if sheet.decls > MAX_CSS_DECLARATIONS {
return Err(Error::Xml(format!("its <style> sheets hold more than {MAX_CSS_DECLARATIONS} declarations")));
}
// Stored with the rule's first accepted selector: a rule of unsupported selectors only
// (`a b{}`, repeated) adds no block.
let mut block = None;
for one in sel.split(',') {
let one = one.trim();
// Only simple selectors (no combinators / pseudo-classes / attributes).
if one.is_empty() || one.contains([' ', '>', '+', '~', ':', '[']) {
continue;
}
if sheet.rules.len() >= MAX_CSS_SELECTORS {
return Err(Error::Xml(format!("its <style> sheets hold more than {MAX_CSS_SELECTORS} selectors")));
}
let block = *block.get_or_insert_with(|| {
let i = sheet.blocks.len();
sheet.blocks.push(std::mem::take(&mut decls));
i
});
let (tag, classes, id) = parse_compound(one);
let specificity = (id.is_some() as u32 * 100)
.saturating_add(u32::try_from(classes.len()).unwrap_or(u32::MAX).saturating_mul(10))
.saturating_add(tag.is_some() as u32);
let order = sheet.rules.len();
sheet.rules.push(Rule { tag, classes, id, specificity, order, block });
}
}
Ok(())
fn parse_css(text: &str, sheet: &mut StyleSheet) -> Result<(), Error> {
craft_svg::simple_css::parse(text, sheet).map_err(|error| Error::Xml(error.to_string()))
}
const PROPS: &[&str] = &[
@@ -695,7 +521,7 @@ impl<'a, 'i> Parser<'a, 'i> {
}
self.apply_rules(n, &mut out);
if let Some(st) = n.attribute("style") {
for (k, v) in parse_decls(st) {
for (k, v) in craft_svg::simple_css::declarations(st) {
out.insert(k, v);
}
}
@@ -763,50 +589,9 @@ impl<'a, 'i> Parser<'a, 'i> {
self.charge_pattern_work(bytes.saturating_add(1))
}
/// Apply the matching `<style>` rules to `out`, by specificity then source order.
/// Apply the shared compatibility stylesheet rules under the document work budget.
fn apply_rules(&self, n: roxmltree::Node, out: &mut HashMap<String, String>) {
let css = &self.css;
if css.rules.is_empty() {
return;
}
// Splitting and sorting the class list is work too: charge its length first.
let class = n.attribute("class").unwrap_or_default();
if !self.charge_css(class.len()) {
return;
}
let tag = n.tag_name().name();
let mut classes: Vec<&str> = class.split_whitespace().collect();
classes.sort_unstable();
classes.dedup();
let id = n.attribute("id");
// Each rule sits in exactly one bucket and the classes are distinct: no rule twice.
let mut buckets: Vec<&Vec<usize>> = vec![&css.universal];
buckets.extend(id.and_then(|i| css.by_id.get(i)));
buckets.extend(classes.iter().filter_map(|c| css.by_class.get(*c)));
buckets.extend(css.by_tag.get(tag));
if !self.charge_css(buckets.iter().map(|b| b.len()).fold(0, usize::saturating_add)) {
return;
}
let candidates = || buckets.iter().flat_map(|b| b.iter()).filter_map(|&i| css.rules.get(i));
// A selector like `.z.z.z…` checks each of its classes: charge them too.
if !self.charge_css(candidates().map(|r| r.classes.len()).fold(0, usize::saturating_add)) {
return;
}
let mut matching: Vec<&Rule> = candidates()
.filter(|r| {
r.tag.as_deref().is_none_or(|t| t == tag)
&& r.id.as_deref().is_none_or(|i| Some(i) == id)
&& r.classes.iter().all(|c| classes.binary_search(&c.as_str()).is_ok())
})
.collect();
matching.sort_by_key(|r| (r.specificity, r.order));
let blocks: Vec<&Vec<(String, String)>> = matching.iter().filter_map(|r| css.blocks.get(r.block)).collect();
if !self.charge_css(blocks.iter().map(|b| b.len()).fold(0, usize::saturating_add)) {
return;
}
for (k, v) in blocks.into_iter().flatten() {
out.insert(k.clone(), v.clone());
}
self.css.apply(n.tag_name().name(), n.attribute("id"), n.attribute("class").unwrap_or_default(), out, |work| self.charge_css(work));
}
fn length(&self, s: &str, axis: char, font: f64) -> Option<f64> {
@@ -1668,34 +1453,7 @@ fn viewbox_transform(n: roxmltree::Node, w: f64, h: f64) -> Affine {
}
/// Parse a `transform` list.
pub fn parse_transform(s: &str) -> Affine {
let mut m = Affine::IDENTITY;
let mut rest = s;
while let Some(open) = rest.find('(') {
let name = rest[..open].trim().trim_start_matches(',').trim();
let Some(close) = rest[open..].find(')') else { break };
let (a, too_many) = pathdata::numbers_bounded(&rest[open + 1..open + close], 6);
rest = &rest[open + close + 1..];
let t = if too_many {
Affine::IDENTITY
} else {
match (name, a.as_slice()) {
("matrix", [a0, a1, a2, a3, a4, a5]) => Affine::new([*a0, *a1, *a2, *a3, *a4, *a5]),
("translate", [x]) => Affine::translate((*x, 0.0)),
("translate", [x, y]) => Affine::translate((*x, *y)),
("scale", [scale]) => Affine::scale(*scale),
("scale", [x, y]) => Affine::scale_non_uniform(*x, *y),
("rotate", [angle]) => Affine::rotate(angle.to_radians()),
("rotate", [angle, x, y]) => Affine::translate((*x, *y)) * Affine::rotate(angle.to_radians()) * Affine::translate((-*x, -*y)),
("skewX", [angle]) => Affine::new([1.0, 0.0, angle.to_radians().tan(), 1.0, 0.0, 0.0]),
("skewY", [angle]) => Affine::new([1.0, angle.to_radians().tan(), 0.0, 1.0, 0.0, 0.0]),
_ => Affine::IDENTITY,
}
};
m *= t;
}
m
}
pub use craft_svg::transform_compat::parse_transform;
/// The deepest element nesting accepted. The XML parser recurses per level and overflowed a
/// 2 MiB thread's stack (aborting the app) at a few thousand levels; real documents stay far
+4 -352
View File
@@ -1,360 +1,12 @@
//! SVG path data (SVG 1.1 §8.3 / SVG 2 §9.3): every command, implicit repeats, relative
//! coordinates, smooth curves and elliptical arcs (converted to cubics through kurbo's `SvgArc`).
//! Parsing stops at the first error, keeping what was read (as the specification asks).
//! Prefix-preserving SVG path and numeric-list parsing is shared with craft-svg.
//! App document budgets and geometry policy remain with the importer.
use kurbo::{BezPath, PathEl, Point, SvgArc, Vec2};
/// Maximum path elements retained from one SVG path or point list.
pub(crate) const MAX_PATH_ELEMENTS: usize = 100_000;
/// Tokenizer over numbers and command letters.
struct Lex<'a> {
b: &'a [u8],
i: usize,
}
impl Lex<'_> {
fn skip_sep(&mut self) {
while self.i < self.b.len() && (self.b[self.i].is_ascii_whitespace() || self.b[self.i] == b',') {
self.i += 1;
}
}
fn command(&mut self) -> Option<u8> {
self.skip_sep();
let c = *self.b.get(self.i)?;
if c.is_ascii_alphabetic() && c != b'e' && c != b'E' {
self.i += 1;
Some(c)
} else {
None
}
}
fn at_number(&mut self) -> bool {
self.skip_sep();
self.b.get(self.i).is_some_and(|c| c.is_ascii_digit() || matches!(c, b'-' | b'+' | b'.'))
}
fn number(&mut self) -> Option<f64> {
self.skip_sep();
let start = self.i;
let b = self.b;
let mut i = self.i;
if i < b.len() && matches!(b[i], b'-' | b'+') {
i += 1;
}
let mut digits = false;
while i < b.len() && b[i].is_ascii_digit() {
i += 1;
digits = true;
}
if i < b.len() && b[i] == b'.' {
i += 1;
while i < b.len() && b[i].is_ascii_digit() {
i += 1;
digits = true;
}
}
if !digits {
return None;
}
if i < b.len() && matches!(b[i], b'e' | b'E') {
let mut j = i + 1;
if j < b.len() && matches!(b[j], b'-' | b'+') {
j += 1;
}
if j < b.len() && b[j].is_ascii_digit() {
while j < b.len() && b[j].is_ascii_digit() {
j += 1;
}
i = j;
}
}
self.i = i;
let number = std::str::from_utf8(&b[start..i]).ok()?.parse::<f64>().ok()?;
number.is_finite().then_some(number)
}
/// Arc flags may be written without separators ("a1 1 0 00 1 1").
fn flag(&mut self) -> Option<bool> {
self.skip_sep();
let c = *self.b.get(self.i)?;
self.i += 1;
match c {
b'0' => Some(false),
b'1' => Some(true),
_ => None,
}
}
}
/// Parse no more than `max_values`; the flag reports whether another valid value was present.
pub(crate) fn numbers_bounded(s: &str, max_values: usize) -> (Vec<f64>, bool) {
let mut l = Lex { b: s.as_bytes(), i: 0 };
let mut v = vec![];
while l.at_number() {
if v.len() >= max_values {
return (v, true);
}
match l.number() {
Some(x) => v.push(x),
None => break,
}
}
(v, false)
}
/// Parse path data into a kurbo path, retaining at most [`MAX_PATH_ELEMENTS`] elements.
/// Malformed or overlong input returns the prefix parsed before the problem.
pub fn parse_path_data(d: &str) -> BezPath {
parse_path_data_bounded(d, MAX_PATH_ELEMENTS).0
}
/// Pen position and reflection state while parsing path commands.
struct PathState {
/// Current point.
current: Point,
/// Start of the current subpath.
start: Point,
/// Last cubic control point, for smooth curves.
last_cubic: Option<Point>,
/// Last quadratic control point, for smooth curves.
last_quad: Option<Point>,
/// Whether a subpath is open.
open: bool,
}
/// Cap on path elements and whether it has been hit.
struct PathLimit {
/// Maximum number of path elements.
max_elements: usize,
/// Set when the cap or a non-finite coordinate stopped output.
exceeded: bool,
}
/// Parse at most `max_elements`, reporting when more path geometry was present.
pub(crate) fn parse_path_data_bounded(d: &str, max_elements: usize) -> (BezPath, bool) {
let mut l = Lex { b: d.as_bytes(), i: 0 };
let mut p = BezPath::new();
let mut state = PathState { current: Point::ZERO, start: Point::ZERO, last_cubic: None, last_quad: None, open: false };
let mut limit = PathLimit { max_elements, exceeded: false };
let mut cmd: Option<u8> = None;
loop {
if p.elements().len() >= limit.max_elements {
l.skip_sep();
limit.exceeded = l.i < l.b.len();
break;
}
let c = match l.command() {
Some(c) => c,
None => match cmd {
// Implicit repeat (a moveto repeats as lineto). Z takes no numbers, so a number
// after it is an error: repeating Z would loop forever without consuming input.
Some(c) if l.at_number() && !c.eq_ignore_ascii_case(&b'z') => match c {
b'M' => b'L',
b'm' => b'l',
other => other,
},
_ => break,
},
};
let rel = c.is_ascii_lowercase();
let base = if rel { state.current.to_vec2() } else { Vec2::ZERO };
let pt = |l: &mut Lex| -> Option<Point> { Some(Point::new(l.number()?, l.number()?) + base) };
let ok = (|| -> Option<()> {
match c.to_ascii_uppercase() {
b'M' => {
state.current = pt(&mut l)?;
if !push_element(&mut p, PathEl::MoveTo(state.current), &mut limit) {
return None;
}
state.start = state.current;
state.open = true;
state.last_cubic = None;
state.last_quad = None;
}
b'Z' => {
if state.open && !push_element(&mut p, PathEl::ClosePath, &mut limit) {
return None;
}
state.current = state.start;
state.last_cubic = None;
state.last_quad = None;
}
_ if !state.open => {
// A segment without a preceding moveto starts at the current point.
if !push_element(&mut p, PathEl::MoveTo(state.current), &mut limit) {
return None;
}
state.open = true;
return segment(&mut l, c, base, &mut p, &mut state, &mut limit);
}
_ => return segment(&mut l, c, base, &mut p, &mut state, &mut limit),
}
Some(())
})();
if ok.is_none() {
break;
}
if limit.exceeded {
break;
}
cmd = Some(c);
if c.eq_ignore_ascii_case(&b'z') {
// After Z a new segment starts from the subpath start (an unused move is dropped
// below).
if !push_element(&mut p, PathEl::MoveTo(state.start), &mut limit) {
break;
}
state.open = true;
}
}
(strip_trailing_moves(p), limit.exceeded)
}
/// Push an element if finite and under the cap; otherwise mark the limit exceeded and return false.
fn push_element(p: &mut BezPath, element: PathEl, limit: &mut PathLimit) -> bool {
let finite = match element {
PathEl::MoveTo(point) | PathEl::LineTo(point) => point.x.is_finite() && point.y.is_finite(),
PathEl::QuadTo(control, point) => [control.x, control.y, point.x, point.y].iter().all(|value| value.is_finite()),
PathEl::CurveTo(first, second, point) => [first.x, first.y, second.x, second.y, point.x, point.y].iter().all(|value| value.is_finite()),
PathEl::ClosePath => true,
};
if p.elements().len() >= limit.max_elements || !finite {
limit.exceeded = true;
return false;
}
p.push(element);
true
}
/// Parse one path command's arguments into `p`, returning `None` on malformed or over-limit input.
fn segment(l: &mut Lex, c: u8, base: Vec2, p: &mut BezPath, state: &mut PathState, limit: &mut PathLimit) -> Option<()> {
let num = |l: &mut Lex| l.number();
let pt = |l: &mut Lex| -> Option<Point> { Some(Point::new(l.number()?, l.number()?) + base) };
match c.to_ascii_uppercase() {
b'L' => {
let current = pt(l)?;
if !push_element(p, PathEl::LineTo(current), limit) {
return None;
}
state.current = current;
state.last_cubic = None;
state.last_quad = None;
}
b'H' => {
let x = num(l)? + base.x;
let current = Point::new(x, state.current.y);
if !push_element(p, PathEl::LineTo(current), limit) {
return None;
}
state.current = current;
state.last_cubic = None;
state.last_quad = None;
}
b'V' => {
let y = num(l)? + base.y;
let current = Point::new(state.current.x, y);
if !push_element(p, PathEl::LineTo(current), limit) {
return None;
}
state.current = current;
state.last_cubic = None;
state.last_quad = None;
}
b'C' => {
let (c1, c2, e) = (pt(l)?, pt(l)?, pt(l)?);
if !push_element(p, PathEl::CurveTo(c1, c2, e), limit) {
return None;
}
state.last_cubic = Some(c2);
state.last_quad = None;
state.current = e;
}
b'S' => {
let c1 = state.last_cubic.map_or(state.current, |c| state.current + (state.current - c));
let (c2, e) = (pt(l)?, pt(l)?);
if !push_element(p, PathEl::CurveTo(c1, c2, e), limit) {
return None;
}
state.last_cubic = Some(c2);
state.last_quad = None;
state.current = e;
}
b'Q' => {
let (q, e) = (pt(l)?, pt(l)?);
if !push_element(p, PathEl::QuadTo(q, e), limit) {
return None;
}
state.last_quad = Some(q);
state.last_cubic = None;
state.current = e;
}
b'T' => {
let q = state.last_quad.map_or(state.current, |c| state.current + (state.current - c));
let e = pt(l)?;
if !push_element(p, PathEl::QuadTo(q, e), limit) {
return None;
}
state.last_quad = Some(q);
state.last_cubic = None;
state.current = e;
}
b'A' => {
let rx = num(l)?.abs();
let ry = num(l)?.abs();
let rot = num(l)?;
let large = l.flag()?;
let sweep = l.flag()?;
let e = pt(l)?;
let arc = SvgArc { from: state.current, to: e, radii: Vec2::new(rx, ry), x_rotation: rot.to_radians(), large_arc: large, sweep };
let mut last_end = None;
if let Some(a) = kurbo::Arc::from_svg_arc(&arc) {
// Scale tolerance with the radius so the segment count stays bounded.
let tol = 0.1_f64.max(a.radii.x.max(a.radii.y) * 1e-4);
a.to_cubic_beziers(tol, |c1, c2, end| {
if limit.exceeded {
return;
}
if push_element(p, PathEl::CurveTo(c1, c2, end), limit) {
last_end = Some(end);
}
});
}
if limit.exceeded {
return None;
}
// Degenerate arcs (e.g. huge radii) may emit nothing or stop short of the end point.
if last_end.is_none_or(|q| (q - e).hypot() > 1e-3 * (1.0 + e.to_vec2().hypot())) && !push_element(p, PathEl::LineTo(e), limit) {
return None;
}
state.current = e;
state.last_cubic = None;
state.last_quad = None;
}
_ => return None,
}
Some(())
}
/// Drop move-tos that start no segment (from closepath bookkeeping).
fn strip_trailing_moves(p: BezPath) -> BezPath {
use kurbo::PathEl;
let els = p.elements();
let mut out = BezPath::new();
for (i, e) in els.iter().enumerate() {
if let PathEl::MoveTo(_) = e {
let next_is_seg = els.get(i + 1).is_some_and(|n| !matches!(n, PathEl::MoveTo(_)));
if !next_is_seg {
continue;
}
}
out.push(*e);
}
out
}
pub use craft_svg::prefix_path::{MAX_PATH_ELEMENTS, numbers_bounded, parse_path_data, parse_path_data_bounded};
#[cfg(test)]
mod tests {
use super::*;
use kurbo::PathEl;
use kurbo::{PathEl, Point};
#[test]
/// Huge arc radii stay bounded.
-33
View File
@@ -878,27 +878,6 @@ fn selector_lists_keep_the_css_cascade() {
}
}
#[test]
fn a_comma_list_stores_its_declarations_once() {
let sels = vec!["rect"; 1000].join(",");
let decls: String = (0..50).map(|i| format!("p{i}:v;")).collect();
let mut sheet = StyleSheet::default();
parse_css(&format!("{sels}{{{decls}}}"), &mut sheet).unwrap();
assert_eq!(sheet.rules.len(), 1000);
assert_eq!(sheet.blocks.len(), 1);
assert_eq!(sheet.decls, 50);
}
#[test]
fn rules_of_unsupported_selectors_store_no_blocks() {
let mut sheet = StyleSheet::default();
parse_css(&"a b{}".repeat(100_000), &mut sheet).unwrap();
parse_css("a b{fill:red} a>b, rect{fill:blue} c:hover, d{fill:red}", &mut sheet).unwrap();
assert_eq!(sheet.rules.len(), 2);
assert_eq!(sheet.blocks.len(), 2);
assert!(sheet.rules.iter().all(|r| sheet.blocks.get(r.block).is_some_and(|b| b.len() == 1)));
}
#[test]
fn huge_class_lists_count_against_the_matching_budget() {
// One rule, but a 1 MB class attribute re-split on each of 100 `<use>` copies (#2140).
@@ -959,18 +938,6 @@ fn font_size_percentage_resolves_against_the_parent_font_size() {
}
}
#[test]
fn at_rule_blocks_are_skipped_by_brace_depth() {
let mut sheet = StyleSheet::default();
parse_css("@media print { .a{fill:#ff0000} .b{fill:#0000ff} } .c{fill:red}", &mut sheet).unwrap();
assert_eq!(sheet.rules.len(), 1);
assert_eq!(sheet.rules[0].classes, vec!["c".to_string()]);
let mut sheet = StyleSheet::default();
parse_css("@media x { @supports y { .c{} } .d{} } .e{fill:red}", &mut sheet).unwrap();
assert_eq!(sheet.rules.len(), 1);
assert_eq!(sheet.rules[0].classes, vec!["e".to_string()]);
}
/// Build a `w` x `h` document from `nodes` for sparse-content render tests.
fn sparse_doc(w: f64, h: f64, nodes: Vec<Node>) -> Doc {
let mut root = Group::new("root");
+191 -10
View File
@@ -8,7 +8,7 @@ use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use effectcraft_engine::project::{ItemId, ItemKind, Layer, LayerSource, Project, Property};
use effectcraft_engine::render::audio::db_to_gain;
use effectcraft_engine::render::audio::{self, db_to_gain};
use effectcraft_engine::time::Tick;
use egui::{Color32, Painter, Rect, Stroke, pos2};
@@ -39,6 +39,40 @@ pub fn audio_item(project: &Project, l: &Layer) -> Option<ItemId> {
}
}
/// Does the layer's [in, out) span play mirrored, as far as its waveform goes
/// ([`audio::plays_backwards`])? A reversed layer (negative stretch) is audible and plays the
/// source span backwards through its time mapping (#3239), which `Layer::layer_time` already
/// gives, so only the Backwards effect adds a mirror, and on a reversed layer it undoes the
/// reversal. The Audio switch and solo are not followed: a muted layer still shows its waveform.
fn played(layer: &Layer) -> bool {
audio::plays_backwards(layer)
}
/// The summary bins under the Timeline column for comp times `ta .. tb` (seconds, limited to
/// the layer's [in, out) span), as the layer plays them: mirrored over that span when `mirror`
/// (see [`played`]), so the first column shows the last samples.
fn column_bins<'a>(layer: &Layer, s: &'a Summary, ta: f64, tb: f64, mirror: bool) -> Option<&'a [[f32; 4]]> {
let (i, o) = (layer.in_point.seconds(), layer.out_point.seconds());
let (ta, tb) = (ta.max(i).min(o), tb.max(i).min(o));
if tb <= ta {
return None;
}
let span = i + o;
let src = |t: f64| {
let t = if mirror { span - t } else { t };
layer.layer_time(Tick::from_seconds_f64(t)).seconds() * s.bins_per_sec as f64
};
let (u, v) = (src(ta), src(tb));
let n = s.peaks.len() as i64;
let ba = u.min(v).floor() as i64;
let bb = (u.max(v).ceil() as i64).max(ba.saturating_add(1));
let (ba, bb) = (ba.clamp(0, n), bb.clamp(0, n));
if ba >= bb {
return None;
}
s.peaks.get(ba as usize..bb as usize)
}
/// The summary for `item`, starting its computation on first request.
pub fn summary(app: &EffectcraftApp, ctx: &egui::Context, item: ItemId) -> Option<Arc<Summary>> {
let mut m = app.waveforms.map.lock().ok()?;
@@ -91,27 +125,23 @@ fn level_gains(layer: &Layer, levels: Option<&Property>, t: Tick) -> [f32; 2] {
}
/// Draw `layer`'s waveform in `rect` (left channel above right), columns mapped through the
/// timeline's time map and the layer's time mapping, limited to its [in, out) span.
/// timeline's time map and the layer's time mapping, limited to its [in, out) span and drawn as
/// the layer plays (see [`played`]).
pub(crate) fn draw(p: &Painter, rect: Rect, tm: &TMap, layer: &Layer, s: &Summary, color: Color32) {
let mid = [rect.min.y + rect.height() * 0.25, rect.min.y + rect.height() * 0.75];
let half = rect.height() * 0.25 - 1.0;
let x0 = tm.x(layer.in_point.seconds()).max(rect.min.x).floor() as i32;
let x1 = tm.x(layer.out_point.seconds()).min(rect.max.x).ceil() as i32;
let n = s.peaks.len() as i64;
let levels = layer.props.sub("audio").and_then(|g| g.get("levels"));
for c in 0..2 {
p.line_segment([pos2(x0 as f32, mid[c]), pos2(x1 as f32, mid[c])], Stroke::new(1.0, color.gamma_multiply(0.5)));
}
let mirror = played(layer);
for x in x0..x1 {
let (ta, tb) = (tm.t(x as f32), tm.t(x as f32 + 1.0));
let src = |t: f64| layer.layer_time(Tick::from_seconds_f64(t)).seconds() * s.bins_per_sec as f64;
let (ba, bb) = (src(ta).floor() as i64, src(tb).ceil() as i64);
let (ba, bb) = (ba.min(bb).clamp(0, n), ba.max(bb).max(ba + 1).clamp(0, n));
if ba >= bb {
continue;
}
let Some(bins) = column_bins(layer, s, ta, tb, mirror) else { continue };
let mut agg = [0.0f32; 4];
for b in &s.peaks[ba as usize..bb as usize] {
for b in bins {
agg[0] = agg[0].min(b[0]);
agg[1] = agg[1].max(b[1]);
agg[2] = agg[2].min(b[2]);
@@ -202,3 +232,154 @@ mod tests {
}
}
}
#[cfg(test)]
mod played_tests {
use super::*;
use effectcraft_engine::color::Label;
use effectcraft_engine::project::{Comp, Footage, FootageKind, GroupKind, build};
use effectcraft_engine::render::audio::{footage_peaks, mix_comp};
use effectcraft_engine::render::{FootageSource, Image};
use effectcraft_engine::time::FrameRate;
/// Footage audio equal to its source time (seconds) on both channels over [0, 2) s.
struct Ramp;
impl FootageSource for Ramp {
fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
None
}
fn audio(&self, _: ItemId, _: &Footage, start: Tick, frames: usize, rate: u32) -> Option<Vec<f32>> {
let t0 = start.seconds();
Some(
(0..frames)
.flat_map(|k| {
let t = t0 + k as f64 / rate as f64;
let v = if (0.0..2.0).contains(&t) { t as f32 } else { 0.0 };
[v, v]
})
.collect(),
)
}
}
/// A project with a 2 s ramp clip and a comp holding one layer of it (start and in 0 s,
/// out 1 s) changed by `edit`, and the clip's peak summary.
fn setup(edit: &dyn Fn(&mut Layer)) -> (Project, ItemId, Layer, Summary) {
let mut p = Project::default();
let f = Footage {
path: "ramp.wav".into(),
kind: FootageKind::Audio,
has_audio: true,
frame_rate: FrameRate::new(25, 1),
duration: Tick::from_seconds_f64(2.0),
..Default::default()
};
let fid = p.add_item("ramp.wav", Label::SeaFoam, None, ItemKind::Footage(f.clone()));
let mut comp = Comp::new(64, 64, FrameRate::new(25, 1), Tick::from_seconds_f64(2.0));
let mut l = build::layer(&mut p, &comp, "a", LayerSource::Footage { item: fid }, (0, 0), None);
(l.start_time, l.in_point, l.out_point) = (Tick::ZERO, Tick::ZERO, Tick::from_seconds_f64(1.0));
edit(&mut l);
comp.layers = vec![l.clone()].into();
let cid = p.add_item("C", Label::Sandstone, None, ItemKind::Comp(comp.into()));
let peaks = footage_peaks(&Ramp, fid, &f, f.duration, BINS_PER_SEC);
(p, cid, l, Summary { bins_per_sec: BINS_PER_SEC, peaks })
}
fn add_backwards(l: &mut Layer, enabled: bool) {
let mut n = 1_000_000;
let mut g = build::Ids(&mut n).group("backwards", "Backwards");
g.kind = GroupKind::Effect { effect: "ec.audio.backwards".into() };
g.enabled = enabled;
l.props.group_mut("effects").expect("effects group").children.push(g.into());
}
/// The loudest left-channel peak drawn in the column for comp times `ta .. tb`.
fn drawn(l: &Layer, s: &Summary, ta: f64, tb: f64) -> Option<f32> {
column_bins(l, s, ta, tb, played(l)).map(|bins| bins.iter().fold(f32::MIN, |m, b| m.max(b[1])))
}
/// The left-channel sample the mix plays at comp time `t`.
fn heard(p: &Project, cid: ItemId, t: f64) -> f32 {
mix_comp(p, &Ramp, None, cid, Tick::from_seconds_f64(t), 1, 8000).first().copied().unwrap_or(f32::NAN)
}
/// Columns of `l` over [0, 1) s: each drawn peak against what the mix plays at the column.
fn assert_columns_match_the_mix(p: &Project, cid: ItemId, l: &Layer, s: &Summary, name: &str) {
let mut max_drawn = 0.0f32;
for k in 0..100 {
let (ta, tb) = (k as f64 / 100.0, (k + 1) as f64 / 100.0);
let d = drawn(l, s, ta, tb).unwrap_or_else(|| panic!("{name}: no column at {ta} s"));
let h = heard(p, cid, (ta + tb) * 0.5);
// The ramp rises 0.01 per column, so a column's peak is within a couple of steps.
assert!((d - h).abs() < 0.03, "{name}: column at {ta} s draws {d}, heard {h}");
max_drawn = max_drawn.max(d);
}
assert!(max_drawn > 0.9, "{name}: the waveform is drawn (loudest {max_drawn})");
}
/// #3238/#3239: a time-reversed layer (Time-Reverse Layer: stretch -100 %, start time at its
/// out point) is audible, and its waveform columns agree with the mix: loud first, quiet last.
#[test]
fn a_reversed_layer_draws_the_waveform_the_mix_plays() {
let (p, cid, l, s) = setup(&|l| {
l.stretch = -100.0;
l.start_time = Tick::from_seconds_f64(1.0);
});
assert_columns_match_the_mix(&p, cid, &l, &s, "reversed");
assert!(heard(&p, cid, 0.005) > 0.98, "the mix plays the clip's last samples first");
assert!(heard(&p, cid, 0.995) < 0.02, "and its first samples last");
}
/// Backwards on a reversed layer plays it forwards again, and the waveform follows.
#[test]
fn a_double_reversal_draws_the_waveform_forwards() {
let (p, cid, l, s) = setup(&|l| {
l.stretch = -100.0;
l.start_time = Tick::from_seconds_f64(1.0);
add_backwards(l, true);
});
assert_columns_match_the_mix(&p, cid, &l, &s, "double reversal");
assert!(heard(&p, cid, 0.005) < 0.02, "the mix plays the clip's first samples first");
assert!(heard(&p, cid, 0.995) > 0.98, "and its last samples last");
}
/// #3238: with the Backwards audio effect the first column shows the clip's last samples
/// and the last column its first, matching what the mix plays there.
#[test]
fn backwards_draws_the_waveform_mirrored_as_the_mix_plays_it() {
let (p, cid, l, s) = setup(&|l| add_backwards(l, true));
let first = drawn(&l, &s, 0.0, 0.005).expect("first column");
let h = heard(&p, cid, 0.0);
assert!(first > 0.98, "first column draws {first}, not the clip's last samples");
assert!((first - h).abs() < 0.01, "first column {first}, heard {h}");
let last = drawn(&l, &s, 0.995, 1.0).expect("last column");
let h = heard(&p, cid, 0.995);
assert!(last < 0.02, "last column draws {last}, not the clip's first samples");
assert!((last - h).abs() < 0.01, "last column {last}, heard {h}");
}
/// No Backwards effect, a disabled one, or the layer's Effects switch off: the mix plays
/// forwards, and so the waveform is drawn.
#[test]
fn without_an_active_backwards_effect_the_waveform_runs_forwards() {
let edits: [(&str, &dyn Fn(&mut Layer)); 3] = [
("no effect", &|_| {}),
("effect disabled", &|l| add_backwards(l, false)),
("effects switch off", &|l| {
add_backwards(l, true);
l.switches.effects = false;
}),
];
for (name, edit) in edits {
let (p, cid, l, s) = setup(edit);
let first = drawn(&l, &s, 0.0, 0.005).expect("first column");
let h = heard(&p, cid, 0.004);
assert!(first < 0.02, "{name}: first column draws {first}");
assert!((first - h).abs() < 0.01, "{name}: first column {first}, heard {h}");
// A column reaching past the out point draws only up to it.
let edge = drawn(&l, &s, 0.998, 1.003).expect("edge column");
assert!(edge < 1.001, "{name}: the edge column draws {edge}, past the out point");
assert_eq!(drawn(&l, &s, 1.0, 1.005), None, "{name}: a column after the out point");
}
}
}