GitCorner

Code

ossartcrafteffectcraft🌐
665bfac0b339
//! Render Settings and Output Module features end to end (through a [`Sink`], so nothing touches
//! the disk): field rendering and 3:2 pulldown, crop / region of interest / resize, alpha-only
//! and premultiplied output, the solo and guide-layer overrides, the render log, storage
//! overflow, PCM audio formats and the compositor a job renders on.

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};

use effectcraft_color::Label;
use effectcraft_effects::Buf;
use effectcraft_export::render_queue::*;
use effectcraft_export::{Job, JobOptions, Report, Sink, StorageQuota, export};
use effectcraft_keyframe::{Keyframe, Value};
use effectcraft_project::{Comp, ItemId, ItemKind, LayerSource, Project, Solid, build};
use effectcraft_render::{Accelerator, AutoPick, FxStep, Image, NoFootage, Renderer};
use effectcraft_time::{FrameRate, Tick};

const W: u32 = 64;
const H: u32 = 48;

/// A comp at `rate`, black, with a white bar 8 px wide sweeping left to right (64 px/s) and a
/// static red block at the bottom left; `extra` adds layers.
fn project(rate: FrameRate, extra: impl FnOnce(&mut Project, &mut Comp)) -> (Project, ItemId) {
    let mut p = Project::default();
    let mut comp = Comp::new(W, H, rate, Tick::from_seconds_f64(2.0));
    comp.background = [0.0, 0.0, 0.0];
    let bar = p.add_item("Bar", Label::Red, None, ItemKind::Solid(Solid { color: [1.0, 1.0, 1.0], width: 8, height: 32, pixel_aspect: 1.0 }));
    let mut l = build::layer(&mut p, &comp, "Bar", LayerSource::Solid { item: bar }, (8, 32), None);
    l.props.prop_mut("transform/position").unwrap().keys =
        vec![Keyframe::new(Tick::ZERO, Value::Vec3([0.0, 16.0, 0.0])), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Vec3([64.0, 16.0, 0.0]))];
    comp.layers.push(l);
    let red = p.add_item("Block", Label::Red, None, ItemKind::Solid(Solid { color: [1.0, 0.0, 0.0], width: 16, height: 8, pixel_aspect: 1.0 }));
    let mut b = build::layer(&mut p, &comp, "Block", LayerSource::Solid { item: red }, (16, 8), None);
    b.props.prop_mut("transform/position").unwrap().value = Value::Vec3([8.0, 44.0, 0.0]);
    comp.layers.push(b);
    extra(&mut p, &mut comp);
    let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.into()));
    (p, cid)
}

type Files = Arc<Mutex<Vec<(String, Vec<u8>)>>>;

fn custom(start: f64, end: f64) -> RenderSettings {
    RenderSettings { time_span: TimeSpan::Custom { start: Tick::from_seconds_f64(start), end: Tick::from_seconds_f64(end) }, ..Default::default() }
}

fn run_with(p: &Project, cid: ItemId, s: &RenderSettings, om: &OutputModule, path: &str, options: JobOptions, cancel: bool) -> (Result<Report, String>, Files) {
    run_on(p, cid, s, om, path, options, (None, cancel))
}

/// [`run_with`] with an accelerator.
fn run_on(
    p: &Project,
    cid: ItemId,
    s: &RenderSettings,
    om: &OutputModule,
    path: &str,
    options: JobOptions,
    execution: (Option<&dyn Accelerator>, bool),
) -> (Result<Report, String>, Files) {
    let (accel, cancel) = execution;
    let files: Files = Default::default();
    let f = files.clone();
    let sink: Box<Sink> = Box::new(move |path: &str, data: Vec<u8>| f.lock().unwrap().push((path.to_string(), data)));
    let job = Job {
        project: p,
        footage: &NoFootage,
        expr: None,
        accel,
        comp: cid,
        settings: s,
        output: om,
        path,
        sink: Some(&*sink),
        options,
        nested_switches: true,
    };
    let r = export(&job, &mut |pr| !(cancel && pr.done > 0)).map_err(|e| e.to_string());
    (r, files)
}

fn run(p: &Project, cid: ItemId, s: &RenderSettings, om: &OutputModule, path: &str) -> Files {
    let (r, files) = run_with(p, cid, s, om, path, JobOptions::default(), false);
    r.expect("export");
    files
}

fn png(files: &Files, i: usize) -> image::RgbaImage {
    let f = files.lock().unwrap();
    let pngs: Vec<&(String, Vec<u8>)> = f.iter().filter(|(p, _)| p.ends_with(".png")).collect();
    let mut pngs = pngs;
    pngs.sort_by(|a, b| a.0.cmp(&b.0));
    image::load_from_memory(&pngs[i].1).expect("png").to_rgba8()
}

fn row(img: &image::RgbaImage, y: u32) -> Vec<u8> {
    (0..img.width()).flat_map(|x| img.get_pixel(x, y).0).collect()
}

