GitCorner

Code

ossartcraftfilmcraft๐ŸŒ
f67d38b35cc5
//! Render previews end to end: render โ†’ green, edit โ†’ stale, undo โ†’ green, save/open keeps them,
//! delete, audio previews, playback frames from previews.

use std::sync::Arc;

use filmcraft_media::Generator;
use filmcraft_media::generators::GeneratorSource;
use filmcraft_project::{ClipId, Label, ParamValue, SequenceSettings, TrackKind, find_effect};
use filmcraft_time::{FrameRate, TICKS_PER_SECOND, Tick, TimeRange};
use serde_json::{Value, json};

use crate::Session;
use crate::previews::BarState;

fn tmp(name: &str) -> std::path::PathBuf {
    let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
    std::env::temp_dir().join(format!("filmcraft-previews-test-{name}-{}-{nanos}", std::process::id()))
}

/// A 64ร—36 24 fps sequence: V1 = matte with Tint (0..24) + plain matte (24..48), A1 = tone (0..48).
fn session(name: &str) -> (Session, ClipId) {
    session_with(name, Generator::ColorMatte { color: [0.2, 0.5, 0.8, 1.0] })
}

/// [`session`] with `video` in place of the matte on V1.
fn session_with(name: &str, video: Generator) -> (Session, ClipId) {
    let mut s = Session::default();
    s.previews.set_dir(Some(tmp(name)));
    let r = FrameRate::FPS_24;
    let mut p = (*s.project).clone();
    let matte = crate::demo::add_generator(&mut p, &s.media, GeneratorSource::new(video, 64, 36, r, Tick(10 * TICKS_PER_SECOND)), "Matte", Label::Iris, None);
    let tone = crate::demo::add_generator(
        &mut p,
        &s.media,
        GeneratorSource::new(Generator::Tone { hz: 440.0, db: -12.0 }, 0, 0, r, Tick(10 * TICKS_PER_SECOND)),
        "Tone",
        Label::Iris,
        None,
    );
    let seq = p.new_sequence("Seq", SequenceSettings { width: 64, height: 36, frame_rate: r, ..Default::default() }, 2, 1, None);
    let mut a = p.make_track_item(matte, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, r.tick_of(24)), r).unwrap();
    let mut b = p.make_track_item(matte, TrackKind::Video, r.tick_of(24), TimeRange::new(r.tick_of(24), r.tick_of(24)), r).unwrap();
    let au = p.make_track_item(tone, TrackKind::Audio, Tick::ZERO, TimeRange::new(Tick::ZERO, r.tick_of(48)), r).unwrap();
    for e in a.effects.iter_mut().chain(b.effects.iter_mut()) {
        filmcraft_project::resolve_auto_points(e, (64, 36), (64, 36));
    }
    a.effects.push(find_effect("tint").unwrap().instance());
    let a_id = a.id;
    let q = p.sequence_mut(seq).unwrap();
    q.video_tracks[0].items = vec![a, b];
    q.audio_tracks[0].items = vec![au];
    s.project = Arc::new(p);
    s.state.active_sequence = Some(seq);
    s.state.open_sequences = vec![seq];
    (s, a_id)
}

fn states(s: &Session) -> Vec<String> {
    let v = crate::previews::bar_json(s).unwrap();
    v["segments"].as_array().unwrap().iter().map(|g| g["state"].as_str().unwrap().to_string()).collect()
}

fn job_ok(s: &Session, v: &Value) {
    let id = v["job"].as_u64().expect("a job was started");
    let j = s.jobs.iter().find(|j| j.id == id).unwrap().to_json();
    assert!(j["finished"].as_bool().unwrap(), "{j}");
    assert!(j["result"].get("error").is_none(), "{j}");
}

/// Render the (yellow) Tint segment: Enter leaves yellow segments live, so render the selection.
fn render_tint(s: &mut Session, tint: ClipId) -> Value {
    s.state.selection = vec![tint];
    let v = s.execute("sequence.renderSelection", json!({"wait": true})).unwrap();
    job_ok(s, &v);
    v
}

