use super::footage::NoFootage; use super::opts::RenderOpts; use super::{Arc, EvalCtx, Footage, FrameBlend, FrameRate, Image, ItemId, Layer, LayerSource, Project, Renderer, TICKS_PER_SECOND, Tick, shapes, text}; use rayon::prelude::*; /// The layer's frame blending mode, if the comp's Enable Frame Blending switch is on. /// One field of an interlaced frame as a full frame: the field's lines (`parity` 0 = even / /// upper, 1 = odd / lower) kept, the other lines interpolated from their neighbours. pub fn field_frame(img: &Image, parity: usize) -> Image { let (w, h) = (img.width as usize, img.height as usize); let mut out = img.clone(); if h < 2 { return out; } for y in 0..h { if y % 2 == parity { continue; } let above = y.checked_sub(1); let below = (y + 1 < h).then_some(y + 1); for x in 0..w { let px = match (above, below) { (Some(a), Some(b)) => { let (p, q) = (img.data[a * w + x], img.data[b * w + x]); [(p[0] + q[0]) * 0.5, (p[1] + q[1]) * 0.5, (p[2] + q[2]) * 0.5, (p[3] + q[3]) * 0.5] } (Some(a), None) => img.data[a * w + x], (None, Some(b)) => img.data[b * w + x], (None, None) => img.data[y * w + x], }; out.data[y * w + x] = px; } } out } /// Interpret Footage ▸ Cineon Settings ▸ Logarithmic Conversion converts the log code values of /// a decoded (premultiplied) frame of `f` to the Current Gamma. When the conversion does not /// apply, the frame is returned unchanged. pub fn cineon_frame(img: Arc, f: &Footage) -> Arc { if !f.cineon_applies() { return img; } let cs = f.cineon; let mut out = (*img).clone(); out.data.par_iter_mut().for_each(|p| { let a = p[3]; let c = if a > 1e-6 { [p[0] / a, p[1] / a, p[2] / a] } else { [0.0; 3] }.map(|v| cs.convert(v)); *p = [c[0] * a, c[1] * a, c[2] * a, a]; }); Arc::new(out) } /// Interpret Footage ▸ Invert Alpha and Interpret As Linear Light on decoded (premultiplied) /// pixels; linear light is encoded in `space` ([`color::Pipe::linear_footage_space`]). pub fn interpret_pixels(img: &Image, f: &Footage, space: effectcraft_color::ColorSpace) -> Image { let linear = f.linear_light_applies(); if !f.invert_alpha && !linear { return img.clone(); } let mut out = img.clone(); for p in out.data.iter_mut() { let a = p[3]; let mut c = if a > 1e-6 { [p[0] / a, p[1] / a, p[2] / a] } else { [0.0; 3] }; if linear { // The file's values are linear light: encode them like the rest of the footage. c = c.map(|v| space.encode(v)); } let a = if f.invert_alpha { 1.0 - a } else { a }; *p = [c[0] * a, c[1] * a, c[2] * a, a]; } out } pub(crate) fn frame_blend_mode(ctx: &EvalCtx, layer: &Layer) -> FrameBlend { if ctx.comp.enable_frame_blending { layer.switches.frame_blend } else { FrameBlend::Off } } /// Position of source time `t` among frames at `rate`: the frame at or before `t` and the /// fraction (0..1) of the way to the next frame. Exact (integer tick arithmetic), so frames that /// line up exactly report a fraction of 0. pub fn frame_position(t: Tick, rate: FrameRate) -> (i64, f64) { // A project file can carry a zero or negative rate; there are no frames to land between. if rate.num <= 0 || rate.den <= 0 { return (0, 0.0); } let num = t.0 as i128 * rate.num as i128; let den = TICKS_PER_SECOND as i128 * rate.den as i128; (num.div_euclid(den) as i64, num.rem_euclid(den) as f64 / den as f64) } /// The fewest source frames one comp frame must run through before frame blending averages all /// of them ([`mix_window`]); below this the two neighbouring frames blend as they always have. /// Conservative on purpose: common footage (60p in a 30, 25 or 24 fps comp, 50p in 25) keeps /// its familiar look, while fast-conformed footage (600 fps in a 25 fps comp, #3180) gets the /// mix. Pending a comparison with After Effects, whose exact threshold is not documented. pub const MIN_MIX_FRAMES: f64 = 4.0; /// The most source frames one comp frame mixes; a wider span is sampled at this many evenly /// spaced frames (After Effects is reported to blend about a dozen; this also bounds the /// decoding per comp frame). Pending a comparison with After Effects. pub const MAX_MIX_FRAMES: usize = 16; /// A span of more source frames than this in one comp frame is a jump (a time remap cut), not /// motion to blur. pub const MAX_MIX_SPAN: f64 = 1000.0; /// How finely [`blend_spans`] probes the source's speed: at 1/16 of a comp frame. const SPEED_PROBE: i64 = 16; /// How far a frame-blended layer's source runs during one comp frame from the context time /// (Interpret Footage's conformed rate, time stretch and time remap all show up in it), as /// `(local, whole)`: the local speed just after the comp frame's time scaled to a whole frame, /// and the actual difference to the next comp frame. They disagree across a time remap jump /// (a hold keyframe followed by a cut, a `loopOut` wrapping back), which then does not mix. /// Measured on the shown source time ([`EvalCtx::nested_time`]: a precomp proxy that preserves /// its frame rate is floored to its frames). pub(crate) fn blend_spans(ctx: &EvalCtx, layer: &Layer) -> (Tick, Tick) { let frame = ctx.comp.frame_duration(); let t0 = ctx.nested_time(layer); let probe = Tick(frame.0 / SPEED_PROBE); let local = ctx.at(ctx.time + probe).nested_time(layer) - t0; let whole = ctx.at(ctx.time + frame).nested_time(layer) - t0; (Tick(local.0.saturating_mul(SPEED_PROBE)), whole) } /// The source frames a frame-blended comp frame averages when the layer runs through many /// source frames per comp frame (footage interpreted at a much higher frame rate than the comp, /// a sped-up time stretch or time remap), so a comp frame skips whole source frames: the frames /// at `rate` that one comp frame's worth of source from `t` overlaps, each weighted by the share /// of a frame it covers. `spans` is [`blend_spans`]' `(local, whole)`; playing forwards the span /// is `[t, t + span)`, backwards it ends with the frame at `t` (the unblended frame). `None` — /// the two neighbouring frames then blend ([`frame_position`], [`blend_frames`]) — when the span /// is shorter than [`MIN_MIX_FRAMES`], longer than [`MAX_MIX_SPAN`], or the local speed and the /// whole frame's difference disagree by more than a source frame (a time remap jump). pub fn mix_window(t: Tick, spans: (Tick, Tick), rate: FrameRate) -> Option> { if rate.num <= 0 || rate.den <= 0 { return None; } let frames_of = |s: Tick| s.0 as f64 * rate.num as f64 / (TICKS_PER_SECOND as f64 * rate.den as f64); let width = frames_of(spans.0); let whole = frames_of(spans.1); if !width.is_finite() || !whole.is_finite() || (width - whole).abs() > 1.0 + 1e-9 { return None; } if width.abs() < MIN_MIX_FRAMES - 1e-9 || width.abs() > MAX_MIX_SPAN { return None; } let (i, w) = frame_position(t, rate); let p = i as f64 + w; let lo = if width < 0.0 { p + 1.0 + width } else { p }; let width = width.abs(); let hi = lo + width; let first = lo.floor(); let n = hi.ceil() - first; if n <= MAX_MIX_FRAMES as f64 { let frames = (0..n as usize) .filter_map(|k| { let j = first + k as f64; let cover = (j + 1.0).min(hi) - j.max(lo); (cover > 1e-9).then_some((j as i64, cover)) }) .collect(); return Some(frames); } let m = MAX_MIX_FRAMES as f64; Some((0..MAX_MIX_FRAMES).map(|k| ((lo + width * (k as f64 + 0.5) / m).floor() as i64, 1.0)).collect()) } /// Blend two neighbouring frames `w` of the way from `a` to `b`: a cross-fade (Frame Mix) or a /// motion-compensated interpolation (Pixel Motion). pub fn blend_frames(mode: FrameBlend, a: &Image, b: &Image, w: f32) -> Image { match mode { FrameBlend::PixelMotion => effectcraft_raster::flow::interpolate(a, b, w), _ => effectcraft_raster::flow::mix(a, b, w), } } /// Convenience: render one frame of a comp with no footage source. /// Adaptive motion-blur sample count for a layer whose corners travel `travel` output pixels /// during the shutter: one sample per pixel, clamped to Samples Per Frame … Adaptive Sample Limit. pub fn adaptive_samples(travel: f64, per_frame: u32, limit: u32) -> usize { let lo = per_frame.clamp(2, 64) as f64; let hi = (limit.clamp(16, 256) as f64).max(lo); travel.ceil().clamp(lo, hi) as usize } /// A region of interest `[x, y, w, h]` lies within a `w`×`h` comp frame. pub fn roi_inside(r: [f64; 4], w: u32, h: u32) -> bool { r[0] >= 0.0 && r[1] >= 0.0 && r[0] + r[2] <= w as f64 + 1e-6 && r[1] + r[3] <= h as f64 + 1e-6 } /// The Extended Viewer's region of interest: the comp frame grown by `margin` × its size on every /// side (`margin` = 1 shows a pasteboard one comp wide around the frame), intersected with the /// `visible` comp-space rectangle `[x0, y0, x1, y1]` and snapped outward to whole 16 px steps from the frame edges /// so panning re-renders rarely. `None` when the visible area lies inside the frame. pub fn extended_region(w: u32, h: u32, visible: [f64; 4], margin: f64) -> Option<[f64; 4]> { let (w, h) = (w as f64, h as f64); let (mx, my) = (w * margin, h * margin); let snap_lo = |v: f64| (v / 16.0).floor() * 16.0; let snap_hi = |v: f64| (v / 16.0).ceil() * 16.0; let x0 = snap_lo(visible[0].max(-mx)).min(0.0); let y0 = snap_lo(visible[1].max(-my)).min(0.0); let x1 = w + snap_hi(visible[2].min(w + mx) - w).max(0.0); let y1 = h + snap_hi(visible[3].min(h + my) - h).max(0.0); if x0 >= 0.0 && y0 >= 0.0 && x1 <= w && y1 <= h { return None; } Some([x0, y0, x1 - x0, y1 - y0]) } /// The size of a `width` x `height` comp frame rendered at `scale` (both compositors, and the /// frame size Composition Settings shows for a Resolution). pub fn frame_size(width: u32, height: u32, scale: f64) -> (u32, u32) { (((width as f64 * scale).round() as u32).max(1), ((height as f64 * scale).round() as u32).max(1)) } pub fn render_frame(project: &Project, comp: ItemId, t: Tick, scale: f64) -> Image { Renderer::new(project, &NoFootage, RenderOpts { scale, ..Default::default() }).comp_frame(comp, t) } /// Layer-space bounds `[x0, y0, x1, y1]` of a layer's content at the context time (source size /// for solids/footage/precomps, glyph bounds for text, painted bounds for shapes). Used for viewer /// handles and hit testing. pub fn content_bounds(ctx: &EvalCtx, layer: &effectcraft_project::Layer) -> Option<[f64; 4]> { match &layer.source { LayerSource::Text => { let glyphs = text::glyph_paths(ctx, layer); let paths: Vec<_> = glyphs.into_iter().map(|g| g.0).collect(); effectcraft_path::bounds(&paths).map(|r| [r.x0, r.y0, r.x1, r.y1]) } LayerSource::Shape => layer.props.sub("contents").and_then(|c| shapes::content_bounds(ctx, layer, c)).map(|r| [r.x0, r.y0, r.x1, r.y1]), LayerSource::Camera | LayerSource::Light { .. } => None, _ => { let (w, h) = ctx.source_size(layer); (w > 0 && h > 0).then_some([0.0, 0.0, w as f64, h as f64]) } } } /// A mask/shape path as a kurbo path (for drawing overlays). pub fn kurbo_path(sp: &effectcraft_keyframe::ShapePath) -> kurbo::BezPath { effectcraft_path::to_kurbo(sp) }