#[test]
fn field_render_interleaves_two_times() {
    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    let om = OutputModule::for_format(OutputFormat::PngSequence);
    // Frame 10 at 25 fps with fields: 0.40 s and 0.42 s.
    for (fr, upper) in [(FieldRender::UpperFirst, true), (FieldRender::LowerFirst, false)] {
        let s = RenderSettings { field_render: fr, ..custom(0.4, 0.44) };
        let fields = png(&run(&p, cid, &s, &om, "/f/field_[#####].png"), 0);
        // Progressive references at 50 fps: frames 20 (0.40 s) and 21 (0.42 s).
        let r = RenderSettings { frame_rate: Some(FrameRate::new(50, 1)), ..custom(0.4, 0.44) };
        let refs = run(&p, cid, &r, &om, "/f/ref_[#####].png");
        let (a, b) = (png(&refs, 0), png(&refs, 1));
        assert_ne!(row(&a, 10), row(&b, 10), "the bar moved between the fields");
        for y in 0..H {
            let first = (y % 2 == 0) == upper;
            assert_eq!(row(&fields, y), row(if first { &a } else { &b }, y), "{fr:?}: line {y}");
        }
    }
}

#[test]
fn pulldown_follows_the_cadence() {
    let ntsc = FrameRate::new(30000, 1001);
    let (p, cid) = project(ntsc, |_, _| {});
    let om = OutputModule::for_format(OutputFormat::PngSequence);
    let five = 5.0 * 1001.0 / 30000.0;
    let s = RenderSettings { field_render: FieldRender::UpperFirst, pulldown: Pulldown::Wssww, ..custom(0.0, five) };
    let out = run(&p, cid, &s, &om, "/p/pd_[#####].png");
    assert_eq!(out.lock().unwrap().len(), 5);
    // Film frames at 23.976 fps.
    let r = RenderSettings { frame_rate: Some(FrameRate::new(24000, 1001)), ..custom(0.0, 0.2) };
    let film = run(&p, cid, &r, &om, "/p/film_[#####].png");
    let mut pattern = String::new();
    for k in 0..5 {
        let (a, b) = Pulldown::Wssww.fields(k as u64).unwrap();
        pattern.push(if a == b { 'W' } else { 'S' });
        let img = png(&out, k);
        let (fa, fb) = (png(&film, a as usize), png(&film, b as usize));
        for y in 0..H {
            assert_eq!(row(&img, y), row(if y % 2 == 0 { &fa } else { &fb }, y), "frame {k} line {y}");
        }
    }
    assert_eq!(pattern, "WSSWW");
}

#[test]
fn crop_roi_and_resize() {
    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    let s = custom(0.4, 0.44);
    let full = png(&run(&p, cid, &s, &OutputModule::for_format(OutputFormat::PngSequence), "/c/full_[#####].png"), 0);
    let mut om = OutputModule::for_format(OutputFormat::PngSequence);
    om.crop = Crop { enabled: true, top: 4, left: 10, bottom: 6, right: 2, ..Default::default() };
    let c = png(&run(&p, cid, &s, &om, "/c/crop_[#####].png"), 0);
    assert_eq!((c.width(), c.height()), (52, 38));
    for (x, y) in [(0, 0), (20, 11), (51, 37), (3, 30)] {
        assert_eq!(c.get_pixel(x, y), full.get_pixel(x + 10, y + 4), "({x}, {y})");
    }
    // Region of interest at half resolution.
    om.crop = Crop { enabled: true, use_roi: true, roi: Some([16.0, 8.0, 32.0, 32.0]), ..Default::default() };
    let half = RenderSettings { resolution: 0.5, ..s.clone() };
    let r = png(&run(&p, cid, &half, &om, "/c/roi_[#####].png"), 0);
    assert_eq!((r.width(), r.height()), (16, 16));
    // Resize (fixed size, low and high quality) after the crop.
    om.crop = Crop::default();
    for q in [ResizeQuality::Low, ResizeQuality::High] {
        om.resize = Resize { enabled: true, width: 32, height: 20, lock_aspect: false, quality: q };
        let z = png(&run(&p, cid, &s, &om, "/c/resize_[#####].png"), 0);
        assert_eq!((z.width(), z.height()), (32, 20));
        // The red block (bottom left) survives the resize.
        let px = z.get_pixel(4, 18).0;
        assert!(px[0] > 150 && px[1] < 80, "{q:?}: {px:?}");
    }
    om.resize.lock_aspect = true;
    let z = png(&run(&p, cid, &s, &om, "/c/aspect_[#####].png"), 0);
    assert_eq!((z.width(), z.height()), (32, 24));
}

