GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Proxies end to end: create (background job) + attach + toggle gives the same composite modulo
//! resolution (scale-aware effects and Motion), attach checks, export ignores proxies, toggling
//! doesn't dirty the project, ingest copies on import.

use filmcraft_media::DemoScene;
use filmcraft_project::{ParamValue, find_effect};
use serde_json::json;

use crate::Session;
use crate::media_test_util::{frame_rgba, make_movie, psnr, session_with, tmp_dir};

const W: u32 = 320;
const H: u32 = 180;

/// Give V1's clip a Motion move and a blur, so proxies must render effects scale-aware.
fn add_effects(s: &mut Session) {
    let seq = s.state.active_sequence.unwrap();
    let mut p = (*s.project).clone();
    let q = p.sequence_mut(seq).unwrap();
    let it = &mut q.video_tracks[0].items[0];
    let m = it.effect_mut("motion").unwrap();
    m.params.get_mut("scale").unwrap().value = ParamValue::Float(70.0);
    m.params.get_mut("rotation").unwrap().value = ParamValue::Float(8.0);
    let mut blur = find_effect("gaussian_blur").unwrap().instance();
    if let Some(b) = blur.params.get_mut("blurriness") {
        b.value = ParamValue::Float(6.0);
    }
    it.effects.push(blur);
    s.project = std::sync::Arc::new(p);
}

#[test]
fn create_attach_toggle_renders_the_same_picture() {
    let root = tmp_dir("proxy-create");
    let a = root.join("a.mov");
    make_movie(&a, DemoScene::OceanSunset, W, H, 12);
    let (mut s, items, _) = session_with(&[&a]);
    add_effects(&mut s);
    let full = frame_rgba(&mut s, 5, 1.0);
    let full_half = frame_rgba(&mut s, 5, 0.5);
    let r = s.execute("media.createProxies", json!({"items": [items[0].0], "preset": "prores_proxy_half", "wait": true})).unwrap();
    let out = r["outputs"][0]["path"].as_str().unwrap().to_string();
    assert!(std::path::Path::new(&out).ends_with(std::path::Path::new("Proxies").join("a_Proxy.mov")), "{out}");
    let job = s.execute("jobs.list", json!({})).unwrap();
    assert_eq!(job[0]["finished"], json!(true), "{job}");
    let m = s.project.item(items[0]).unwrap().as_media().unwrap().clone();
    assert_eq!(m.proxy, Some(filmcraft_project::MediaRef::File { path: out.clone() }), "attached when the job finished");
    // proxies off: unchanged
    assert_eq!(frame_rgba(&mut s, 5, 1.0), full);
    let rev = s.revision;
    let dirty = s.is_dirty();
    s.execute("media.toggleProxies", json!({"enabled": true})).unwrap();
    assert!(s.revision > rev, "frame caches refresh");
    assert_eq!(s.is_dirty(), dirty, "toggling proxies is not an edit");
    let px = frame_rgba(&mut s, 5, 1.0);
    assert_eq!((px.0, px.1), (full.0, full.1));
    assert_ne!(px.2, full.2, "the proxy is really used");
    let q = psnr(&px.2, &full.2);
    let q_half = psnr(&frame_rgba(&mut s, 5, 0.5).2, &full_half.2);
    eprintln!("proxy vs full: {q:.1} dB at full scale, {q_half:.1} dB at ½");
    assert!(q > 30.0, "proxy composite matches full res modulo resolution: {q:.1} dB");
    assert!(q_half > 33.0, "at ½ playback resolution the proxy is near-identical: {q_half:.1} dB");
    let _ = std::fs::remove_dir_all(&root);
}

