Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

test(rendering): cover the decoder giving up on abandoned scrub requests and run the backward scrub test in Engine verify

Richie McIlroy249c5c93ddfd
diff --git a/crates/rendering/src/decoder/model/mod.rs b/crates/rendering/src/decoder/model/mod.rs
index c536c7237..33d9cd0df 100644
--- a/crates/rendering/src/decoder/model/mod.rs
+++ b/crates/rendering/src/decoder/model/mod.rs
@@ -1093,6 +1093,8 @@ fn run_suite(decoder: Decoder) {
#[test]
fn avassetreader_answers_match_the_reference_model() {
run_suite(Decoder::Avf);
+ avassetreader_scrubbing_backwards_reuses_the_frames_below_each_seek();
+ avassetreader_stops_reading_only_once_every_request_is_abandoned();
}
#[test]
@@ -1180,3 +1182,63 @@ fn avassetreader_scrubbing_backwards_reuses_the_frames_below_each_seek() {
outcome.starts
);
}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn avassetreader_stops_reading_only_once_every_request_is_abandoned() {
+ let script = Script {
+ time_base: (1, 30),
+ frames: (0..900)
+ .map(|pts| scripted::ScriptFrame {
+ pts,
+ keyframe: pts % 600 == 0,
+ })
+ .collect(),
+ last_duration: 1,
+ };
+ let registration = scripted::register(script);
+ let path = registration.path().to_path_buf();
+ runtime().block_on(async {
+ let handle = spawn_decoder("model", path, 30, 0.0, false)
+ .await
+ .unwrap()
+ .with_max_fallback_distance(2);
+ registration.set_vend_delay(Duration::from_millis(2));
+ registration.take_vended();
+ let time = |frame: u32| frame as f32 / 30.0;
+
+ let abandoned = tokio::time::timeout(
+ Duration::from_millis(40),
+ handle.get_frame_initial(time(550)),
+ );
+ let batch = async {
+ tokio::time::sleep(Duration::from_millis(10)).await;
+ tokio::join!(
+ tokio::time::timeout(
+ Duration::from_millis(150),
+ handle.get_frame_initial(time(760)),
+ ),
+ handle.get_frame_initial(time(765)),
+ )
+ };
+ let (abandoned, (dropped, kept)) = tokio::join!(abandoned, batch);
+
+ assert!(abandoned.is_err(), "frame 550 arrived before 40 ms");
+ assert!(dropped.is_err(), "frame 760 arrived before 160 ms");
+ assert_eq!(
+ kept.as_ref().and_then(frame_identity),
+ Some(765),
+ "the open request of a batch whose other request was dropped"
+ );
+ let read_below_keyframe = registration
+ .take_vended()
+ .iter()
+ .filter(|&&index| index < 600)
+ .count();
+ assert!(
+ read_below_keyframe < 300,
+ "{read_below_keyframe} frames read towards frame 550 after its request was dropped at 40 ms"
+ );
+ assert_eq!(handle.decoder_type(), DecoderType::AVAssetReader);
+ });
+}
diff --git a/crates/video-decode/src/scripted.rs b/crates/video-decode/src/scripted.rs
index a44e2a929..864894c62 100644
--- a/crates/video-decode/src/scripted.rs
+++ b/crates/video-decode/src/scripted.rs
@@ -25,6 +25,7 @@ use std::{
Arc, Mutex, OnceLock,
atomic::{AtomicU64, Ordering},
},
+ time::Duration,
};
const MAGIC: [u8; 4] = *b"CAPS";
@@ -95,6 +96,7 @@ struct Counters {
pub(crate) struct ScriptState {
pub(crate) script: Script,
counters: Counters,
+ vend_delay_micros: AtomicU64,
vended: Mutex<Vec<u32>>,
#[cfg(target_os = "macos")]
samples: Mutex<HashMap<usize, avf::SharedSample>>,
@@ -102,6 +104,10 @@ pub(crate) struct ScriptState {
impl ScriptState {
fn record_vend(&self, index: usize) {
+ let delay = self.vend_delay_micros.load(Ordering::Relaxed);
+ if delay > 0 {
+ std::thread::sleep(Duration::from_micros(delay));
+ }
self.vended.lock().unwrap().push(index as u32);
}
@@ -156,6 +162,15 @@ impl Registration {
std::mem::take(&mut *self.state.vended.lock().unwrap())
}
+ /// Every reader of this script sleeps this long before each vend, so a
+ /// test can act while a read is still in progress.
+ pub fn set_vend_delay(&self, delay: Duration) {
+ let micros = u64::try_from(delay.as_micros()).unwrap_or(u64::MAX);
+ self.state
+ .vend_delay_micros
+ .store(micros, Ordering::Relaxed);
+ }
+
/// AVAssetReader starts: creations and resets.
pub fn reader_starts(&self) -> u64 {
self.state.counters.reader_starts.load(Ordering::Relaxed)
@@ -184,6 +199,7 @@ pub fn register(script: Script) -> Registration {
let state = Arc::new(ScriptState {
script,
counters: Counters::default(),
+ vend_delay_micros: AtomicU64::new(0),
vended: Mutex::new(Vec::new()),
#[cfg(target_os = "macos")]
samples: Mutex::new(HashMap::new()),