/// Resizing to the cropped frame's own dimensions must preserve every decoded PNG pixel.
/// Compare against crop-only output for padding and scaled ROIs with both resize qualities.
#[test]
fn crop_resize_preserves_pixels_when_the_cropped_size_is_requested() {
    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    for (crop, scale, expected) in [
        (Crop { enabled: true, left: 16, right: 16, ..Default::default() }, 1.0, (32, 48)),
        (Crop { enabled: true, left: -4, top: -2, ..Default::default() }, 1.0, (68, 50)),
        (Crop { enabled: true, use_roi: true, roi: Some([0.0, 24.0, 32.0, 24.0]), ..Default::default() }, 0.5, (16, 12)),
        (Crop { enabled: true, use_roi: true, roi: Some([0.0, 24.0, 32.0, 24.0]), ..Default::default() }, 2.0, (64, 48)),
    ] {
        let settings = RenderSettings { resolution: scale, ..custom(0.4, 0.44) };
        let mut output = OutputModule { crop, ..OutputModule::for_format(OutputFormat::PngSequence) };
        let reference = png(&run(&p, cid, &settings, &output, "/c/reference_[#####].png"), 0);
        assert_eq!(reference.dimensions(), expected);
        assert!(reference.pixels().any(|p| p.0[0] > 150), "the reference contains visible content");
        for quality in [ResizeQuality::Low, ResizeQuality::High] {
            output.resize = Resize { enabled: true, width: expected.0, height: 1, lock_aspect: true, quality };
            let actual = png(&run(&p, cid, &settings, &output, "/c/resized_[#####].png"), 0);
            assert_eq!(actual.dimensions(), expected);
            assert!(actual == reference, "crop {crop:?}, scale {scale}, quality {quality:?}: pixels changed");
        }
    }
}

#[test]
fn alpha_only_and_premultiplied() {
    let (p, cid) = project(FrameRate::new(25, 1), |p, comp| {
        // A half-transparent green layer over the right half.
        let g = p.add_item("Green", Label::Green, None, ItemKind::Solid(Solid { color: [0.0, 1.0, 0.0], width: 32, height: 48, pixel_aspect: 1.0 }));
        let mut l = build::layer(p, comp, "Green", LayerSource::Solid { item: g }, (32, 48), None);
        l.props.prop_mut("transform/position").unwrap().value = Value::Vec3([48.0, 24.0, 0.0]);
        l.props.prop_mut("transform/opacity").unwrap().value = Value::Scalar(50.0);
        comp.layers.insert(0, l);
    });
    let s = custom(0.0, 0.04);
    let mut om = OutputModule::for_format(OutputFormat::PngSequence);
    om.channels = Channels::Alpha;
    let a = png(&run(&p, cid, &s, &om, "/a/alpha_[#####].png"), 0);
    assert_eq!(a.get_pixel(60, 2).0[0], 128, "half-opaque green");
    assert_eq!(a.get_pixel(20, 2).0[0], 0, "transparent");
    assert_eq!(a.get_pixel(8, 44).0[0], 255, "opaque block");
    om.channels = Channels::Rgba;
    let straight = png(&run(&p, cid, &s, &om, "/a/s_[#####].png"), 0);
    om.alpha_mode = AlphaMode::Premultiplied;
    let premul = png(&run(&p, cid, &s, &om, "/a/p_[#####].png"), 0);
    assert_eq!(straight.get_pixel(60, 2).0, [0, 255, 0, 128]);
    assert_eq!(premul.get_pixel(60, 2).0, [0, 128, 0, 128]);
}

#[test]
fn solo_and_guide_layer_overrides() {
    let (p, cid) = project(FrameRate::new(25, 1), |p, comp| {
        let g = p.add_item("Guide", Label::Green, None, ItemKind::Solid(Solid { color: [0.0, 0.0, 1.0], width: 8, height: 8, pixel_aspect: 1.0 }));
        let mut l = build::layer(p, comp, "Guide", LayerSource::Solid { item: g }, (8, 8), None);
        l.props.prop_mut("transform/position").unwrap().value = Value::Vec3([56.0, 44.0, 0.0]);
        l.switches.guide = true;
        comp.layers.insert(0, l);
        // Solo the moving bar.
        comp.layers[1].switches.solo = true;
    });
    let om = OutputModule::for_format(OutputFormat::PngSequence);
    let s = custom(0.4, 0.44);
    let cur = png(&run(&p, cid, &s, &om, "/s/cur_[#####].png"), 0);
    assert_eq!(cur.get_pixel(8, 44).0[0], 0, "solo: the red block is hidden");
    assert_eq!(cur.get_pixel(56, 44).0[2], 0, "guide layers off by default");
    let off = RenderSettings { solo: CurrentOrOff::AllOff, guide_layers: CurrentOrOff::Current, ..s.clone() };
    let all = png(&run(&p, cid, &off, &om, "/s/off_[#####].png"), 0);
    assert_eq!(all.get_pixel(8, 44).0[0], 255, "Solo Switches: All Off");
    // (with solo off the guide renders too: Guide Layers: Current Settings)
    assert_eq!(all.get_pixel(56, 44).0[2], 255);
}

