mirror of
https://github.com/storytold/effectcraft.git
synced 2026-11-16 15:22:43 +00:00
#2042: a decode in flight when its file is forgotten keeps nothing
The media pool counts forgets and frame clears. A read-ahead (sequential playback's next frame, on its own thread) carries the count it was queued at and decodes nothing once a forget came after it; any decode keeps its frame only if no forget came while it ran. A viewer playing a movie at Close, or any reader decoding through it, can no longer bring the closed project's frames back after Session::replace_project forgot them.
This commit is contained in:
1 parent
365c472828
commit
2da516ed84
1 file changed
+51
-7
@@ -208,6 +208,10 @@ struct CacheState {
|
||||
last: HashMap<Arc<str>, i64>,
|
||||
/// Movies whose frames can't be kept as 8-bit levels (more bits, or shown turned).
|
||||
wide: HashSet<Arc<str>>,
|
||||
/// Counts [`MediaPool::forget`]s and frame clears: a decode keeps its frame only when none
|
||||
/// came while it ran, so one in flight when a file is forgotten (a closed project's, or one
|
||||
/// changed on disk) can't bring the frame back.
|
||||
forgets: u64,
|
||||
}
|
||||
|
||||
/// A movie/audio source by path ([`Opened`]), opened by the first caller while the others wait
|
||||
@@ -406,6 +410,7 @@ impl MediaPool {
|
||||
let mut c = lock(&self.inner.cache);
|
||||
c.lru = Lru::default();
|
||||
c.last.clear();
|
||||
c.forgets = c.forgets.wrapping_add(1);
|
||||
drop(c);
|
||||
// Decoded GIFs sit outside the frame budget; Purge frees them too.
|
||||
lock(&self.inner.gifs).clear();
|
||||
@@ -431,6 +436,7 @@ impl MediaPool {
|
||||
}
|
||||
c.last.remove(path);
|
||||
c.wide.remove(path);
|
||||
c.forgets = c.forgets.wrapping_add(1);
|
||||
drop(c);
|
||||
crate::exr_channels::forget(path);
|
||||
}
|
||||
@@ -455,7 +461,7 @@ impl MediaPool {
|
||||
if lock(&self.inner.cache).wide.contains(footage.path.as_str()) {
|
||||
return None;
|
||||
}
|
||||
match Inner::frame_px(&self.inner, footage, t, true, None, float, true) {
|
||||
match Inner::frame_px(&self.inner, footage, t, true, None, float, true, None) {
|
||||
Ok(Pixels::Q8(f)) => Some(f),
|
||||
_ => None,
|
||||
}
|
||||
@@ -850,7 +856,7 @@ impl Inner {
|
||||
/// The frame of `footage` at `t`, resampled to `size` (see [`FootageSource::frame_at_size`]):
|
||||
/// a movie's made at that size directly, a still's resampled once and kept at that size.
|
||||
fn frame_at(self: &Arc<Self>, footage: &Footage, t: Tick, playback: bool, size: Option<(u32, u32)>, float: FloatCurve) -> Result<Arc<Image>> {
|
||||
match Self::frame_px(self, footage, t, playback, size, float, false)? {
|
||||
match Self::frame_px(self, footage, t, playback, size, float, false, None)? {
|
||||
Pixels::F32(img) => Ok(img),
|
||||
// (a float request's key never holds 8-bit levels)
|
||||
Pixels::Q8(_) => Err(MediaError::Decode(format!("{}: 8-bit frame for a float request", footage.path))),
|
||||
@@ -859,8 +865,20 @@ impl Inner {
|
||||
|
||||
/// [`Self::frame_at`], kept as 8-bit levels when `q8` is set and the frame has 8 bits (a
|
||||
/// float frame under the float key otherwise, and the movie is remembered as `wide`).
|
||||
/// `since`: the [`CacheState::forgets`] count the read was asked at (a read-ahead's, when it
|
||||
/// was queued); a read that missed is not decoded once a forget came after it, and a frame
|
||||
/// decoded while one came is not kept.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn frame_px(self: &Arc<Self>, footage: &Footage, t: Tick, playback: bool, size: Option<(u32, u32)>, float: FloatCurve, q8: bool) -> Result<Pixels> {
|
||||
fn frame_px(
|
||||
self: &Arc<Self>,
|
||||
footage: &Footage,
|
||||
t: Tick,
|
||||
playback: bool,
|
||||
size: Option<(u32, u32)>,
|
||||
float: FloatCurve,
|
||||
q8: bool,
|
||||
since: Option<u64>,
|
||||
) -> Result<Pixels> {
|
||||
if !footage.has_video {
|
||||
return Err(MediaError::Unsupported(format!("{}: no video", footage.path)));
|
||||
}
|
||||
@@ -909,6 +927,10 @@ impl Inner {
|
||||
}
|
||||
c = self.done.wait(c).unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
}
|
||||
let since = since.unwrap_or(c.forgets);
|
||||
if c.forgets != since {
|
||||
return Err(MediaError::Cancelled);
|
||||
}
|
||||
self.misses.fetch_add(1, Ordering::Relaxed);
|
||||
c.inflight.insert(loc.key.clone());
|
||||
drop(c);
|
||||
@@ -917,6 +939,9 @@ impl Inner {
|
||||
reads::note_all(&files);
|
||||
let img = img?;
|
||||
let mut c = lock(&self.cache);
|
||||
if c.forgets != since {
|
||||
return Ok(img);
|
||||
}
|
||||
if q8 && let Pixels::F32(_) = img {
|
||||
// not 8-bit: kept as the float frame it is, which the renderer asks for next
|
||||
c.wide.insert(loc.key.path.clone());
|
||||
@@ -935,23 +960,23 @@ impl Inner {
|
||||
next.key.size = loc.key.size;
|
||||
next.key.q8 = loc.key.q8;
|
||||
if next.key != loc.key && !c.lru.map.contains_key(&next.key) && !c.inflight.contains(&next.key) {
|
||||
self.prefetch(footage, next_t, size, float, loc.key.q8);
|
||||
self.prefetch(footage, next_t, size, float, loc.key.q8, c.forgets);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn prefetch(self: &Arc<Self>, footage: &Footage, t: Tick, size: Option<(u32, u32)>, float: FloatCurve, q8: bool) {
|
||||
fn prefetch(self: &Arc<Self>, footage: &Footage, t: Tick, size: Option<(u32, u32)>, float: FloatCurve, q8: bool, since: u64) {
|
||||
let (me, f) = (self.clone(), footage.clone());
|
||||
self.prefetched.fetch_add(1, Ordering::Relaxed);
|
||||
// A plain thread, not a rayon job: the decode below parallelises with rayon itself.
|
||||
std::thread::spawn(move || {
|
||||
let _ = me.frame_px(&f, t, false, size, float, q8);
|
||||
let _ = me.frame_px(&f, t, false, size, float, q8, Some(since));
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn prefetch(self: &Arc<Self>, _footage: &Footage, _t: Tick, _size: Option<(u32, u32)>, _float: FloatCurve, _q8: bool) {}
|
||||
fn prefetch(self: &Arc<Self>, _footage: &Footage, _t: Tick, _size: Option<(u32, u32)>, _float: FloatCurve, _q8: bool, _since: u64) {}
|
||||
|
||||
/// A still (image file or sequence frame) at `loc.key.size` when one is set: resampled as the
|
||||
/// renderer would ([`FootageSource::frame_at_size`]), so the pool keeps the reduced frame and a
|
||||
@@ -1203,6 +1228,25 @@ fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// #2042: a read queued before its file was forgotten (a read-ahead of a closed project's
|
||||
/// movie, started from the frame before) decodes nothing and keeps nothing; a read asked
|
||||
/// after the forget decodes and keeps its frame.
|
||||
#[test]
|
||||
fn reads_queued_before_a_forget_keep_nothing() {
|
||||
let mut png = std::io::Cursor::new(Vec::new());
|
||||
image::RgbaImage::new(2, 2).write_to(&mut png, image::ImageFormat::Png).unwrap();
|
||||
let pool = MediaPool::new();
|
||||
pool.add_bytes("/a.png", png.into_inner().into());
|
||||
let f = Footage { path: "/a.png".into(), kind: FootageKind::Still, width: 2, height: 2, has_video: true, ..Default::default() };
|
||||
let queued = lock(&pool.inner.cache).forgets;
|
||||
pool.forget("/a.png");
|
||||
let read = Inner::frame_px(&pool.inner, &f, Tick::ZERO, false, None, FloatCurve::Srgb, false, Some(queued));
|
||||
assert!(matches!(read, Err(MediaError::Cancelled)), "{:?}", read.err());
|
||||
assert_eq!(pool.stats().frames, 0, "the forgotten file's frame came back");
|
||||
pool.frame_at(&f, Tick::ZERO).unwrap();
|
||||
assert_eq!(pool.stats().frames, 1);
|
||||
}
|
||||
|
||||
/// Conforming a long file's audio reads every chunk at its own time: the sample index times
|
||||
/// ticks per second overflowed `i64` past 12:36 at 48 kHz, and later chunks came out silent
|
||||
/// (#172).
|
||||
|
||||
Reference in new issue
Block a user