#[test]
fn render_turns_green_edit_invalidates_and_undo_restores() {
    let (mut s, a) = session("undo");
    assert_eq!(states(&s), vec!["yellow", "none"]);
    let v = render_tint(&mut s, a);
    assert_eq!(v["segments"], 1, "only the segment with the selected clip");
    assert_eq!(states(&s), vec!["green", "none"]);
    assert_eq!(s.previews.count(), 1);
    // playback reads preview frames for the rendered segment only
    let seq = s.state.active_sequence.unwrap();
    let f = s.previews.frame(&s.media, &s.project, seq, 5, 1.0).expect("preview frame");
    assert_eq!((f.width, f.height), (64, 36));
    assert!(s.previews.frame(&s.media, &s.project, seq, 30, 1.0).is_none());
    // the preview frame matches the live render closely (ProRes 10-bit)
    let live = filmcraft_render::render_sequence(
        &s.project,
        seq,
        FrameRate::FPS_24.tick_of(5),
        Default::default(),
        &s.media.provider(s.project.clone(), s.services.clone()),
    );
    let live = live.over_black_rgba8();
    let prev = f.to_rgba8();
    let diff = live.iter().zip(&prev).map(|(a, b)| (*a as i32 - *b as i32).abs()).max().unwrap();
    assert!(diff <= 4, "preview differs from live render by {diff}");
    // edit the effect โ†’ stale
    s.edit_sequence("Tint", |q, _, _| {
        let (_, it) = q.find_item_mut(a).unwrap();
        it.effect_mut("tint").unwrap().params.values_mut().find(|p| matches!(p.value, ParamValue::Float(_))).unwrap().value = ParamValue::Float(30.0);
        Ok(())
    })
    .unwrap();
    assert_eq!(states(&s), vec!["yellow", "none"]);
    // undo โ†’ the old content hash โ†’ green again
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(states(&s), vec!["green", "none"]);
    s.execute("edit.redo", json!({})).unwrap();
    assert_eq!(states(&s), vec!["yellow", "none"]);
    s.execute("edit.undo", json!({})).unwrap();
    // nothing left to render
    let v = s.execute("sequence.renderEffectsInToOut", json!({"wait": true})).unwrap();
    assert!(v["job"].is_null());
    // Render In to Out also renders the no-bar segment
    let v = s.execute("sequence.renderInToOut", json!({"wait": true})).unwrap();
    assert_eq!(v["segments"], 1);
    assert_eq!(states(&s), vec!["green", "green"]);
    let bar = s.previews.bar(&s.project, s.state.active_sequence.unwrap());
    assert_eq!(bar.len(), 1, "adjacent green spans merge in the drawn bar");
    assert_eq!(bar[0].state, BarState::Green);
    // Delete Render Files In to Out (In/Out around the second clip only)
    s.edit_sequence("marks", |q, _, _| {
        q.mark_in = Some(FrameRate::FPS_24.tick_of(30));
        q.mark_out = Some(FrameRate::FPS_24.tick_of(40));
        Ok(())
    })
    .unwrap();
    s.execute("sequence.deleteRenderFilesInToOut", json!({})).unwrap();
    assert_eq!(states(&s), vec!["green", "none"]);
    s.execute("sequence.deleteRenderFiles", json!({})).unwrap();
    assert_eq!(states(&s), vec!["yellow", "none"]);
    assert_eq!(s.previews.count(), 0);
    assert!(!s.is_enabled("sequence.deleteRenderFiles"), "disabled with no files");
    let _ = std::fs::remove_dir_all(s.previews.dir().unwrap());
}

fn max_diff(a: &[u8], b: &[u8]) -> i32 {
    a.iter().zip(b).map(|(a, b)| (*a as i32 - *b as i32).abs()).max().unwrap()
}

fn set_marks(s: &mut Session, marks: Option<(i64, i64)>) {
    let r = FrameRate::FPS_24;
    s.edit_sequence("marks", |q, _, _| {
        q.mark_in = marks.map(|m| r.tick_of(m.0));
        q.mark_out = marks.map(|m| r.tick_of(m.1));
        Ok(())
    })
    .unwrap();
}