#[test]
fn render_logs() {
    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    let om = OutputModule::for_format(OutputFormat::PngSequence);
    let s = RenderSettings { field_render: FieldRender::UpperFirst, name: "DV-ish".into(), ..custom(0.0, 0.2) };
    let log_of = |files: &Files| {
        files.lock().unwrap().iter().find(|(p, _)| p.ends_with("_RenderLog.txt")).map(|(p, d)| (p.clone(), String::from_utf8(d.clone()).unwrap()))
    };
    // Errors Only + success: no log.
    let (r, files) = run_with(&p, cid, &s, &om, "/l/a_[#####].png", JobOptions::default(), false);
    assert!(r.unwrap().log.is_none());
    assert!(log_of(&files).is_none());
    // Plus Per Frame Info: settings and one line per frame.
    let opts = JobOptions { log: RenderLog::PlusPerFrameInfo, label: "#1 Comp".into(), ..Default::default() };
    let (r, files) = run_with(&p, cid, &s, &om, "/l/b_[#####].png", opts, false);
    let r = r.unwrap();
    let (path, text) = log_of(&files).expect("log");
    assert_eq!(r.log.as_deref(), Some(path.as_str()));
    assert_eq!(std::path::Path::new(&path), std::path::Path::new("/l/b_RenderLog.txt"));
    assert!(text.contains("Item: #1 Comp") && text.contains("Result: Done (5 frames"), "{text}");
    assert!(text.contains("Field Render: Upper Field First") && text.contains("Template: DV-ish") && text.contains("Format: PNG Sequence"), "{text}");
    assert_eq!(text.lines().filter(|l| l.contains("rendered in")).count(), 5, "{text}");
    assert!(text.contains("Frame 0 (0.000 s): rendered in") && text.contains("Frame 4 (0.160 s)"), "{text}");
    // Plus Settings: no per-frame lines.
    let opts = JobOptions { log: RenderLog::PlusSettings, ..Default::default() };
    let (_, files) = run_with(&p, cid, &s, &om, "/l/c.gif", opts, false);
    let (_, text) = log_of(&files).expect("log");
    assert!(text.contains("Render Settings:") && !text.contains("rendered in"), "{text}");
    // Errors Only + failure (the composition is gone): the error is logged.
    let gif = OutputModule::for_format(OutputFormat::Gif);
    let (r, files) = run_with(&p, ItemId(424_242), &s, &gif, "/l/d.gif", JobOptions::default(), false);
    assert!(r.is_err());
    let (path, text) = log_of(&files).expect("error log");
    assert_eq!(std::path::Path::new(&path), std::path::Path::new("/l/d_RenderLog.txt"));
    assert!(text.contains("Result: Failed") && text.contains("Error: composition not found") && !text.contains("Render Settings:"), "{text}");
    // A user stop is not an error: no log.
    let (r, files) = run_with(&p, cid, &s, &gif, "/l/e.gif", JobOptions::default(), true);
    assert!(r.is_err());
    assert!(log_of(&files).is_none());
}

/// The primary folder holds `limit` bytes; overflow folders are unlimited.
struct Quota {
    limit: u64,
    used: Mutex<u64>,
}

impl StorageQuota for Quota {
    fn has_room(&self, path: &str, bytes: u64) -> bool {
        if !std::path::Path::new(path).starts_with("/primary") {
            return true;
        }
        let mut u = self.used.lock().unwrap();
        if *u + bytes > self.limit {
            return false;
        }
        *u += bytes;
        true
    }
}

#[test]
fn storage_overflow_moves_files_to_the_overflow_folder() {
    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    let om = OutputModule::for_format(OutputFormat::PngSequence);
    let s = RenderSettings { skip_existing: false, ..custom(0.0, 0.4) };
    let q = Quota { limit: 1, used: Mutex::new(0) };
    let opts = JobOptions { storage: Some(&q), overflow: vec!["/overflow".into()], log: RenderLog::PlusSettings, ..Default::default() };
    let (r, files) = run_with(&p, cid, &s, &om, "/primary/seq_[#####].png", opts, false);
    let r = r.unwrap();
    assert_eq!(r.overflow.len(), 10, "{:?}", r.overflow);
    let f = files.lock().unwrap();
    assert_eq!(
        f.iter()
            .filter(|(p, _)| std::path::Path::new(p).parent() == Some(std::path::Path::new("/overflow"))
                && std::path::Path::new(p).file_name().is_some_and(|n| n.to_string_lossy().starts_with("seq_"))
                && p.ends_with(".png"))
            .count(),
        10
    );
    let log = f.iter().find(|(p, _)| p.ends_with("_RenderLog.txt")).map(|(_, d)| String::from_utf8_lossy(d).to_string()).unwrap();
    assert!(log.contains("Storage overflow: 10 file(s)"), "{log}");
    drop(f);
    // Use Storage Overflow off: everything stays in place.
    let off = RenderSettings { storage_overflow: false, ..s };
    let q = Quota { limit: 1, used: Mutex::new(0) };
    let opts = JobOptions { storage: Some(&q), overflow: vec!["/overflow".into()], ..Default::default() };
    let (r, files) = run_with(&p, cid, &off, &om, "/primary/seq_[#####].png", opts, false);
    assert!(r.unwrap().overflow.is_empty());
    assert!(files.lock().unwrap().iter().all(|(p, _)| std::path::Path::new(p).starts_with("/primary")));
}

