AI media harness for planning, generating, and editing locally
TypeScript
Free consumed images and abandoned worker results
Bitti7ca029b86a6a
diff --git a/src-tauri/core/src/rendered.rs b/src-tauri/core/src/rendered.rsindex bdcb54c..45d592c 100644--- a/src-tauri/core/src/rendered.rs+++ b/src-tauri/core/src/rendered.rs@@ -53,6 +53,30 @@ pub struct RenderedVideo {}impl RenderedVideo {+ fn summary(&self) -> RenderedSummary {+ RenderedSummary {+ job_id: self.job_id.clone(),+ width: self.width,+ height: self.height,+ frame_count: self.frame_count,+ fps: self.fps,+ audio_channels: self.audio_channels,+ audio_sample_rate: self.audio_sample_rate,+ audio_samples: self.audio.len() as u32,+ }+ }++ fn into_still(self) -> Result<(RenderedSummary, Vec<u8>), String> {+ if self.frame_count != 1 {+ return Err("Expected a single still image.".into());+ }+ let summary = self.summary();+ let pixels = self.frame(0)?.ok_or("The generated image has no pixels.")?;+ // Dropping self releases the native generation before image encoding+ // allocates its own buffers. Errors release the same ownership.+ Ok((summary, pixels))+ }+/// One frame's pixels, converted on demand, or None past the last frame.pub fn frame(&self, index: u32) -> Result<Option<Vec<u8>>, String> {if index >= self.frame_count {@@ -292,6 +316,10 @@ fn from_output(static WAITING: LazyLock<Mutex<VecDeque<RenderedVideo>>> = LazyLock::new(Default::default);+// Tests that exercise the shared capacity must not evict one another's jobs.+#[cfg(test)]+pub(crate) static TEST_LOCK: Mutex<()> = Mutex::new(());+/// Puts a finished render where the webview can fetch it. Returns what had to/// be dropped to make room, so the caller can say so rather than let a render/// disappear quietly.@@ -353,16 +381,21 @@ pub struct RenderedSummary {}pub fn summary(job_id: &str) -> Option<RenderedSummary> {- with(job_id, |video| RenderedSummary {- job_id: video.job_id.clone(),- width: video.width,- height: video.height,- frame_count: video.frame_count,- fps: video.fps,- audio_channels: video.audio_channels,- audio_sample_rate: video.audio_sample_rate,- audio_samples: video.audio.len() as u32,- })+ with(job_id, RenderedVideo::summary)+}++/// Transfers a still's pixels to its finalizer and immediately releases the+/// generation. The caller owns everything needed to encode the image now.+pub fn take_still(job_id: &str) -> Result<(RenderedSummary, Vec<u8>), String> {+ let video = {+ let mut waiting = WAITING+ .lock()+ .map_err(|_| "Finished-render lock failed.".to_string())?;+ let index = waiting.iter().position(|video| video.job_id == job_id)+ .ok_or("The generated image is no longer in memory.")?;+ waiting.remove(index).unwrap()+ };+ video.into_still()}/// Hands the memory back. Called when the webview has written the file, and@@ -380,6 +413,49 @@ pub fn release(job_id: &str) -> bool {#[cfg(test)]mod tests {use super::*;+ use std::sync::{atomic::{AtomicBool, Ordering}, Arc};++ struct TrackedStill {+ dropped: Arc<AtomicBool>,+ fail: bool,+ }++ impl FrameSource for TrackedStill {+ fn frame_rgba(&self, _: u32, _: u32, _: u32) -> Result<Vec<u8>, String> {+ assert!(!self.dropped.load(Ordering::Acquire));+ if self.fail { Err("Frame conversion failed.".into()) } else { Ok(vec![20, 40, 60, 255]) }+ }+ }++ impl Drop for TrackedStill {+ fn drop(&mut self) { self.dropped.store(true, Ordering::Release); }+ }++ #[test]+ fn consuming_a_still_releases_its_source_before_the_encoder_receives_pixels() {+ let _serial = TEST_LOCK.lock().unwrap();+ let dropped = Arc::new(AtomicBool::new(false));+ let mut video = sample("consume-still");+ video.source = Box::new(TrackedStill { dropped: dropped.clone(), fail: false });+ keep(video);+ let (summary, pixels) = take_still("consume-still").unwrap();+ assert!(dropped.load(Ordering::Acquire));+ assert_eq!(summary.frame_count, 1);+ assert_eq!(pixels, vec![20, 40, 60, 255]);+ assert!(!release("consume-still"));+ }++ #[test]+ fn consuming_a_still_releases_its_source_when_conversion_fails() {+ let _serial = TEST_LOCK.lock().unwrap();+ let dropped = Arc::new(AtomicBool::new(false));+ let mut video = sample("failed-still");+ video.source = Box::new(TrackedStill { dropped: dropped.clone(), fail: true });+ keep(video);+ assert_eq!(take_still("failed-still").unwrap_err(), "Frame conversion failed.");+ assert!(dropped.load(Ordering::Acquire));+ assert!(!release("failed-still"));+ }fn planar(frames: usize,@@ -516,6 +592,7 @@ mod tests {#[test]fn a_render_is_held_until_it_is_released() {+ let _serial = TEST_LOCK.lock().unwrap();release("held");assert!(frame("held", 0).unwrap().is_none());keep(sample("held"));@@ -552,6 +629,7 @@ mod tests {#[test]fn a_second_run_of_one_scene_replaces_the_first() {+ let _serial = TEST_LOCK.lock().unwrap();release("same");keep(sample("same"));keep(sample("same"));@@ -561,6 +639,7 @@ mod tests {#[test]fn the_oldest_render_is_dropped_rather_than_the_process_growing_without_limit() {+ let _serial = TEST_LOCK.lock().unwrap();for id in ["cap-1", "cap-2", "cap-3"] {release(id);}diff --git a/src-tauri/core/src/worker/server.rs b/src-tauri/core/src/worker/server.rsindex 862d2ad..f0b30db 100644--- a/src-tauri/core/src/worker/server.rs+++ b/src-tauri/core/src/worker/server.rs@@ -118,10 +118,22 @@ struct JobLog {changed: Condvar,latents: Option<PathBuf>,created: Instant,+ released: AtomicBool,}impl JobLog {fn push(&self, kind: &str, payload: serde_json::Value) {+ // The client can disappear while native generation is finishing.+ // Its result is stored before this callback runs, so a release that+ // raced with that hand-off must also discard the late result.+ if self.released.load(Ordering::Acquire) {+ if kind == "job" && payload["state"] == "framesReady" {+ if let Some(id) = payload["jobId"].as_str() {+ rendered::release(id);+ }+ }+ return;+ }if let Ok(mut events) = self.events.lock() {let seq = events.len() as u64 + 1;events.push(WireEvent { seq, kind: kind.into(), payload });@@ -129,6 +141,11 @@ impl JobLog {self.changed.notify_all();}+ fn release(&self, id: &str) {+ self.released.store(true, Ordering::Release);+ rendered::release(id);+ }+/// Long poll: returns as soon as anything after `after` exists.fn after(&self, after: u64, wait: Duration) -> Vec<WireEvent> {let Ok(events) = self.events.lock() else { return Vec::new() };@@ -648,7 +665,7 @@ impl Worker {None};request.save_latents_path = latents.clone();- let log = Arc::new(JobLog { events: Mutex::default(), changed: Condvar::new(), latents, created: Instant::now() });+ let log = Arc::new(JobLog { events: Mutex::default(), changed: Condvar::new(), latents, created: Instant::now(), released: AtomicBool::new(false) });{let mut jobs = self.jobs.lock().map_err(|_| "Lock failed.")?;if jobs.contains_key(id) {@@ -672,9 +689,12 @@ impl Worker {}fn release_job(&self, id: &str) {- rendered::release(id);- if let Ok(mut jobs) = self.jobs.lock() {- jobs.remove(id);+ self.runtime.cancel(id);+ let log = self.jobs.lock().ok().and_then(|mut jobs| jobs.remove(id));+ if let Some(log) = log {+ log.release(id);+ } else {+ rendered::release(id);}if generated_file_stem(id).is_ok() {let _ = fs::remove_dir_all(self.data.join("jobs").join(id));@@ -713,6 +733,50 @@ fn percent_decode(part: &str) -> Result<String, String> {mod tests {use super::*;+ struct TrackedFrames(Arc<AtomicBool>);++ impl rendered::FrameSource for TrackedFrames {+ fn frame_rgba(&self, _: u32, _: u32, _: u32) -> Result<Vec<u8>, String> {+ Ok(vec![0, 0, 0, 255])+ }+ }++ impl Drop for TrackedFrames {+ fn drop(&mut self) { self.0.store(true, Ordering::Release); }+ }++ #[test]+ fn releasing_a_worker_job_discards_frames_that_finish_after_release() {+ let _serial = rendered::TEST_LOCK.lock().unwrap();+ let id = "worker-release-before-finish";+ let log = JobLog { events: Mutex::default(), changed: Condvar::new(), latents: None,+ created: Instant::now(), released: AtomicBool::new(false) };+ log.release(id);+ let dropped = Arc::new(AtomicBool::new(false));+ rendered::keep(rendered::from_source(id, Box::new(TrackedFrames(dropped.clone())),+ vec![], 1, 1, 1, 3, 3, 24.0, 0, 0).unwrap());+ log.push("job", serde_json::json!({ "jobId": id, "state": "framesReady" }));+ assert!(dropped.load(Ordering::Acquire));+ assert!(rendered::summary(id).is_none());+ assert!(log.after(0, Duration::ZERO).is_empty());+ }++ #[test]+ fn releasing_a_finished_worker_job_discards_its_frames() {+ let _serial = rendered::TEST_LOCK.lock().unwrap();+ let id = "worker-release-after-finish";+ let log = JobLog { events: Mutex::default(), changed: Condvar::new(), latents: None,+ created: Instant::now(), released: AtomicBool::new(false) };+ let dropped = Arc::new(AtomicBool::new(false));+ rendered::keep(rendered::from_source(id, Box::new(TrackedFrames(dropped.clone())),+ vec![], 1, 1, 1, 3, 3, 24.0, 0, 0).unwrap());+ log.push("job", serde_json::json!({ "jobId": id, "state": "framesReady" }));+ assert_eq!(log.after(0, Duration::ZERO).len(), 1);+ log.release(id);+ assert!(dropped.load(Ordering::Acquire));+ assert!(rendered::summary(id).is_none());+ }+fn probe(nvidia_gpu: bool, cuda: Option<&'static str>) -> slopfab::BackendProbe {slopfab::BackendProbe { nvidia_gpu, cuda, cuda_problem: (nvidia_gpu && cuda.is_none()).then(|| "cublas64_12.dll not found".into()) }}diff --git a/src-tauri/src/commands/artifacts.rs b/src-tauri/src/commands/artifacts.rsindex 29dcfd9..68bcdd6 100644--- a/src-tauri/src/commands/artifacts.rs+++ b/src-tauri/src/commands/artifacts.rs@@ -160,12 +160,7 @@ pub(crate) fn save_generated_image(job_id: String,format: Option<String>,) -> Result<GeneratedImageFile, String> {- let summary =- rendered::summary(&job_id).ok_or("The generated image is no longer in memory.")?;- if summary.frame_count != 1 {- return Err("Expected a single still image.".into());- }- let rgba = rendered::frame(&job_id, 0)?.ok_or("The generated image has no pixels.")?;+ let (summary, rgba) = rendered::take_still(&job_id)?;if format.as_deref() == Some("png") {write_generated_png_frame(&folder_path, &job_id, summary.width, summary.height, &rgba)} else if format.is_none() || format.as_deref() == Some("jpg") {diff --git a/src-tauri/src/commands/character_sheet.rs b/src-tauri/src/commands/character_sheet.rsindex a53fc31..1aca97b 100644--- a/src-tauri/src/commands/character_sheet.rs+++ b/src-tauri/src/commands/character_sheet.rs@@ -17,11 +17,7 @@ pub(crate) fn save_character_sheet_view(job_id: String,index: usize,) -> Result<(), String> {- let summary = rendered::summary(&job_id).ok_or("The character view is no longer in memory.")?;- if summary.frame_count != 1 {- return Err("Expected one character view.".into());- }- let pixels = rendered::frame(&job_id, 0)?.ok_or("The character view has no pixels.")?;+ let (summary, pixels) = rendered::take_still(&job_id)?;write_view(&folder_path,&sheet_id,diff --git a/src-tauri/src/commands/extend_image.rs b/src-tauri/src/commands/extend_image.rsindex 8cdcb61..4cdf17e 100644--- a/src-tauri/src/commands/extend_image.rs+++ b/src-tauri/src/commands/extend_image.rs@@ -234,7 +234,7 @@ pub(crate) fn save_extended_image({return Err("The generated image does not match the Extend box.".into());}- let pixels = crate::rendered::frame(&job_id, 0)?.ok_or("The extended image has no pixels.")?;+ let (_, pixels) = crate::rendered::take_still(&job_id)?;let mut result = RgbaImage::from_raw(bounds.width, bounds.height, pixels).ok_or("Invalid generated image pixels.")?;restore_original(&mut result, &source, bounds);@@ -560,6 +560,7 @@ mod tests {.unwrap(),);let saved = save_extended_image(path.clone(), job.into()).unwrap();+ assert!(crate::rendered::summary(job).is_none());let image = image::open(root.existing(&saved.relative_path).unwrap()).unwrap().to_rgba8();diff --git a/src-tauri/src/media/artifacts.rs b/src-tauri/src/media/artifacts.rsindex 3413e1c..e72d474 100644--- a/src-tauri/src/media/artifacts.rs+++ b/src-tauri/src/media/artifacts.rs@@ -78,7 +78,7 @@ pub(crate) fn reference_icon_pixels(job_id: &str) -> Result<Vec<u8>, String> {{return Err("A reference icon must be a single 768x768 frame.".into());}- rendered::frame(job_id, 0)?.ok_or_else(|| "The reference icon has no image.".into())+ rendered::take_still(job_id).map(|(_, pixels)| pixels)}pub(crate) fn write_reference_icon_frame(folder_path: &str,