//! M6.5 export parity through engine commands: every built-in preset exports the demo sequence //! and ffprobe (an external test oracle only) confirms codec / size / rate / bitrate; the user //! preset library; the export queue (order, cancel, retry, several sequences and ranges); Quick //! Export; ranges and caption sidecars. use std::path::{Path, PathBuf}; use serde_json::{Value, json}; use crate::Session; /// A scratch directory under the workspace `target/`, removed when dropped. struct Scratch(PathBuf); impl Scratch { fn new(name: &str) -> Self { let d = filmcraft_testkit::workspace_root().join("target").join("export-tests").join(format!("engine-{name}-{}", std::process::id())); let _ = std::fs::remove_dir_all(&d); std::fs::create_dir_all(&d).unwrap(); Scratch(d) } fn path(&self, name: &str) -> String { self.0.join(name).to_string_lossy().to_string() } } impl Drop for Scratch { fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.0); } } fn demo() -> Session { let mut s = Session::default(); s.execute("file.openDemoProject", json!({})).unwrap(); s } fn probe(path: &str) -> Option { let ffprobe = filmcraft_testkit::ffprobe_or_skip("export presets")?; let out = std::process::Command::new(ffprobe).args(["-v", "error", "-of", "json", "-show_format", "-show_streams", path]).output().unwrap(); assert!(out.status.success(), "{path}: {}", String::from_utf8_lossy(&out.stderr)); Some(serde_json::from_slice(&out.stdout).unwrap()) } fn stream<'a>(j: &'a Value, kind: &str) -> Option<&'a Value> { j["streams"].as_array().unwrap().iter().find(|s| s["codec_type"] == kind) } fn num(v: &Value) -> f64 { v.as_str().and_then(|s| s.parse().ok()).or_else(|| v.as_f64()).unwrap_or(f64::NAN) } fn files_in(dir: &Path) -> Vec { let mut v: Vec = std::fs::read_dir(dir).unwrap().flatten().map(|e| e.file_name().to_string_lossy().to_string()).collect(); v.sort(); v } /// Every built-in preset: a quarter second of the demo sequence (seven frames at 23.976) exported /// with `file.exportMedia {preset}`; ffprobe checks container, codec, profile, frame size, frame /// rate and audio format, and the data rate where the codec fixes it. #[test] fn every_builtin_preset_exports_and_ffprobe_confirms() { let mut s = demo(); let presets = s.execute("export.presets.list", json!({})).unwrap()["presets"].as_array().unwrap().clone(); assert!(presets.len() >= 24); let dir = Scratch::new("presets"); for pr in &presets { let name = pr["name"].as_str().unwrap(); let sub = dir.0.join(format!("p{}", filmcraft_export::presets::preset_key(name))); std::fs::create_dir_all(&sub).unwrap(); let path = sub.join("Demo").to_string_lossy().to_string(); let params = json!({"preset": name, "path": path, "range": "custom", "startSeconds": 1.0, "endSeconds": 1.25, "wait": true}); let frames = s.execute("export.resolve", params.clone()).unwrap()["frames"].as_u64().unwrap(); let r = s.execute("file.exportMedia", params).unwrap_or_else(|e| panic!("{name}: {e}")); let out = r["path"].as_str().unwrap().to_string(); let settings = s.execute("export.presets.get", json!({"name": name})).unwrap()["settings"].clone(); let fmt = settings["format"].as_str().unwrap().to_string(); let (w, h) = match settings["frameSize"].as_array() { Some(a) => (a[0].as_u64().unwrap(), a[1].as_u64().unwrap()), None => (1920, 1080), }; if matches!(fmt.as_str(), "png" | "tiff" | "bmp") { let files = files_in(&sub); let ext = Path::new(&out).extension().unwrap().to_string_lossy().to_string(); assert_eq!(frames, 7, "frames 23..=29 at 23.976 fps"); let want: Vec = (0..frames).map(|i| format!("Demo{i:03}.{ext}")).collect(); assert_eq!(files, want, "{name}"); if let Some(j) = probe(&sub.join(&want[0]).to_string_lossy()) { let v = stream(&j, "video").unwrap(); let codec = match fmt.as_str() { "png" => "png", "tiff" => "tiff", _ => "bmp", }; assert_eq!(v["codec_name"], codec, "{name}"); assert_eq!((v["width"].as_u64().unwrap(), v["height"].as_u64().unwrap()), (w, h), "{name}"); } continue; } assert!(Path::new(&out).exists(), "{name}: {out}"); let Some(j) = probe(&out) else { continue }; let fmt_name = j["format"]["format_name"].as_str().unwrap(); match fmt.as_str() { "wav" | "aiff" => { let a = stream(&j, "audio").unwrap(); let bits = settings["audio"]["bits"].as_u64().unwrap(); let codec = match (fmt.as_str(), bits) { ("wav", 24) => "pcm_s24le", ("wav", _) => "pcm_s16le", (_, 24) => "pcm_s24be", _ => "pcm_s16be", }; assert_eq!(a["codec_name"], codec, "{name}"); assert_eq!(a["sample_rate"], "48000", "{name}"); assert_eq!(a["channels"], 2, "{name}"); assert!((num(&j["format"]["duration"]) - 0.25).abs() < 0.01, "{name}: {}", j["format"]["duration"]); continue; } "gif" => { let v = stream(&j, "video").unwrap(); assert_eq!(v["codec_name"], "gif"); assert_eq!((v["width"].as_u64().unwrap(), v["height"].as_u64().unwrap()), (640, 360)); continue; } "mxf-opatom" => { // Avid style: picture only in Demo.mxf, one mono PCM file per channel assert_eq!(fmt_name, "mxf", "{name}"); assert_eq!(j["streams"].as_array().unwrap().len(), 1, "{name}"); assert_eq!(stream(&j, "video").unwrap()["codec_name"], "dnxhd", "{name}"); for k in 1..=2 { let a = probe(&format!("{}_A{k}.mxf", out.trim_end_matches(".mxf"))).unwrap(); let a = stream(&a, "audio").unwrap(); assert_eq!((a["codec_name"].as_str(), a["channels"].as_u64()), (Some("pcm_s24le"), Some(1)), "{name} A{k}"); } continue; } _ => {} } let v = stream(&j, "video").unwrap_or_else(|| panic!("{name}: no video")); assert_eq!((v["width"].as_u64().unwrap(), v["height"].as_u64().unwrap()), (w, h), "{name}"); assert_eq!(v["r_frame_rate"], "24000/1001", "{name}"); let a = stream(&j, "audio").unwrap_or_else(|| panic!("{name}: no audio")); assert_eq!(a["sample_rate"], "48000", "{name}"); assert_eq!(a["channels"], 2, "{name}"); let vbr = num(&v["bit_rate"]) / 1e6; let px = (w * h) as f64 / (1920.0 * 1080.0) * (24000.0 / 1001.0) / 29.97; match fmt.as_str() { "h264" => { assert!(fmt_name.contains("mp4"), "{name}: {fmt_name}"); assert_eq!(v["codec_name"], "h264", "{name}"); assert_eq!(v["profile"], "High", "{name}"); assert_eq!(a["codec_name"], "aac", "{name}"); assert!((num(&a["bit_rate"]) / 1000.0 - 320.0).abs() < 80.0, "{name}: AAC {}", a["bit_rate"]); } "prores" => { assert!(fmt_name.contains("mov"), "{name}: {fmt_name}"); assert_eq!(v["codec_name"], "prores", "{name}"); let (profile, mbps) = match settings["proresProfile"].as_str().unwrap() { "proxy" => ("Proxy", 45.0), "lt" => ("LT", 102.0), "standard" => ("Standard", 147.0), _ => ("HQ", 220.0), }; assert_eq!(v["profile"], profile, "{name}"); assert!(vbr <= mbps * px * 1.5, "{name}: {vbr:.1} Mb/s vs nominal {:.1}", mbps * px); assert_eq!(a["codec_name"], "pcm_s24le", "{name}"); } "dnxhr" => { assert_eq!(v["codec_name"], "dnxhd", "{name}"); let p = settings["dnxProfile"].as_str().unwrap().to_ascii_uppercase(); assert_eq!(v["profile"], format!("DNXHR {p}"), "{name}"); let mbps = match p.as_str() { "LB" => 45.0, "SQ" => 145.0, _ => 220.0, }; assert!((vbr / (mbps * px) - 1.0).abs() < 0.25, "{name}: {vbr:.1} Mb/s vs nominal {:.1}", mbps * px); assert_eq!(a["codec_name"], "pcm_s24le", "{name}"); } "mxf-op1a" => { assert_eq!(fmt_name, "mxf", "{name}"); let codec = match settings["mxfVideoCodec"].as_str().unwrap() { "proRes" => "prores", "h264" => "h264", _ => "dnxhd", }; assert_eq!(v["codec_name"], codec, "{name}"); assert_eq!(a["codec_name"], "pcm_s24le", "{name}"); } other => panic!("{name}: unexpected format {other}"), } } } /// H.264 bitrate control over three seconds of the demo: the adaptive Match Source preset /// targets width × height × fps × bpp, the 1080p delivery presets their fixed targets; ffprobe's /// measured video bitrate stays within the VBR maximum and close to the target. #[test] fn h264_presets_hit_their_bitrates() { let mut s = demo(); let dir = Scratch::new("bitrate"); for (preset, target_kbps, max_kbps) in [ ("Match Source – Adaptive High Bitrate", 1920.0 * 1080.0 * (24000.0 / 1001.0) * 0.2 / 1000.0, 1.5), ("YouTube 1080p Full HD", 16_000.0, 20.0 / 16.0), ("Vimeo 1080p Full HD", 18_000.0, 24.0 / 18.0), ] { let path = dir.path(&format!("{}.mp4", filmcraft_export::presets::preset_key(preset))); s.execute( "file.exportMedia", json!({"preset": preset, "path": path, "range": "custom", "startSeconds": 0.0, "endSeconds": 3.0, "audio": false, "wait": true}), ) .unwrap(); let Some(j) = probe(&path) else { return }; let v = stream(&j, "video").unwrap(); let kbps = num(&v["bit_rate"]) / 1000.0; eprintln!("{preset}: {kbps:.0} kbps (target {target_kbps:.0})"); assert!(kbps <= target_kbps * max_kbps * 1.1, "{preset}: {kbps:.0} kbps over the maximum"); assert!(kbps >= target_kbps * 0.5, "{preset}: {kbps:.0} kbps far under the target {target_kbps:.0}"); } } #[test] fn user_presets_persist_with_favourites_import_and_export() { let dir = Scratch::new("library"); let mut s = demo(); s.export_presets.set_dir(&dir.0); // a custom preset from a built-in plus overrides s.execute( "export.presets.save", json!({"name": "Review 720p", "from": "YouTube 1080p Full HD", "width": 1280, "height": 720, "bitrateKbps": 5000, "description": "client review"}), ) .unwrap(); let got = s.execute("export.presets.get", json!({"name": "review 720P"})).unwrap(); assert_eq!(got["builtin"], false); assert_eq!(got["settings"]["frameSize"], json!([1280, 720])); assert_eq!(got["settings"]["bitrateKbps"], 5000); assert!(s.execute("export.presets.save", json!({"name": "YouTube 1080p Full HD"})).is_err(), "built-in names are reserved"); assert!(s.execute("export.presets.delete", json!({"name": "Apple ProRes 422 HQ"})).is_err(), "built-ins cannot be deleted"); // favourites s.execute("export.presets.favorite", json!({"name": "Apple ProRes 422 HQ"})).unwrap(); s.execute("export.presets.favorite", json!({"name": "Review 720p", "favorite": true})).unwrap(); let favs = s.execute("export.presets.list", json!({"favorites": true})).unwrap()["presets"].as_array().unwrap().len(); assert_eq!(favs, 2); let hits = s.execute("export.presets.list", json!({"query": "prores"})).unwrap()["presets"].as_array().unwrap().len(); assert_eq!(hits, 5, "four QuickTime ProRes presets and MXF OP1a ProRes 422 HQ"); // persisted: a fresh session with the same data directory sees both let mut s2 = demo(); s2.export_presets.set_dir(&dir.0); assert!(s2.export_presets.find("Review 720p").is_some()); assert!(s2.export_presets.is_favorite("Apple ProRes 422 HQ")); // export → delete → import let file = dir.path("mine.json"); s2.execute("export.presets.export", json!({"path": file, "names": ["Review 720p"]})).unwrap(); s2.execute("export.presets.delete", json!({"name": "Review 720p"})).unwrap(); assert!(s2.export_presets.find("Review 720p").is_none()); let imp = s2.execute("export.presets.import", json!({"path": file})).unwrap(); assert_eq!(imp["imported"], json!(["Review 720p"])); // and it exports let out = dir.path("review.mp4"); s2.execute("file.exportMedia", json!({"preset": "Review 720p", "path": out, "range": "custom", "startSeconds": 0, "endSeconds": 0.25, "wait": true})) .unwrap(); if let Some(j) = probe(&out) { assert_eq!(stream(&j, "video").unwrap()["width"], 1280); } assert!(s2.execute("export.presets.import", json!({"path": dir.path("missing.json")})).is_err()); } fn queue(s: &mut Session) -> Vec { s.execute("export.queue.list", json!({})).unwrap()["items"].as_array().unwrap().clone() } #[test] fn queue_orders_cancels_and_retries() { let mut s = demo(); let dir = Scratch::new("queue"); let add = |s: &mut Session, name: &str, preset: &str| -> u64 { let r = s.execute("export.queue.add", json!({"preset": preset, "path": dir.path(name), "range": "custom", "startSeconds": 0, "endSeconds": 0.25})).unwrap(); r["added"][0].as_u64().unwrap() }; let a = add(&mut s, "a.mp4", "Match Source – Adaptive Low Bitrate"); let b = add(&mut s, "b.mov", "Apple ProRes 422 Proxy"); let c = add(&mut s, "c.wav", "Waveform Audio 48 kHz 16-bit"); let d = add(&mut s, "d.mp4", "Match Source – Adaptive Low Bitrate"); assert!(queue(&mut s).iter().all(|i| i["status"] == "ready")); // reorder: c to the front, a one down s.execute("export.queue.move", json!({"id": c, "to": 0})).unwrap(); s.execute("export.queue.move", json!({"id": a, "by": 1})).unwrap(); let order: Vec = queue(&mut s).iter().map(|i| i["id"].as_u64().unwrap()).collect(); assert_eq!(order, [c, b, a, d]); // cancel one before it starts, then run the queue to completion s.execute("export.queue.cancel", json!({"id": d})).unwrap(); s.execute("export.queue.start", json!({"wait": true})).unwrap(); let items = queue(&mut s); let status = |id: u64| items.iter().find(|i| i["id"] == id).unwrap()["status"].clone(); assert_eq!([status(c), status(b), status(a), status(d)], [json!("done"), json!("done"), json!("done"), json!("cancelled")]); // jobs ran in queue order let job = |id: u64| items.iter().find(|i| i["id"] == id).unwrap()["job"].as_u64().unwrap(); assert!(job(c) < job(b) && job(b) < job(a)); for f in ["a.mp4", "b.mov", "c.wav"] { assert!(Path::new(&dir.path(f)).exists(), "{f}"); } assert!(!Path::new(&dir.path("d.mp4")).exists()); // retry the cancelled one s.execute("export.queue.retry", json!({"id": d, "start": true, "wait": true})).unwrap(); assert_eq!(queue(&mut s).iter().find(|i| i["id"] == d).unwrap()["status"], "done"); assert!(Path::new(&dir.path("d.mp4")).exists()); assert!(s.execute("export.queue.retry", json!({"id": 999})).is_err()); // clear finished s.execute("export.queue.clear", json!({})).unwrap(); assert!(queue(&mut s).is_empty()); } #[test] fn queue_cancels_a_running_export_and_retries_a_failed_one() { let mut s = demo(); let dir = Scratch::new("queue-cancel"); // a long encode, cancelled while it runs let long = s.execute("export.queue.add", json!({"preset": "Apple ProRes 422 HQ", "path": dir.path("long.mov"), "range": "entire", "start": true})).unwrap() ["added"][0] .as_u64() .unwrap(); assert_eq!(queue(&mut s)[0]["status"], "encoding"); s.execute("export.queue.cancel", json!({"id": long, "wait": true})).unwrap(); assert_eq!(queue(&mut s)[0]["status"], "cancelled"); // a failure (the output directory cannot be created: a file is in the way) and a retry std::fs::write(dir.path("blocker"), b"x").unwrap(); let bad = s .execute( "export.queue.add", json!({"preset": "Waveform Audio 48 kHz 16-bit", "path": dir.path("blocker/x.wav"), "range": "custom", "startSeconds": 0, "endSeconds": 0.1}), ) .unwrap()["added"][0] .as_u64() .unwrap(); s.execute("export.queue.start", json!({"wait": true})).unwrap(); let it = queue(&mut s).into_iter().find(|i| i["id"] == bad).unwrap(); assert_eq!(it["status"], "failed"); assert!(it["error"].as_str().unwrap().contains("I/O"), "{it}"); s.execute("export.queue.retry", json!({"id": bad})).unwrap(); assert_eq!(queue(&mut s).into_iter().find(|i| i["id"] == bad).unwrap()["status"], "ready"); s.execute("export.queue.remove", json!({"id": bad})).unwrap(); assert!(queue(&mut s).iter().all(|i| i["id"] != bad)); } #[test] fn queue_exports_several_sequences_and_ranges() { let mut s = demo(); let dir = Scratch::new("queue-many"); let first = s.state.active_sequence.unwrap(); let second = s.execute("file.newSequence", json!({"name": "Second Cut", "width": 640, "height": 360, "fps": 25})).unwrap()["sequence"].as_u64().unwrap(); let r = s .execute( "export.queue.add", json!({"preset": "Waveform Audio 48 kHz 16-bit", "path": format!("{}/", dir.0.display()), "sequences": [first.0, second], "range": "custom", "startSeconds": 0, "endSeconds": 0.5}), ) .unwrap(); assert_eq!(r["added"].as_array().unwrap().len(), 2); let r = s .execute( "export.queue.add", json!({"preset": "Waveform Audio 48 kHz 16-bit", "sequence": first.0, "path": dir.path("parts.wav"), "ranges": [{"startSeconds": 0, "endSeconds": 0.5}, {"startSeconds": 1, "endSeconds": 1.25}]}), ) .unwrap(); assert_eq!(r["added"].as_array().unwrap().len(), 2); s.execute("export.queue.start", json!({"wait": true})).unwrap(); assert!(queue(&mut s).iter().all(|i| i["status"] == "done"), "{:?}", queue(&mut s)); let names = files_in(&dir.0); let first_name = s.project.item(first).unwrap().name.clone(); assert!(names.contains(&format!("{first_name}.wav")), "{names:?}"); assert!(names.contains(&"Second Cut.wav".to_string()), "{names:?}"); assert!(names.contains(&"parts.wav".to_string()) && names.contains(&"parts_2.wav".to_string()), "{names:?}"); let len = |f: &str| std::fs::metadata(dir.0.join(f)).unwrap().len(); assert_eq!(len("parts_2.wav"), 44 + 12_000 * 4, "0.25 s of 16-bit stereo"); } #[test] fn quick_export_uses_and_remembers_a_preset() { let mut s = demo(); let dir = Scratch::new("quick"); let r = s.execute("export.quick", json!({"path": dir.path("quick"), "range": "custom", "startSeconds": 0, "endSeconds": 0.25, "wait": true})).unwrap(); assert_eq!(r["preset"], filmcraft_export::presets::DEFAULT_PRESET); assert_eq!(r["path"], dir.path("quick.mp4")); assert!(Path::new(&dir.path("quick.mp4")).exists()); s.execute( "export.quick", json!({"preset": "Apple ProRes 422 LT", "path": dir.path("q2"), "range": "custom", "startSeconds": 0, "endSeconds": 0.1, "wait": true}), ) .unwrap(); let r = s.execute("export.quick", json!({"path": dir.path("q3"), "range": "custom", "startSeconds": 0, "endSeconds": 0.1, "wait": true})).unwrap(); assert_eq!(r["preset"], "Apple ProRes 422 LT", "the last preset is remembered"); assert!(Path::new(&dir.path("q3.mov")).exists()); } #[test] fn ranges_resolve_and_sidecar_captions_are_written() { let mut s = demo(); let dir = Scratch::new("ranges"); let fps = 24000.0 / 1001.0; let frames = |s: &mut Session, p: Value| s.execute("export.resolve", p).unwrap()["frames"].as_i64().unwrap(); let whole = frames(&mut s, json!({"preset": "PNG Sequence", "range": "entire"})); let dur = s.active_sequence().unwrap().duration(); assert_eq!(whole, (dur.seconds() * fps).ceil() as i64); s.execute("markers.markIn", json!({"seconds": 1.0})).unwrap(); s.execute("markers.markOut", json!({"seconds": 2.0})).unwrap(); let io = frames(&mut s, json!({"preset": "PNG Sequence", "range": "inOut"})); assert!((24..=26).contains(&io), "{io}"); assert_eq!(frames(&mut s, json!({"preset": "PNG Sequence"})), io, "In/Out is the default"); assert!(s.execute("export.resolve", json!({"range": "workArea"})).is_err(), "no work area"); assert_eq!(frames(&mut s, json!({"preset": "Animated GIF 640×360", "range": "custom", "startSeconds": 0, "endSeconds": 2})), 30, "15 fps"); let bare = frames(&mut s, json!({"preset": "Animated GIF 640×360", "startSeconds": 0, "endSeconds": 2})); assert_eq!(bare, 30, "start/end times without `range` are a custom range, not the In/Out or whole sequence"); assert!(s.execute("export.resolve", json!({"startSeconds": 1})).is_err(), "a start without an end is an error"); let res = s.execute("export.resolve", json!({"preset": "YouTube 2160p 4K Ultra HD"})).unwrap(); assert_eq!(res["output"]["width"], 3840); assert!(res["summary"]["video"].as_str().unwrap().contains("3840x2160")); assert!(res["summary"]["estimated_bytes"].as_u64().unwrap() > 1_000_000); // caption sidecar next to the output s.execute("captions.add", json!({"seconds": 1.5, "durationSeconds": 1.0, "text": "Hello sidecar"})).unwrap(); let out = dir.path("cap.wav"); s.execute("file.exportMedia", json!({"preset": "Waveform Audio 48 kHz 16-bit", "path": out, "captionSidecar": "srt", "wait": true})).unwrap(); let srt = std::fs::read_to_string(dir.path("cap.srt")).unwrap(); // timed from the start of the export range (In at 1 s; the caption starts on frame 35) assert!(srt.contains("Hello sidecar") && srt.contains("00:00:00,460 --> 00:00:01,461"), "{srt}"); s.execute("file.exportMedia", json!({"preset": "Waveform Audio 48 kHz 16-bit", "path": out, "captionSidecar": "vtt", "wait": true})).unwrap(); assert!(std::fs::read_to_string(dir.path("cap.vtt")).unwrap().starts_with("WEBVTT")); // a bad preset name is a clean error assert!(s.execute("file.exportMedia", json!({"preset": "Nope", "path": out})).is_err()); } /// Export mode asks for a default folder as soon as it opens. With no saved project and no /// HOME (the web build) this used to reach `std::env::temp_dir()`, which panics on wasm32 and /// killed the web app whenever the Export tab was clicked. #[test] fn default_export_dir_never_needs_a_real_filesystem() { let s = Session::default(); let d = crate::export_tools::default_export_dir(&s); assert!(!d.as_os_str().is_empty()); // the shared temp-dir helper is what every former `std::env::temp_dir()` call goes through assert!(!crate::temp_dir().as_os_str().is_empty()); // a saved project exports next to itself let s = Session { path: Some("/projects/show/edit.fcproj".into()), ..Default::default() }; assert_eq!(crate::export_tools::default_export_dir(&s), std::path::PathBuf::from("/projects/show")); }