#[test]
fn wav_and_aiff_channels_and_formats() {
    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    let s = custom(0.0, 0.5);
    let mut om = OutputModule::for_format(OutputFormat::Wav);
    om.audio_channels = 1;
    om.audio_format = AudioFormat::S24;
    om.audio_sample_rate = 44_100;
    let files = run(&p, cid, &s, &om, "/w/a.wav");
    let d = files.lock().unwrap()[0].1.clone();
    assert_eq!(&d[..4], b"RIFF");
    let u16_at = |o: usize| u16::from_le_bytes([d[o], d[o + 1]]);
    let u32_at = |o: usize| u32::from_le_bytes([d[o], d[o + 1], d[o + 2], d[o + 3]]);
    assert_eq!((u16_at(20), u16_at(22), u32_at(24), u16_at(32), u16_at(34)), (1, 1, 44_100, 3, 24));
    assert_eq!(u32_at(40), 22_050 * 3, "half a second of mono 24-bit");
    om.audio_channels = 2;
    om.audio_format = AudioFormat::F32;
    let files = run(&p, cid, &s, &om, "/w/b.wav");
    let d = files.lock().unwrap()[0].1.clone();
    let u16_at = |o: usize| u16::from_le_bytes([d[o], d[o + 1]]);
    assert_eq!((u16_at(20), u16_at(22), u16_at(32), u16_at(34)), (3, 2, 8, 32), "IEEE float stereo");
    // Plain AIFF has no float: 32-bit float is AIFF-C with `fl32` samples (#317).
    let mut aiff = OutputModule::for_format(OutputFormat::Aiff);
    aiff.audio_format = AudioFormat::F32;
    let files = run(&p, cid, &s, &aiff, "/w/c.aif");
    let d = files.lock().unwrap()[0].1.clone();
    let u32_at = |o: usize| u32::from_be_bytes([d[o], d[o + 1], d[o + 2], d[o + 3]]);
    assert_eq!((&d[..4], u32_at(4) as usize + 8, &d[8..12]), (&b"FORM"[..], d.len(), &b"AIFC"[..]));
    assert_eq!((&d[12..16], u32_at(16), u32_at(20)), (&b"FVER"[..], 4, 0xA280_5140));
    assert_eq!(&d[24..28], b"COMM");
    let comm = 32;
    assert_eq!(u32_at(28) as usize, 18 + 4 + 22, "COMM: AIFF fields, compression type, name");
    assert_eq!(u16::from_be_bytes([d[comm], d[comm + 1]]), 2, "stereo");
    assert_eq!(u32_at(comm + 2), 24_000, "half a second at 48 kHz");
    assert_eq!(u16::from_be_bytes([d[comm + 6], d[comm + 7]]), 32, "sample size");
    assert_eq!(&d[comm + 18..comm + 22], b"fl32");
    assert_eq!(&d[comm + 22..comm + 44], b"\x1532-bit floating point");
    let ssnd = comm + 44;
    assert_eq!((&d[ssnd..ssnd + 4], u32_at(ssnd + 4) as usize), (&b"SSND"[..], 8 + 24_000 * 2 * 4));
    // 16- and 24-bit stay plain AIFF.
    aiff.audio_format = AudioFormat::S24;
    let files = run(&p, cid, &s, &aiff, "/w/d.aif");
    let d = files.lock().unwrap()[0].1.clone();
    assert_eq!(&d[8..12], b"AIFF");
    assert_eq!(u16::from_be_bytes([d[26], d[27]]), 24, "sample size");
}