/// Render-bar spans as (first frame, end frame, state).
fn spans(s: &Session) -> Vec<(i64, i64, BarState)> {
    let r = FrameRate::FPS_24;
    s.previews.bar(&s.project, s.state.active_sequence.unwrap()).iter().map(|b| (r.frame_at(b.start), r.frame_at(b.end), b.state)).collect()
}

/// #424: Render In to Out renders the frames between In and Out, not every segment that In/Out
/// touches; a later render fills only the gaps, and Delete Render Files In to Out removes only the
/// files holding marked frames.
#[test]
fn render_in_to_out_renders_only_the_marked_frames() {
    use BarState::{Green, None as NoBar, Yellow};
    let (mut s, _) = session_with("range", Generator::CountingLeader);
    let seq = s.state.active_sequence.unwrap();
    set_marks(&mut s, Some((6, 11)));
    let v = s.execute("sequence.renderInToOut", json!({"wait": true})).unwrap();
    job_ok(&s, &v);
    assert_eq!(v["frames"], 6, "frames 6..=11, not the whole 24-frame segment: {v}");
    assert_eq!(spans(&s), vec![(0, 6, Yellow), (6, 12, Green), (12, 24, Yellow), (24, 48, NoBar)]);
    assert_eq!(states(&s), vec!["yellow", "none"], "a partly rendered segment is not green");
    assert_eq!(crate::previews::bar_json(&s).unwrap()["segments"][0]["renderedFrames"], 6);
    for f in [5, 12, 30] {
        assert!(s.previews.frame(&s.media, &s.project, seq, f, 1.0).is_none(), "frame {f} has no preview");
    }
    // the preview's frames line up with the sequence (the leader changes from frame to frame)
    let live = |s: &Session, f: i64| {
        filmcraft_render::render_sequence(
            &s.project,
            seq,
            FrameRate::FPS_24.tick_of(f),
            Default::default(),
            &s.media.provider(s.project.clone(), s.services.clone()),
        )
        .over_black_rgba8()
    };
    let prev = s.previews.frame(&s.media, &s.project, seq, 9, 1.0).expect("frame 9 has a preview").to_rgba8();
    assert!(max_diff(&live(&s, 9), &live(&s, 3)) > 16, "the test needs frames that differ");
    let d = max_diff(&live(&s, 9), &prev);
    assert!(d <= 4, "preview of frame 9 differs from the live frame 9 by {d}");
    // the files survive re-indexing the folder (as on reopening the project)
    s.previews.set_dir(s.previews.dir());
    assert_eq!(spans(&s)[1], (6, 12, Green));
    // In/Out over the whole sequence: only the two gaps around the part, and the second segment
    set_marks(&mut s, None);
    let v = s.execute("sequence.renderInToOut", json!({"wait": true})).unwrap();
    job_ok(&s, &v);
    assert_eq!((v["segments"].as_i64(), v["frames"].as_i64()), (Some(3), Some(18 + 24)), "{v}");
    assert_eq!(states(&s), vec!["green", "green"]);
    assert_eq!(s.previews.count(), 4);
    let prev = s.previews.frame(&s.media, &s.project, seq, 20, 1.0).expect("frame 20 has a preview").to_rgba8();
    assert!(max_diff(&live(&s, 20), &prev) <= 4);
    // Delete Render Files In to Out keeps the parts outside In/Out
    set_marks(&mut s, Some((7, 8)));
    let v = s.execute("sequence.deleteRenderFilesInToOut", json!({})).unwrap();
    assert_eq!(v["deleted"], 1);
    assert_eq!(spans(&s), vec![(0, 6, Green), (6, 12, Yellow), (12, 48, Green)]);
    let _ = std::fs::remove_dir_all(s.previews.dir().unwrap());
}