/// #1831: proxies asked for while another job runs wait their turn, one at a time in the order they
/// were asked for, instead of all encoding at once.
#[test]
fn proxy_jobs_wait_in_line_and_run_in_order() {
    let root = tmp_dir("proxy-queue");
    let (a, b) = (root.join("a.mov"), root.join("b.mov"));
    make_movie(&a, DemoScene::OceanSunset, W, H, 12);
    make_movie(&b, DemoScene::Aurora, W, H, 12);
    let (mut s, items, _) = session_with(&[&a, &b]);
    // something else is running: it holds the front of the line until it is dropped
    let busy = crate::media_queue::MEDIA_JOBS.ticket();
    let mut jobs = Vec::new();
    for it in &items {
        let r = s.execute("media.createProxies", json!({"items": [it.0], "preset": "prores_proxy_half"})).unwrap();
        jobs.push(r["job"]["job"].as_u64().or_else(|| r["job"].as_u64()).unwrap_or_else(|| panic!("{r}")));
    }
    std::thread::sleep(std::time::Duration::from_millis(400));
    let listed = s.execute("jobs.list", json!({})).unwrap();
    for id in &jobs {
        let j = listed.as_array().unwrap().iter().find(|j| j["id"] == json!(id)).unwrap();
        assert_eq!(j["finished"], json!(false), "{j}");
        assert_eq!(j["done"], json!(0), "nothing is encoded while another job holds the line: {j}");
        assert!(j["status"].as_str().unwrap().starts_with("Waiting for"), "{j}");
    }
    drop(busy);
    let all_done = |s: &Session| jobs.iter().all(|id| s.jobs.iter().any(|j| j.id == *id && j.progress.finished.load(std::sync::atomic::Ordering::Relaxed)));
    for _ in 0..1200 {
        if all_done(&s) {
            break;
        }
        std::thread::sleep(std::time::Duration::from_millis(50));
    }
    assert!(all_done(&s), "both proxies finish once the line moves");
    s.poll_persistence();
    for it in &items {
        let proxy = &s.project.item(*it).unwrap().as_media().unwrap().proxy;
        assert!(matches!(proxy, Some(filmcraft_project::MediaRef::File { .. })), "proxy not attached: {proxy:?}");
    }
    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn attach_checks_duration_and_export_ignores_proxies() {
    let root = tmp_dir("proxy-attach");
    let a = root.join("a.mov");
    make_movie(&a, DemoScene::Aurora, W, H, 12);
    let short = root.join("short.mov");
    make_movie(&short, DemoScene::Aurora, W / 2, H / 2, 6);
    // a "proxy" with other pictures but the right duration and rate
    let other = root.join("other.mp4");
    make_movie(&other, DemoScene::Plasma, W / 4, H / 4, 12);
    let (mut s, items, _) = session_with(&[&a]);
    let e = s.execute("media.attachProxies", json!({"item": items[0].0, "path": short.to_string_lossy()})).unwrap_err().to_string();
    assert!(e.contains("long"), "{e}");
    s.execute("media.attachProxies", json!({"item": items[0].0, "path": other.to_string_lossy()})).unwrap();
    let full = frame_rgba(&mut s, 4, 1.0);
    s.execute("media.toggleProxies", json!({"enabled": true})).unwrap();
    assert!(psnr(&frame_rgba(&mut s, 4, 1.0).2, &full.2) < 20.0, "monitors show the (different) proxy");
    let png = root.join("out.png").to_string_lossy().into_owned();
    s.execute("file.exportMedia", json!({"path": png, "format": "png", "wait": true})).unwrap();
    let jobs = s.execute("jobs.list", json!({})).unwrap();
    assert!(jobs.as_array().unwrap().iter().all(|j| j["result"].get("error").is_none()), "{jobs}");
    let f = image::open(root.join("out004.png")).unwrap().to_rgba8();
    assert_eq!(psnr(f.as_raw(), &full.2), f64::INFINITY, "export renders full-resolution media");
    s.execute("media.detachProxies", json!({"items": [items[0].0]})).unwrap();
    assert_eq!(frame_rgba(&mut s, 4, 1.0), full);
    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn ingest_copies_and_creates_proxies_on_import() {
    let root = tmp_dir("proxy-ingest");
    let cards = root.join("Card");
    std::fs::create_dir_all(&cards).unwrap();
    let a = cards.join("A001.mov");
    make_movie(&a, DemoScene::Forest, W, H, 8);
    let dest = root.join("Ingest");
    let mut s = Session::default();
    s.execute(
        "project.ingestSettings",
        json!({"enabled": true, "action": "copyAndCreateProxies", "destination": dest.to_string_lossy(), "preset": "h264_quarter"}),
    )
    .unwrap();
    let r = s.execute("file.import", json!({"paths": [a.to_string_lossy()]})).unwrap();
    let item = filmcraft_project::ItemId(r["items"][0].as_u64().unwrap());
    let job = r["ingest"]["job"]["job"].as_u64().unwrap_or_else(|| panic!("{r}"));
    // wait for the background proxy job, then let the session apply it
    for _ in 0..600 {
        if s.jobs.iter().any(|j| j.id == job && j.progress.finished.load(std::sync::atomic::Ordering::Relaxed)) {
            break;
        }
        std::thread::sleep(std::time::Duration::from_millis(50));
    }
    s.poll_persistence();
    let m = s.project.item(item).unwrap().as_media().unwrap();
    let copy = dest.join("A001.mov").to_string_lossy().into_owned();
    assert_eq!(m.media, filmcraft_project::MediaRef::File { path: copy.clone() }, "the clip uses the verified copy");
    assert_eq!(m.identity, Some(crate::relink::identity_of(&crate::FsServices, &a.to_string_lossy()).unwrap()));
    assert_eq!(m.proxy, Some(filmcraft_project::MediaRef::File { path: dest.join("A001_Proxy.mp4").to_string_lossy().into_owned() }));
    let _ = std::fs::remove_dir_all(&root);
}

/// Import two different camera takes with the same basename into a folder that already has
/// that name. Check the saved project with a new media pool so cached decoders cannot hide a
/// replaced file.
fn check_ingest_collision(action: &str) {
    use filmcraft_media::FrameRequest;
    use filmcraft_project::{ItemId, MediaRef};
    use filmcraft_time::FrameRate;
    use std::collections::BTreeSet;
    use std::sync::atomic::Ordering;

    let root = tmp_dir(&format!("ingest-collision-{action}"));
    let paths = [root.join("Card A/A001.mov"), root.join("Card B/A001.mov")];
    for (path, scene) in paths.iter().zip([DemoScene::Aurora, DemoScene::Plasma]) {
        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
        make_movie(path, scene, 160, 96, 4);
    }
    let original: Vec<Vec<u8>> = paths.iter().map(|p| std::fs::read(p).unwrap()).collect();
    assert_ne!(original[0], original[1], "different source takes");
    let dest = root.join("Ingest");
    std::fs::create_dir_all(&dest).unwrap();
    let existing = dest.join("A001.mov");
    let existing_bytes = b"existing destination must survive ingest";
    std::fs::write(&existing, existing_bytes).unwrap();
    let mut s = Session::default();
    s.execute("project.ingestSettings", json!({"enabled": true, "action": action, "destination": dest.to_string_lossy(), "preset": "prores_proxy_half"}))
        .unwrap();
    let result = s.execute("file.import", json!({"paths": paths.iter().map(|p| p.to_string_lossy()).collect::<Vec<_>>()})).unwrap();
    assert_eq!(result["errors"], json!([]), "{result}");
    let items: Vec<ItemId> = result["items"].as_array().unwrap().iter().map(|i| ItemId(i.as_u64().unwrap())).collect();
    assert_eq!(items.len(), 2, "both takes imported");
    if let Some(id) = result["ingest"]["job"]["job"].as_u64() {
        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
        loop {
            let job = s.jobs.iter().find(|j| j.id == id).unwrap();
            if job.progress.finished.load(Ordering::Relaxed) && job.result.lock().unwrap().is_some() {
                assert!(job.result.lock().unwrap().as_ref().unwrap().is_ok(), "ingest job failed");
                break;
            }
            assert!(std::time::Instant::now() < deadline, "ingest job did not finish");
            std::thread::sleep(std::time::Duration::from_millis(25));
        }
        s.poll_persistence();
    }
    assert_eq!(std::fs::read(&existing).unwrap(), existing_bytes, "ingest must preserve existing destination files");
    let project_path = root.join("ingested.fcproj");
    s.execute("file.save", json!({"path": project_path.to_string_lossy()})).unwrap();
    let mut reopened = Session::default();
    reopened.execute("file.open", json!({"path": project_path.to_string_lossy()})).unwrap();
    let request = FrameRequest { time: FrameRate::FPS_24.tick_of(2), scale: 1.0 };
    let mut linked = BTreeSet::new();
    let mut proxies = BTreeSet::new();
    for (index, item) in items.iter().enumerate() {
        let media = reopened.project.item(*item).unwrap().as_media().unwrap();
        let MediaRef::File { path } = &media.media else { panic!("ingest must retain file media") };
        assert!(linked.insert(path.clone()), "different takes must have different ingest paths");
        assert_eq!(std::path::Path::new(path).parent(), Some(dest.as_path()));
        assert_eq!(std::fs::read(&paths[index]).unwrap(), original[index], "source card is unchanged");
        if action != "transcode" {
            assert_eq!(std::fs::read(path).unwrap(), original[index], "each copy retains its own take");
            assert_eq!(media.identity, Some(crate::relink::identity_of_bytes(&original[index])));
        }
        let source = reopened.media.open_file(&paths[index].to_string_lossy(), &*reopened.services).unwrap();
        let expected = source.video_frame(request).unwrap();
        let ingested = reopened.source(*item).unwrap().video_frame(request).unwrap();
        let quality = |frame: &filmcraft_frame::VideoFrame| {
            let rgba = image::RgbaImage::from_raw(frame.width, frame.height, frame.to_rgba8()).unwrap();
            let expected = image::RgbaImage::from_raw(expected.width, expected.height, expected.to_rgba8()).unwrap();
            let expected = image::imageops::resize(&expected, frame.width, frame.height, image::imageops::FilterType::Triangle);
            psnr(rgba.as_raw(), expected.as_raw())
        };
        assert!(quality(&ingested) > 30.0, "saved project retains the correct picture for take {index}");
        if action == "copyAndCreateProxies" {
            let Some(MediaRef::File { path }) = &media.proxy else { panic!("copy should have its proxy attached") };
            assert!(proxies.insert(path.clone()), "different takes must have different proxy paths");
            let proxy = reopened.media.open_file(path, &*reopened.services).unwrap().video_frame(request).unwrap();
            assert!(quality(&proxy) > 30.0, "proxy retains the correct picture for take {index}");
        }
    }
    let _ = std::fs::remove_dir_all(root);
}

#[test]
fn ingest_copy_preserves_same_named_takes_and_existing_files() {
    check_ingest_collision("copy");
}

#[test]
fn ingest_copy_and_proxy_preserves_same_named_takes_and_existing_files() {
    check_ingest_collision("copyAndCreateProxies");
}

#[test]
fn ingest_transcode_preserves_same_named_takes_and_existing_files() {
    check_ingest_collision("transcode");
}

#[test]
fn ingest_copy_keeps_sources_already_at_destination_and_extensionless_names() {
    use filmcraft_project::{ItemId, MediaRef};

    for (name, numbered) in [("Take.wav", "Take 2.wav"), ("Take", "Take 2")] {
        let root = tmp_dir("ingest-copy-existing-source");
        let dest = root.join("Ingest");
        let card = root.join("Card");
        std::fs::create_dir_all(&dest).unwrap();
        std::fs::create_dir_all(&card).unwrap();
        let paths = [dest.join(name), card.join(name)];
        let takes = [filmcraft_media::wav::write_wav16(&[0.25; 960], 1, 48_000), filmcraft_media::wav::write_wav16(&[-0.25; 960], 1, 48_000)];
        for (path, bytes) in paths.iter().zip(&takes) {
            std::fs::write(path, bytes).unwrap();
        }
        let mut s = Session::default();
        s.execute("project.ingestSettings", json!({"enabled": true, "action": "copy", "destination": dest.to_string_lossy()})).unwrap();
        let result = s.execute("file.import", json!({"paths": paths.iter().map(|p| p.to_string_lossy()).collect::<Vec<_>>()})).unwrap();
        assert_eq!(result["errors"], json!([]), "{result}");
        assert_eq!(result["items"].as_array().unwrap().len(), 2);
        assert_eq!(result["ingest"]["copied"].as_array().unwrap().len(), 1, "source already at destination is kept");
        for (index, path) in [dest.join(name), dest.join(numbered)].iter().enumerate() {
            let item = ItemId(result["items"][index].as_u64().unwrap());
            let media = s.project.item(item).unwrap().as_media().unwrap();
            assert_eq!(media.media, MediaRef::File { path: path.to_string_lossy().into_owned() });
            assert_eq!(std::fs::read(path).unwrap(), takes[index]);
            assert_eq!(std::fs::read(&paths[index]).unwrap(), takes[index]);
        }
        assert_eq!(std::fs::read_dir(&dest).unwrap().count(), 2, "no unnecessary copies or trailing-dot filenames");
        let _ = std::fs::remove_dir_all(root);
    }
}

#[test]
fn ingest_copy_does_not_create_a_destination_when_the_source_is_missing() {
    use filmcraft_project::ItemId;

    let root = tmp_dir("ingest-copy-missing-source");
    let source = root.join("Take.wav");
    std::fs::write(&source, filmcraft_media::wav::write_wav16(&[0.25; 960], 1, 48_000)).unwrap();
    let mut s = Session::default();
    let imported = s.execute("file.import", json!({"paths": [source.to_string_lossy()]})).unwrap();
    let item = ItemId(imported["items"][0].as_u64().unwrap());
    let dest = root.join("Ingest");
    s.execute("project.ingestSettings", json!({"enabled": true, "action": "copy", "destination": dest.to_string_lossy()})).unwrap();
    let before = s.project.clone();
    std::fs::rename(&source, root.join("Moved.wav")).unwrap();
    assert!(crate::proxies::ingest(&mut s, &[item]).is_err());
    assert_eq!(s.project, before, "failed copy does not relink the item");
    assert!(!dest.exists(), "no destination is created before the source can be opened");
    let _ = std::fs::remove_dir_all(root);
}

/// Measure: Program-monitor playback cost of 4K H.264 with and without proxies (sequential frames
/// at ½ resolution). Run with `RAYON_NUM_THREADS=1` so wall time ≈ CPU time:
/// `cargo test --release -p filmcraft-engine proxy_playback_perf_4k -- --ignored --nocapture`.
#[test]
#[ignore = "benchmark: 4K fixture via ffmpeg"]
fn proxy_playback_perf_4k() {
    let Some(ffmpeg) = filmcraft_testkit::oracle::ffmpeg_or_skip("proxy_playback_perf_4k") else { return };
    let out = filmcraft_testkit::fixtures_dir("proxies").join("uhd_h264.mp4");
    let src = filmcraft_testkit::fixtures::generate(&out, |tmp| {
        std::process::Command::new(&ffmpeg)
            .args([
                "-y",
                "-loglevel",
                "error",
                "-f",
                "lavfi",
                "-i",
                "testsrc2=size=3840x2160:rate=24:duration=2",
                "-c:v",
                "libx264",
                "-preset",
                "fast",
                "-pix_fmt",
                "yuv420p",
                "-g",
                "48",
            ])
            .arg(tmp)
            .status()
            .is_ok_and(|s| s.success())
    })
    .expect("fixture");
    let dir = tmp_dir("proxy-perf");
    let media = dir.join("uhd.mp4");
    std::fs::copy(&src, &media).unwrap();
    let (mut s, items, _) = session_with(&[&media]);
    let n = 24;
    // (decode ms/frame as the GPU playback path pays it, CPU composite ms/frame at ½ and ¼)
    let measure = |s: &mut Session| {
        let rate = s.sequence_rate();
        let src = s.source(items[0]).unwrap();
        let _ = src.video_frame(filmcraft_media::FrameRequest { time: rate.tick_of(0), scale: 0.5 });
        let t0 = std::time::Instant::now();
        for f in 1..n {
            let _ = src.video_frame(filmcraft_media::FrameRequest { time: rate.tick_of(f), scale: 0.5 }).unwrap();
        }
        let decode = t0.elapsed().as_secs_f64() * 1000.0 / (n - 1) as f64;
        let mut comp = [0.0; 2];
        for (k, scale) in [0.5f32, 0.25].into_iter().enumerate() {
            s.media.clear();
            frame_rgba(s, 0, scale);
            let t0 = std::time::Instant::now();
            for f in 1..n {
                frame_rgba(s, f, scale);
            }
            comp[k] = t0.elapsed().as_secs_f64() * 1000.0 / (n - 1) as f64;
        }
        (decode, comp[0], comp[1])
    };
    let full = measure(&mut s);
    eprintln!("4K H.264, full res: decode {:.1} ms/frame; CPU composite {:.1} ms/frame at 1/2, {:.1} at 1/4", full.0, full.1, full.2);
    for preset in ["prores_proxy_quarter", "h264_quarter"] {
        let t0 = std::time::Instant::now();
        s.execute("media.createProxies", json!({"items": [items[0].0], "preset": preset, "wait": true})).unwrap();
        let make = t0.elapsed().as_secs_f64();
        s.execute("media.toggleProxies", json!({"enabled": true})).unwrap();
        let px = measure(&mut s);
        s.execute("media.toggleProxies", json!({"enabled": false})).unwrap();
        eprintln!(
            "{preset} proxy (made in {make:.1}s): decode {:.1} ms/frame ({:.1}x less); CPU composite {:.1} ms/frame at 1/2 ({:.1}x less), {:.1} at 1/4 ({:.1}x less)",
            px.0,
            full.0 / px.0,
            px.1,
            full.1 / px.1,
            px.2,
            full.2 / px.2
        );
    }
    let _ = std::fs::remove_dir_all(&dir);
}

/// Render previews are cached by content and reused whether proxies are on or off, so they are
/// always rendered from full-resolution media (like export).
#[test]
fn render_previews_ignore_proxies() {
    let root = tmp_dir("proxy-previews");
    let a = root.join("a.mov");
    make_movie(&a, DemoScene::Aurora, W, H, 12);
    let other = root.join("other.mp4");
    make_movie(&other, DemoScene::Plasma, W / 4, H / 4, 12);
    let (mut s, items, _) = session_with(&[&a]);
    add_effects(&mut s);
    let full = frame_rgba(&mut s, 4, 1.0);
    s.execute("media.attachProxies", json!({"item": items[0].0, "path": other.to_string_lossy()})).unwrap();
    s.execute("media.toggleProxies", json!({"enabled": true})).unwrap();
    s.execute("sequence.renderInToOut", json!({"wait": true})).unwrap();
    let seq = s.state.active_sequence.unwrap();
    let f = s.previews.frame(&s.media, &s.project, seq, 4, 1.0).expect("frame 4 has a preview");
    let q = psnr(&f.to_rgba8(), &full.2);
    assert!(q > 30.0, "preview rendered from full-resolution media, not the (different) proxy: {q:.1} dB");
    let _ = std::fs::remove_dir_all(&root);
}

/// A project can overstate a clip's duration; the generated proxy is as long as the opened source and still attaches,
/// and the progress total counts the frames actually written.
#[test]
fn generated_proxy_attaches_when_the_stored_duration_is_too_long() {
    let root = tmp_dir("proxy-overstated");
    let a = root.join("a.mov");
    make_movie(&a, DemoScene::Aurora, W, H, 12);
    let (mut s, items, _) = session_with(&[&a]);
    let real = s.project.item(items[0]).unwrap().as_media().unwrap().info.duration;
    std::sync::Arc::make_mut(&mut s.project).item_mut(items[0]).unwrap().as_media_mut().unwrap().info.duration = real + real;
    let r = s.execute("media.createProxies", json!({"items": [items[0].0], "preset": "prores_proxy_half", "wait": true})).unwrap();
    let id = r["job"]["job"].as_u64().or_else(|| r["job"].as_u64()).unwrap_or_else(|| panic!("{r}"));
    let job = s.jobs.iter().find(|j| j.id == id).unwrap();
    let (total, done) = (job.progress.total.load(std::sync::atomic::Ordering::Relaxed), job.progress.done.load(std::sync::atomic::Ordering::Relaxed));
    assert!(total <= done + 1, "total {total} counts frames beyond the {done} written");
    let proxy = &s.project.item(items[0]).unwrap().as_media().unwrap().proxy;
    assert!(matches!(proxy, Some(filmcraft_project::MediaRef::File { .. })), "proxy not attached: {proxy:?}");
    let _ = std::fs::remove_dir_all(&root);
}

/// An output made from a file the item no longer is (relinked or refreshed while the job ran) is not applied.
#[test]
fn an_item_changed_since_the_job_started_is_not_the_same_source() {
    let root = tmp_dir("proxy-changed");
    let a = root.join("a.mov");
    make_movie(&a, DemoScene::Aurora, W, H, 12);
    let (mut s, items, _) = session_with(&[&a]);
    let clip = s.project.item(items[0]).unwrap().as_media().unwrap().clone();
    let started = vec![(items[0], a.to_string_lossy().into_owned(), clip.info.duration)];
    assert!(crate::proxies::unchanged_since_start(&s.project, items[0], &started));
    std::sync::Arc::make_mut(&mut s.project).item_mut(items[0]).unwrap().as_media_mut().unwrap().info.duration = clip.info.duration + clip.info.duration;
    assert!(!crate::proxies::unchanged_since_start(&s.project, items[0], &started));
    let _ = std::fs::remove_dir_all(&root);
}

/// A job that finishes after another project was installed must not apply its outputs: its item ids
/// may name unrelated items there.
#[test]
fn a_finished_job_of_a_replaced_project_applies_nothing() {
    let root = tmp_dir("proxy-epoch");
    let a = root.join("a.mov");
    make_movie(&a, DemoScene::OceanSunset, W, H, 12);
    let (mut s, items, _) = session_with(&[&a]);
    let before = s.project.item(items[0]).unwrap().as_media().unwrap().media.clone();
    let out = root.join("copy.mov");
    make_movie(&out, DemoScene::Aurora, W, H, 12);
    let pending = |epoch| crate::proxies::PendingJob {
        job: u64::MAX,
        on_done: crate::proxies::OnDone::ReplaceMedia,
        outputs: std::sync::Arc::new(std::sync::Mutex::new(vec![(items[0], out.to_string_lossy().into_owned())])),
        source_durations: Default::default(),
        started_from: Vec::new(),
        epoch,
    };
    s.media_jobs.push(pending(s.document_epoch.wrapping_sub(1)));
    crate::proxies::poll(&mut s);
    assert_eq!(s.project.item(items[0]).unwrap().as_media().unwrap().media, before, "a stale job changed the project");
    // the same job of the current project does apply
    s.media_jobs.push(pending(s.document_epoch));
    crate::proxies::poll(&mut s);
    assert_ne!(s.project.item(items[0]).unwrap().as_media().unwrap().media, before);
}