#[test]
fn cancelled_export_removes_only_files_it_opened() {
    use effectcraft_export::ExportError;
    let guard = tempfile::tempdir().unwrap();
    let dir = guard.path().to_path_buf();
    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    struct Overflow;
    impl StorageQuota for Overflow {
        fn has_room(&self, path: &str, _: u64) -> bool {
            path.contains("overflow")
        }
    }
    for overflow in [false, true] {
        let output_dir = if overflow { dir.join("overflow") } else { dir.clone() };
        std::fs::create_dir_all(&output_dir).unwrap();
        let settings = RenderSettings { skip_existing: true, storage_overflow: overflow, ..Default::default() };
        for format in [OutputFormat::PngSequence, OutputFormat::H264] {
            let om = OutputModule::for_format(format);
            let path = dir.join(if format.is_sequence() { "clip_[#####].png" } else { "clip.mp4" });
            let path = path.to_str().unwrap();
            let decoys = ["clip.aep", "clip2.psd", "clip000.mp4", "clip_99999.png", "clip_00000.png", "clip.txt", "clip_RenderLog.txt"];
            for name in decoys {
                std::fs::write(output_dir.join(name), b"keep").unwrap();
            }
            // Skip-existing checks the primary destination even when the new frames overflow.
            std::fs::write(dir.join("clip_00000.png"), b"keep").unwrap();
            let result = export(
                &Job {
                    project: &p,
                    footage: &NoFootage,
                    expr: None,
                    accel: None,
                    comp: cid,
                    settings: &settings,
                    output: &om,
                    path,
                    sink: None,
                    nested_switches: true,
                    options: JobOptions {
                        log: RenderLog::PlusPerFrameInfo,
                        storage: Some(&Overflow),
                        overflow: vec![output_dir.to_string_lossy().into_owned()],
                        ..Default::default()
                    },
                },
                &mut |progress| progress.done == 0,
            );
            assert!(matches!(result, Err(ExportError::Cancelled)), "{result:?}");
            for name in decoys {
                assert_eq!(std::fs::read(output_dir.join(name)).unwrap(), b"keep", "{name}");
            }
            let remaining: Vec<_> = std::fs::read_dir(&output_dir).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
            assert_eq!(remaining.len(), decoys.len(), "partial files remain: {remaining:?}");
        }
    }
    std::fs::remove_dir_all(dir).unwrap();
}

/// Skip Existing keeps a frame that is already in the overflow folder the frame is placed in
/// (it checked only the primary destination, then truncated the overflow file).
#[test]
fn skip_existing_keeps_a_frame_in_the_overflow_folder() {
    use std::path::PathBuf;
    // Room only in the second overflow folder; the frame already sits in the first (which is full).
    struct Overflow(PathBuf);
    impl StorageQuota for Overflow {
        fn has_room(&self, path: &str, _: u64) -> bool {
            std::path::Path::new(path).starts_with(&self.0)
        }
    }
    let guard = tempfile::tempdir().unwrap();
    let (dir, full, over) = (guard.path().to_path_buf(), guard.path().join("full"), guard.path().join("over"));
    std::fs::create_dir_all(&full).unwrap();
    std::fs::create_dir_all(&over).unwrap();
    std::fs::write(full.join("clip_00000.png"), b"keep").unwrap();
    let quota = Overflow(over.clone());
    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    let settings = RenderSettings { skip_existing: true, storage_overflow: true, ..Default::default() };
    let om = OutputModule::for_format(OutputFormat::PngSequence);
    let path = dir.join("clip_[#####].png");
    let result = export(
        &Job {
            project: &p,
            footage: &NoFootage,
            expr: None,
            accel: None,
            comp: cid,
            settings: &settings,
            output: &om,
            path: path.to_str().unwrap(),
            sink: None,
            nested_switches: true,
            options: JobOptions {
                storage: Some(&quota),
                overflow: vec![full.to_string_lossy().into_owned(), over.to_string_lossy().into_owned()],
                ..Default::default()
            },
        },
        &mut |_| true,
    );
    assert!(result.is_ok(), "{result:?}");
    assert_eq!(std::fs::read(full.join("clip_00000.png")).unwrap(), b"keep");
    assert!(!over.join("clip_00000.png").exists(), "no duplicate in another overflow folder");
    assert!(over.join("clip_00001.png").exists(), "the other frames are still written");
}

/// A GPU compositor stand-in that renders every frame solid green (the CPU draws the bar and the
/// block on black) and keeps Auto's timing history.
#[derive(Default)]
struct GreenAccel {
    pick: AutoPick,
    frames: AtomicUsize,
}

impl Accelerator for GreenAccel {
    fn name(&self) -> String {
        "green".into()
    }
    fn comp_frame(&self, r: &Renderer, comp: ItemId, _t: Tick) -> Option<Image> {
        self.frames.fetch_add(1, Ordering::SeqCst);
        let c = r.project.comp(comp)?;
        Some(Image::filled(c.width, c.height, [0.0, 1.0, 0.0, 1.0]))
    }
    fn supports_effect(&self, _id: &str) -> bool {
        false
    }
    fn effects(&self, _chain: &[FxStep], _buf: &Buf, _levels: Option<f32>) -> Option<Buf> {
        None
    }
    fn auto_pick(&self) -> Option<&AutoPick> {
        Some(&self.pick)
    }
}