#[test]
fn previews_survive_save_and_open() {
    let (mut s, a) = session("save");
    render_tint(&mut s, a);
    let folder = tmp("save-project");
    std::fs::create_dir_all(&folder).unwrap();
    let path = folder.join("Film.fcproj").to_string_lossy().to_string();
    s.execute("file.save", json!({"path": path})).unwrap();
    // the unsaved project's previews moved next to the project
    assert_eq!(s.previews.dir().unwrap(), folder.join("FilmCraft Previews").join("Film"));
    assert_eq!(states(&s), vec!["green", "none"]);
    let mut t = Session::default();
    t.execute("file.open", json!({"path": path})).unwrap();
    assert_eq!(states(&t), vec!["green", "none"], "hashes are stable across save/load");
    let _ = std::fs::remove_dir_all(&folder);
}

#[test]
fn saving_without_previews_creates_no_previews_folder() {
    // #2343: a project with nothing rendered leaves only the file it was asked to write
    let mut s = Session::default();
    let folder = tmp("save-empty");
    std::fs::create_dir_all(&folder).unwrap();
    let path = folder.join("Film.fcproj").to_string_lossy().to_string();
    s.execute("file.save", json!({"path": path})).unwrap();
    assert_eq!(s.previews.dir().unwrap(), folder.join("FilmCraft Previews").join("Film"));
    assert!(!folder.join("FilmCraft Previews").exists());
    // the first render creates it
    let (mut r, a) = session("save-empty-render");
    r.execute("file.save", json!({"path": path})).unwrap();
    assert!(!folder.join("FilmCraft Previews").exists());
    render_tint(&mut r, a);
    assert!(folder.join("FilmCraft Previews").join("Film").is_dir());
    assert_eq!(states(&r), vec!["green", "none"]);
    let _ = std::fs::remove_dir_all(&folder);
}

#[test]
fn render_selection_and_audio_previews() {
    let (mut s, a) = session("sel");
    s.state.selection = vec![a];
    let v = s.execute("sequence.renderSelection", json!({"wait": true})).unwrap();
    assert_eq!(v["segments"], 1);
    job_ok(&s, &v);
    // audio: the preview mix equals the live mix
    let seq = s.state.active_sequence.unwrap();
    let provider = s.media.provider(s.project.clone(), s.services.clone());
    let q = s.project.sequence(seq).unwrap();
    let live = filmcraft_render::audio::mix_sequence(&s.project, q, 1000, 30_000, &provider);
    let v = s.execute("sequence.renderAudio", json!({"wait": true})).unwrap();
    job_ok(&s, &v);
    assert!(s.previews.audio_segments(&s.project, seq).iter().all(|g| s.previews.has_audio(&g.hash)));
    let mixed = s.previews.mix(&s.project, seq, 1000, 30_000, &provider);
    for c in 0..2 {
        for (x, y) in live.channels[c].iter().zip(&mixed.channels[c]) {
            assert!((x - y).abs() < 1e-6);
        }
    }
    assert!(mixed.channels[0].iter().any(|x| x.abs() > 0.05), "tone is audible");
    // muting the track changes the audio hash: the preview no longer applies
    s.edit_sequence("mute", |q, _, _| {
        q.audio_tracks[0].muted = true;
        Ok(())
    })
    .unwrap();
    assert!(!s.previews.audio_segments(&s.project, seq).iter().any(|g| s.previews.has_audio(&g.hash)));
    let _ = std::fs::remove_dir_all(s.previews.dir().unwrap());
}

/// #1220: Enter (Render Effects In to Out) renders red segments only, as in Premiere. Yellow
/// segments play in real time; rendering them made Enter on a 49-minute 4K sequence of plain phone
/// clips encode 126 000 frames of ProRes.
#[test]
fn enter_renders_only_red_segments() {
    use crate::previews::RenderMode;
    use filmcraft_render::preview::Need;
    assert!(RenderMode::EffectsInToOut.renders(Need::Render));
    assert!(!RenderMode::EffectsInToOut.renders(Need::Realtime));
    assert!(!RenderMode::EffectsInToOut.renders(Need::None));
    for need in [Need::None, Need::Realtime, Need::Render] {
        assert!(RenderMode::InToOut.renders(need));
        assert!(RenderMode::Selection.renders(need));
    }
    // a sequence with yellow and no-bar segments only: nothing to render, no job, no folder
    let (mut s, _) = session("enter-yellow");
    assert_eq!(states(&s), vec!["yellow", "none"]);
    let v = s.execute("sequence.renderEffectsInToOut", json!({"wait": true})).unwrap();
    assert!(v["job"].is_null(), "{v}");
    assert_eq!(states(&s), vec!["yellow", "none"]);
    assert_eq!(s.previews.count(), 0);
    assert!(!s.previews.dir().unwrap().exists(), "no previews folder for nothing rendered");
}

