Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,