#[test]
fn a_job_renders_on_one_compositor() {
    // #414: Auto chose the CPU or the GPU for each frame from measured frame times, so GPU
    // renders of the same frames differed run to run. A job renders every frame on the
    // project's renderer.
    let (mut p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    let om = OutputModule::for_format(OutputFormat::PngSequence);
    let s = custom(0.0, 0.4);
    let render = |p: &Project, accel: &GreenAccel, path: &str| {
        let (r, files) = run_on(p, cid, &s, &om, path, JobOptions::default(), (Some(accel), false));
        r.expect("export");
        (0..10).map(|i| png(&files, i)).collect::<Vec<_>>()
    };
    // Mercury GPU Acceleration: every frame on the GPU, the same in every run.
    p.settings.gpu_acceleration = true;
    let gpu = GreenAccel::default();
    let a = render(&p, &gpu, "/g/a_[#####].png");
    assert_eq!(gpu.frames.load(Ordering::SeqCst), 10);
    for (i, f) in a.iter().enumerate() {
        assert!(f.pixels().all(|px| px.0 == [0, 255, 0, 255]), "frame {i} rendered on the CPU");
    }
    assert_eq!(a, render(&p, &gpu, "/g/b_[#####].png"));
    // Mercury Software Only: every frame on the CPU.
    p.settings.gpu_acceleration = false;
    let cpu = GreenAccel::default();
    let c = render(&p, &cpu, "/g/c_[#####].png");
    assert_eq!(cpu.frames.load(Ordering::SeqCst), 0);
    assert_eq!(c[0].get_pixel(10, 44).0, [255, 0, 0, 255], "the CPU drew the red block");
}

/// A GPU compositor stand-in that renders the frame exactly as the CPU does, after `delay`, and
/// either as it is or solid green (`green`), counting its frames.
struct TimedAccel {
    delay: std::time::Duration,
    green: bool,
    frames: AtomicUsize,
}

impl TimedAccel {
    fn new(delay_ms: u64, green: bool) -> TimedAccel {
        TimedAccel { delay: std::time::Duration::from_millis(delay_ms), green, frames: AtomicUsize::new(0) }
    }
}

impl Accelerator for TimedAccel {
    fn name(&self) -> String {
        "timed".into()
    }
    fn comp_frame(&self, r: &Renderer, comp: ItemId, t: Tick) -> Option<Image> {
        self.frames.fetch_add(1, Ordering::SeqCst);
        std::thread::sleep(self.delay);
        let c = r.project.comp(comp)?;
        Some(if self.green { Image::filled(c.width, c.height, [0.0, 1.0, 0.0, 1.0]) } else { r.comp_frame_cpu(comp, t) })
    }
    fn supports_effect(&self, _id: &str) -> bool {
        false
    }
    fn effects(&self, _chain: &[FxStep], _buf: &Buf, _levels: Option<f32>) -> Option<Buf> {
        None
    }
}

/// The environment forces the compositor or the GPU frames in flight: the measured choice
/// isn't what these tests check then.
fn measurement_overridden() -> bool {
    std::env::var_os(effectcraft_export::RENDERER_ENV).is_some() || std::env::var_os("EFFECTCRAFT_GPU_INFLIGHT").is_some()
}

/// [`run_on`] on a pool of 8 threads (a batch of 8 frames: room to measure both compositors on
/// the first one, whatever the machine), returning the PNGs and the render log.
fn run_pooled(p: &Project, cid: ItemId, s: &RenderSettings, path: &str, options: JobOptions, accel: &dyn Accelerator) -> (Vec<image::RgbaImage>, String) {
    let om = OutputModule::for_format(OutputFormat::PngSequence);
    let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();
    let options = JobOptions { log: RenderLog::PlusSettings, ..options };
    let (r, files) = pool.install(|| run_on(p, cid, s, &om, path, options, (Some(accel), false)));
    let n = r.expect("export").frames as usize;
    let log = files.lock().unwrap().iter().find(|(p, _)| p.ends_with("_RenderLog.txt")).map(|(_, d)| String::from_utf8(d.clone()).unwrap()).expect("log");
    ((0..n).map(|i| png(&files, i)).collect(), log)
}

#[test]
fn a_transfer_bound_gpu_job_renders_on_the_cpu() {
    // #3335: a GPU project whose GPU frames are slower than the CPU's renders the whole job on
    // the CPU's frame-parallel compositor, measured on its first frames, and says so in the log.
    if measurement_overridden() {
        return;
    }
    let (mut p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    p.settings.gpu_acceleration = true;
    let s = custom(0.0, 0.8);
    let slow = TimedAccel::new(60, true);
    let (frames, log) = run_pooled(&p, cid, &s, "/r/a_[#####].png", JobOptions::default(), &slow);
    assert_eq!(frames.len(), 20);
    // The GPU rendered its warm-up and timed frames only, and none of them is in the output.
    assert_eq!(slow.frames.load(Ordering::SeqCst), 3);
    for (i, f) in frames.iter().enumerate() {
        assert_eq!(f.get_pixel(10, 44).0, [255, 0, 0, 255], "frame {i} is not the CPU's");
    }
    assert!(log.contains("Renderer: Software Rendering (measured on the first frames: GPU "), "{log}");
    // The queue item's next output module follows the first one's choice without measuring.
    let shared = Mutex::new(None);
    let opts = || JobOptions { renderer: Some(&shared), ..Default::default() };
    let slow = TimedAccel::new(60, true);
    run_pooled(&p, cid, &s, "/r/b_[#####].png", opts(), &slow);
    assert_eq!(*shared.lock().unwrap(), Some(effectcraft_render::Backend::Cpu));
    let again = TimedAccel::new(0, true);
    let (frames, log) = run_pooled(&p, cid, &s, "/r/c_[#####].png", opts(), &again);
    assert_eq!(again.frames.load(Ordering::SeqCst), 0);
    assert!(frames.iter().all(|f| f.get_pixel(10, 44).0 == [255, 0, 0, 255]));
    assert!(log.contains("Renderer: Software Rendering (as the queue item's first output module)"), "{log}");
}

#[test]
fn a_gpu_job_that_measures_no_faster_on_the_cpu_stays_on_the_gpu() {
    if measurement_overridden() {
        return;
    }
    // A slow CPU (a large comp of eight rotating, translucent full-frame layers, composited
    // anew every frame) against a GPU that only fills the frame: every frame is the GPU's.
    let (mut p, cid) = project(FrameRate::new(25, 1), |p, comp| {
        comp.width = 1920;
        comp.height = 1080;
        let big = p.add_item("Big", Label::Red, None, ItemKind::Solid(Solid { color: [0.2, 0.4, 0.6], width: 1920, height: 1080, pixel_aspect: 1.0 }));
        for k in 0..8 {
            let mut l = build::layer(p, comp, "Big", LayerSource::Solid { item: big }, (1920, 1080), None);
            l.props.prop_mut("transform/rotation").unwrap().keys =
                vec![Keyframe::new(Tick::ZERO, Value::Scalar(k as f64)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(90.0 + k as f64))];
            l.props.prop_mut("transform/opacity").unwrap().value = Value::Scalar(50.0);
            comp.layers.insert(0, l);
        }
    });
    p.settings.gpu_acceleration = true;
    let s = custom(0.0, 0.6);
    let fast = TimedAccel::new(0, true);
    let (frames, log) = run_pooled(&p, cid, &s, "/r/d_[#####].png", JobOptions::default(), &fast);
    assert_eq!(frames.len(), 15);
    assert_eq!(fast.frames.load(Ordering::SeqCst), 15, "every kept frame, warm-up and measured ones included, is the GPU's");
    assert!(frames.iter().all(|f| f.pixels().all(|px| px.0 == [0, 255, 0, 255])));
    assert!(log.contains("Renderer: GPU Acceleration (measured on the first frames: GPU "), "{log}");
}

#[test]
fn gpu_cpu_and_measured_jobs_write_the_same_frames() {
    // #3335: where the two compositors agree, a job is the same whichever renders it: the GPU
    // (forced), the CPU (Software Only) or the measured choice.
    if measurement_overridden() {
        return;
    }
    let (mut p, cid) = project(FrameRate::new(25, 1), |_, _| {});
    let s = custom(0.0, 0.8);
    let echo = TimedAccel::new(5, false);
    p.settings.gpu_acceleration = false;
    let (cpu, log) = run_pooled(&p, cid, &s, "/i/a_[#####].png", JobOptions::default(), &echo);
    assert!(log.contains("Renderer: Software Rendering (the project's renderer)"), "{log}");
    p.settings.gpu_acceleration = true;
    let gpu_slot = Mutex::new(Some(effectcraft_render::Backend::Gpu));
    let (gpu, _) = run_pooled(&p, cid, &s, "/i/b_[#####].png", JobOptions { renderer: Some(&gpu_slot), ..Default::default() }, &echo);
    let (auto, _) = run_pooled(&p, cid, &s, "/i/c_[#####].png", JobOptions::default(), &echo);
    assert_eq!(cpu.len(), 20);
    assert_eq!(cpu, gpu);
    assert_eq!(cpu, auto);
}

#[test]
fn renderer_choice_follows_the_measurement() {
    use effectcraft_export::{JobRenderer, pick_renderer};
    assert_eq!(pick_renderer(Some(117.0), Some(68.0)), JobRenderer::Cpu);
    assert_eq!(pick_renderer(Some(68.0), Some(117.0)), JobRenderer::Gpu);
    // Ties and noise stay on the GPU: the CPU must be clearly faster.
    assert_eq!(pick_renderer(Some(100.0), Some(90.0)), JobRenderer::Gpu);
    assert_eq!(pick_renderer(Some(100.0), Some(80.0)), JobRenderer::Cpu);
    // Unmeasured or nonsense: the GPU, unless the GPU stopped while measuring.
    assert_eq!(pick_renderer(None, None), JobRenderer::Gpu);
    assert_eq!(pick_renderer(Some(f64::NAN), Some(1.0)), JobRenderer::Gpu);
    assert_eq!(pick_renderer(None, Some(50.0)), JobRenderer::Cpu);
}