/// #1220 end to end: on a red and a yellow segment, Enter starts a job for the red one only.
#[test]
fn enter_renders_the_red_segment_and_leaves_the_yellow_one() {
    let mut s = Session::default();
    s.previews.set_dir(Some(tmp("enter-red")));
    let r = FrameRate::FPS_24;
    let mut p = (*s.project).clone();
    let matte = GeneratorSource::new(Generator::ColorMatte { color: [0.2, 0.5, 0.8, 1.0] }, 1920, 1080, r, Tick(TICKS_PER_SECOND));
    let matte = crate::demo::add_generator(&mut p, &s.media, matte, "Matte", Label::Iris, None);
    // 1080p, where four heavy effects cost more than a frame lasts (red) and a Tint does not
    let seq = p.new_sequence("Seq", SequenceSettings { width: 1920, height: 1080, frame_rate: r, ..Default::default() }, 1, 1, None);
    let clip = |p: &mut filmcraft_project::Project, at: i64, fx: &[&str]| {
        let mut it = p.make_track_item(matte, TrackKind::Video, r.tick_of(at), TimeRange::new(r.tick_of(at), r.tick_of(2)), r).unwrap();
        for e in &mut it.effects {
            filmcraft_project::resolve_auto_points(e, (1920, 1080), (1920, 1080));
        }
        it.effects.extend(fx.iter().map(|f| find_effect(f).unwrap().instance()));
        it
    };
    let red = clip(&mut p, 0, &["gaussian_blur", "sharpen", "lumetri", "noise"]);
    let yellow = clip(&mut p, 2, &["tint"]);
    p.sequence_mut(seq).unwrap().video_tracks[0].items = vec![red, yellow];
    s.project = Arc::new(p);
    s.state.active_sequence = Some(seq);
    s.state.open_sequences = vec![seq];
    assert_eq!(states(&s), vec!["red", "yellow"]);
    let v = s.execute("sequence.renderEffectsInToOut", json!({"wait": true})).unwrap();
    job_ok(&s, &v);
    assert_eq!((v["segments"].as_i64(), v["frames"].as_i64()), (Some(1), Some(2)), "{v}");
    assert_eq!(states(&s), vec!["green", "yellow"]);
    let _ = std::fs::remove_dir_all(s.previews.dir().unwrap());
}

#[test]
fn render_commands_are_registered_like_premiere() {
    let f = |id| crate::commands::find(id).unwrap();
    assert_eq!(f("sequence.renderEffectsInToOut").shortcut, Some("Enter"));
    for id in [
        "sequence.renderEffectsInToOut",
        "sequence.renderInToOut",
        "sequence.renderSelection",
        "sequence.renderAudio",
        "sequence.deleteRenderFiles",
        "sequence.deleteRenderFilesInToOut",
    ] {
        assert_eq!(f(id).menu, &["Sequence"]);
    }
}

#[test]
fn float_wav_round_trip() {
    let x: Vec<f32> = (0..200).map(|i| (i as f32 * 0.1).sin()).collect();
    assert_eq!(crate::previews::read_wav_f32(&crate::previews::write_wav_f32(&x, 48_000)).unwrap(), x);
}

