208 lines
9.7 KiB
Rust
208 lines
9.7 KiB
Rust
//! Render Queue commands against mock exporters (real encoding is tested in `effectcraft-export`
|
|
//! and end to end in `effectcraft-host`).
|
|
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use effectcraft_project::render_queue::{OutputFormat, RenderQuality, RenderStatus};
|
|
use serde_json::json;
|
|
|
|
use crate::render_queue::CANCELLED;
|
|
use crate::{Event, ExportJob, ExportResult, Exporter, Session};
|
|
|
|
fn demo() -> Session {
|
|
let mut s = Session::default();
|
|
s.execute("file.openDemoProject", json!({})).unwrap();
|
|
s
|
|
}
|
|
|
|
/// Records exports; fails items whose path contains "fail"; honours cancellation.
|
|
pub(crate) struct MockExporter {
|
|
pub(crate) log: Mutex<Vec<String>>,
|
|
}
|
|
|
|
impl Exporter for MockExporter {
|
|
fn formats(&self) -> Vec<OutputFormat> {
|
|
OutputFormat::ALL.to_vec()
|
|
}
|
|
fn export(&self, job: &ExportJob, progress: &mut dyn FnMut(u64, u64) -> bool) -> Result<ExportResult, String> {
|
|
self.log.lock().unwrap().push(job.path.to_string());
|
|
if job.path.contains("fail") {
|
|
return Err("boom".into());
|
|
}
|
|
let comp = job.project.comp(job.item.comp).ok_or("no comp")?;
|
|
let n = job.item.settings.frame_count(comp);
|
|
for k in 0..=n {
|
|
if !progress(k, n) {
|
|
return Err(CANCELLED.into());
|
|
}
|
|
}
|
|
Ok(ExportResult { path: job.path.to_string(), frames: n, ..Default::default() })
|
|
}
|
|
}
|
|
|
|
fn rq_session() -> (Session, Arc<MockExporter>) {
|
|
let mut s = demo();
|
|
let ex = Arc::new(MockExporter { log: Default::default() });
|
|
s.exporter = Some(ex.clone());
|
|
(s, ex)
|
|
}
|
|
|
|
#[test]
|
|
fn add_configure_render() {
|
|
let (mut s, ex) = rq_session();
|
|
assert!(s.is_enabled("renderQueue.add"));
|
|
assert!(!s.is_enabled("renderQueue.render"));
|
|
let a = s.execute("renderQueue.add", json!({})).unwrap();
|
|
let name = s.project.item(s.active_comp_id().unwrap()).unwrap().name.clone();
|
|
assert_eq!(a["index"], 1);
|
|
assert_eq!(a["statusLabel"], "Queued");
|
|
assert!(a["outputPath"].as_str().unwrap().ends_with(&format!("{name}.mp4")), "{a}");
|
|
let id = a["item"].as_u64().unwrap();
|
|
// Render Settings / Output Module / Output To.
|
|
let r = s
|
|
.execute("renderQueue.setRenderSettings", json!({"item": id, "resolution": "half", "timeSpan": "custom", "start": 1.0, "end": 2.0, "frameRate": 10}))
|
|
.unwrap();
|
|
assert_eq!(r["frames"], 10);
|
|
assert_eq!(r["width"], 960);
|
|
let r = s.execute("renderQueue.setOutputModule", json!({"item": id, "format": "png", "channels": "rgba"})).unwrap();
|
|
assert!(r["outputPath"].as_str().unwrap().ends_with("_[#####].png"), "{r}");
|
|
assert!(s.execute("renderQueue.setOutputModule", json!({"item": id, "format": "jpeg", "channels": "rgba"})).is_err());
|
|
let r = s.execute("renderQueue.setOutput", json!({"item": id, "path": "/tmp/rq/out.mov"})).unwrap();
|
|
assert_eq!(r["output"]["format"], "ProRes", "Output To with .mov switches to ProRes");
|
|
assert_eq!(std::path::Path::new(r["outputPath"].as_str().unwrap()), std::path::absolute("/tmp/rq/out.mov").unwrap());
|
|
// A second item that fails, a third that is unqueued.
|
|
let b = s.execute("renderQueue.add", json!({"format": "gif", "output": "/tmp/rq/fail.gif"})).unwrap();
|
|
let c = s.execute("renderQueue.add", json!({"output": "/tmp/rq/skip.mp4"})).unwrap();
|
|
s.execute("renderQueue.setRender", json!({"item": c["item"], "render": false})).unwrap();
|
|
assert_eq!(s.project.render_queue[2].status.label(), "Unqueued");
|
|
let r = s.execute("renderQueue.render", json!({})).unwrap();
|
|
assert_eq!(r["items"].as_array().unwrap().len(), 2);
|
|
assert_eq!(
|
|
ex.log.lock().unwrap().iter().map(std::path::PathBuf::from).collect::<Vec<_>>(),
|
|
[std::path::absolute("/tmp/rq/out.mov").unwrap(), std::path::absolute("/tmp/rq/fail.gif").unwrap()]
|
|
);
|
|
let q = &s.project.render_queue;
|
|
assert_eq!(q[0].status.label(), "Done");
|
|
assert!(q[0].started.is_some() && q[0].render_time.is_some());
|
|
assert_eq!(std::path::Path::new(q[0].last_output.as_deref().unwrap()), std::path::absolute("/tmp/rq/out.mov").unwrap());
|
|
assert_eq!(q[1].status, RenderStatus::Failed("boom".into()));
|
|
assert_eq!(q[2].status.label(), "Unqueued");
|
|
assert!(s.drain_events().iter().any(|e| matches!(e, Event::Toast { error: true, .. })));
|
|
// Reorder, duplicate, remove, undo.
|
|
s.execute("renderQueue.move", json!({"item": b["item"], "to": 1})).unwrap();
|
|
assert_eq!(s.project.render_queue[0].id, b["item"].as_u64().unwrap());
|
|
let d = s.execute("renderQueue.duplicate", json!({"index": 2})).unwrap();
|
|
assert_eq!(s.project.render_queue.len(), 4);
|
|
assert_eq!(s.project.render_queue[2].id, d["item"].as_u64().unwrap());
|
|
assert_eq!(s.project.render_queue[2].status.label(), "Queued");
|
|
s.execute("renderQueue.remove", json!({"index": 3})).unwrap();
|
|
assert_eq!(s.project.render_queue.len(), 3);
|
|
s.undo();
|
|
assert_eq!(s.project.render_queue.len(), 4);
|
|
}
|
|
|
|
#[test]
|
|
fn persists_in_project_file() {
|
|
let (mut s, _) = rq_session();
|
|
s.execute("renderQueue.add", json!({"format": "tiff", "output": "[compName]/[compName]_[####].tif", "quality": "draft"})).unwrap();
|
|
let json = s.project.to_json();
|
|
let p = effectcraft_project::Project::from_json(&json).unwrap();
|
|
assert_eq!(p.render_queue, s.project.render_queue);
|
|
assert_eq!(p.render_queue[0].settings.quality, RenderQuality::Draft);
|
|
// Projects without a queue still load.
|
|
let old = json.replace("\"render_queue\"", "\"_ignored\"");
|
|
assert!(effectcraft_project::Project::from_json(&old).unwrap().render_queue.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn background_render_and_stop() {
|
|
struct Slow;
|
|
impl Exporter for Slow {
|
|
fn formats(&self) -> Vec<OutputFormat> {
|
|
OutputFormat::ALL.to_vec()
|
|
}
|
|
fn export(&self, _: &ExportJob, progress: &mut dyn FnMut(u64, u64) -> bool) -> Result<ExportResult, String> {
|
|
for k in 0..10_000 {
|
|
std::thread::sleep(std::time::Duration::from_millis(2));
|
|
if !progress(k, 10_000) {
|
|
return Err(CANCELLED.into());
|
|
}
|
|
}
|
|
Ok(Default::default())
|
|
}
|
|
}
|
|
let mut s = demo();
|
|
s.exporter = Some(Arc::new(Slow));
|
|
s.execute("renderQueue.add", json!({"output": "/tmp/a.mp4"})).unwrap();
|
|
s.execute("renderQueue.add", json!({"output": "/tmp/b.mp4"})).unwrap();
|
|
s.execute("renderQueue.render", json!({"wait": false})).unwrap();
|
|
assert!(s.is_rendering());
|
|
assert!(!s.is_enabled("renderQueue.add"), "queue is locked while rendering");
|
|
let t0 = std::time::Instant::now();
|
|
while s.render_progress().is_some_and(|p| p.done < 3) {
|
|
assert!(t0.elapsed().as_secs() < 20);
|
|
std::thread::sleep(std::time::Duration::from_millis(5));
|
|
}
|
|
s.poll_render();
|
|
assert_eq!(s.project.render_queue[0].status.label(), "Rendering");
|
|
s.execute("renderQueue.stop", json!({})).unwrap();
|
|
while s.is_rendering() {
|
|
assert!(t0.elapsed().as_secs() < 20);
|
|
std::thread::sleep(std::time::Duration::from_millis(5));
|
|
}
|
|
s.poll_render();
|
|
assert!(s.render_job.is_none());
|
|
assert_eq!(s.project.render_queue[0].status.label(), "User Stopped");
|
|
assert_eq!(s.project.render_queue[1].status.label(), "User Stopped");
|
|
}
|
|
|
|
#[test]
|
|
fn without_exporter() {
|
|
let mut s = demo();
|
|
s.execute("renderQueue.add", json!({})).unwrap();
|
|
assert!(!s.is_enabled("renderQueue.render"));
|
|
let f = s.execute("renderQueue.formats", json!({})).unwrap();
|
|
assert_eq!(f["formats"].as_array().unwrap().len(), 12);
|
|
assert_eq!(f["formats"][0]["available"], false);
|
|
}
|
|
|
|
#[test]
|
|
fn queue_add_accepts_render_settings_templates_without_output_module_namesakes() {
|
|
let mut s = Session::default();
|
|
s.execute("comp.new", json!({"name":"C","width":64,"height":64,"duration":1})).unwrap();
|
|
let all = s.execute("renderQueue.templates", json!({})).unwrap();
|
|
let names = all["renderSettings"].as_array().unwrap();
|
|
assert!(!names.is_empty());
|
|
for row in names {
|
|
let name = row["name"].as_str().unwrap();
|
|
let expected = s.project.render_templates.render_settings(name).unwrap();
|
|
s.execute("renderQueue.add", json!({"comp":"C","template":name})).unwrap();
|
|
assert_eq!(s.project.render_queue.last().unwrap().settings, expected);
|
|
}
|
|
let count = s.project.render_queue.len();
|
|
assert!(s.execute("renderQueue.add", json!({"comp":"C","template":"Unknown Settings"})).is_err());
|
|
assert_eq!(s.project.render_queue.len(), count);
|
|
}
|
|
|
|
#[test]
|
|
fn locked_resize_uses_height_for_height_only_output_module_updates() {
|
|
for change in [json!({"resizeHeight": 32}), json!({"resize": {"height": 32, "lockAspect": true}})] {
|
|
let mut s = Session::default();
|
|
s.execute("comp.new", json!({"name":"Square","width":64,"height":64,"frameRate":10,"duration":1})).unwrap();
|
|
s.execute("renderQueue.add", json!({})).unwrap();
|
|
s.execute("renderQueue.setOutputModule", json!({"resize": {"width": 64, "lockAspect": true}})).unwrap();
|
|
s.execute("renderQueue.setOutputModule", change).unwrap();
|
|
let item = &s.project.render_queue[0];
|
|
let comp = s.project.comp(item.comp).unwrap();
|
|
assert_eq!(item.output.output_size(comp, &item.settings), (32, 32));
|
|
assert_eq!(item.output.resize.height, 32);
|
|
}
|
|
let mut s = Session::default();
|
|
s.execute("comp.new", json!({"name":"Square","width":64,"height":64,"duration":1})).unwrap();
|
|
s.execute("renderQueue.add", json!({})).unwrap();
|
|
s.execute("renderQueue.setOutputModule", json!({"resize": {"width": 32, "height": 54, "lockAspect": true}})).unwrap();
|
|
let item = &s.project.render_queue[0];
|
|
let comp = s.project.comp(item.comp).unwrap();
|
|
assert_eq!(item.output.output_size(comp, &item.settings), (32, 32), "explicit width retains precedence");
|
|
}
|