#[test]
fn wav_header_matches_the_whole_file_writer_and_refuses_what_does_not_fit() {
    let x = vec![0.5f32; 200];
    let whole = crate::previews::write_wav_f32(&x, 44_100);
    assert_eq!(&crate::previews::wav_header_f32(100, 44_100).unwrap()[..], &whole[..44]);
    // 2^29 frames of 8 bytes is 4 GiB: the format's 32-bit sizes cannot hold it
    assert!(crate::previews::wav_header_f32(1 << 29, 48_000).is_none());
    assert!(crate::previews::wav_header_f32(u64::MAX, 48_000).is_none());
}

#[test]
fn bar_state_serializes_lowercase() {
    assert_eq!(serde_json::to_value(BarState::Green).unwrap(), json!("green"));
}

/// #2185: preview files are read in place, never whole. Rendered previews still play from their
/// files, and a file only a whole-file reader could open is refused rather than loaded.
#[test]
fn preview_files_are_streamed_not_read_whole() {
    let (mut s, a) = session("stream");
    render_tint(&mut s, a);
    let seq = s.state.active_sequence.unwrap();
    assert!(s.previews.frame(&s.media, &s.project, seq, 5, 1.0).is_some(), "a rendered frame plays from its file");
    // a still image opens only from its whole bytes: as a preview file it is not opened
    let dir = s.previews.dir().unwrap();
    let png = dir.join("still.png");
    // a 1ร—1 PNG
    const PNG: &[u8] = &[
        137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0, 1, 0, 0, 0, 1, 8, 6, 0, 0, 0, 31, 21, 196, 137, 0, 0, 0, 13, 73, 68, 65, 84,
        120, 218, 99, 100, 96, 248, 95, 15, 0, 2, 135, 1, 128, 235, 71, 186, 146, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130,
    ];
    std::fs::write(&png, PNG).unwrap();
    assert!(s.media.open_bytes("still.png", PNG.into()).is_ok(), "the image opens from its bytes");
    // (the web, without a file reader, still reads preview files whole)
    if cfg!(any(unix, windows)) {
        assert!(crate::previews::open_preview_file(&s.media, "still.png", &png).is_none());
    }
    let _ = std::fs::remove_dir_all(dir);
}

fn job_error(s: &Session, v: &Value) -> String {
    let id = v["job"].as_u64().expect("a job was started");
    let j = s.jobs.iter().find(|j| j.id == id).unwrap().to_json();
    assert!(j["finished"].as_bool().unwrap(), "{j}");
    j["result"]["error"].as_str().unwrap_or_else(|| panic!("the job should have failed: {j}")).to_string()
}

/// A stored clip length that overflows the WAV header is a failed job, not a buffer sized from it.
#[test]
fn an_audio_segment_too_long_for_a_wav_fails_the_job() {
    let (mut s, _) = session("audio-too-long");
    s.edit_sequence("stretch", |q, _, _| {
        q.audio_tracks[0].items[0].duration = Tick(4 * 3600 * TICKS_PER_SECOND);
        Ok(())
    })
    .unwrap();
    let v = s.execute("sequence.renderAudio", json!({"wait": true})).unwrap();
    assert!(job_error(&s, &v).contains("too long"));
    let _ = std::fs::remove_dir_all(s.previews.dir().unwrap());
}

/// A preview folder that cannot be written ends the job with the OS error and leaves no preview.
#[cfg(unix)]
#[test]
fn an_unwritable_preview_folder_fails_the_audio_job() {
    use std::os::unix::fs::PermissionsExt;
    let (mut s, _) = session("audio-unwritable");
    let dir = s.previews.dir().unwrap();
    std::fs::create_dir_all(&dir).unwrap();
    std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o500)).unwrap();
    if std::fs::File::create(dir.join("probe")).is_ok() {
        // running as a user the mode does not bind (root)
        let _ = std::fs::remove_dir_all(&dir);
        return;
    }
    let v = s.execute("sequence.renderAudio", json!({"wait": true})).unwrap();
    let e = job_error(&s, &v);
    std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o700)).unwrap();
    assert!(!e.is_empty());
    assert!(!s.previews.audio_segments(&s.project, s.state.active_sequence.unwrap()).iter().any(|g| s.previews.has_audio(&g.hash)));
    let _ = std::fs::remove_dir_all(&dir);
}