Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(recording): recover footage after an early muxer restart

Aditya Garud96d80712905f
diff --git a/crates/recording/src/recovery.rs b/crates/recording/src/recovery.rs
index 3d1e70f67..36b43f061 100644
--- a/crates/recording/src/recovery.rs
+++ b/crates/recording/src/recovery.rs
@@ -394,6 +394,16 @@ impl RecoveryManager {
display_init_segment = None;
}
+ if display_fragments.is_empty()
+ && let Some(info) = Self::respawn_directories(&display_dir)
+ .into_iter()
+ .map(|(_, directory)| Self::find_studio_fragments_with_init(&directory))
+ .find(|info| !info.fragments.is_empty())
+ {
+ display_fragments = info.fragments;
+ display_init_segment = info.init_segment;
+ }
+
if display_fragments.is_empty() {
debug!(
"No display fragments found for segment {} at {:?}",
@@ -690,11 +700,7 @@ impl RecoveryManager {
}
}
- fn collect_respawn_groups(
- dir: &Path,
- health_tx: Option<&HealthSender>,
- recover_complete_prefixes: bool,
- ) -> Vec<(u32, PathBuf, Vec<PathBuf>)> {
+ fn respawn_directories(dir: &Path) -> Vec<(u32, PathBuf)> {
let Ok(entries) = std::fs::read_dir(dir) else {
return Vec::new();
};
@@ -710,9 +716,16 @@ impl RecoveryManager {
.collect();
respawn_dirs.sort_by_key(|(n, _)| *n);
+ respawn_dirs
+ }
+ fn collect_respawn_groups(
+ dir: &Path,
+ health_tx: Option<&HealthSender>,
+ recover_complete_prefixes: bool,
+ ) -> Vec<(u32, PathBuf, Vec<PathBuf>)> {
let mut groups = Vec::new();
- for (n, respawn_dir) in respawn_dirs {
+ for (n, respawn_dir) in Self::respawn_directories(dir) {
let init_path = respawn_dir.join("init.mp4");
if !init_path.exists() {
debug!(
@@ -1279,6 +1292,9 @@ impl RecoveryManager {
for track in ["display", "camera"] {
let directory = entry.path().join(track);
Self::rescue_pending_tmp_fragments(&directory, None, true);
+ for (_, respawn) in Self::respawn_directories(&directory) {
+ Self::rescue_pending_tmp_fragments(&respawn, None, true);
+ }
}
}
}
@@ -2268,10 +2284,6 @@ impl RecoveryManager {
Self::rescue_pending_tmp_fragments(fragmented_dir, health_tx, recover_complete_prefixes);
let info = Self::find_complete_fragments_with_init(fragmented_dir);
- if info.fragments.is_empty() {
- return Err(RecoveryError::NoRecoverableSegments);
- }
-
let respawn_groups =
Self::collect_respawn_groups(fragmented_dir, health_tx, recover_complete_prefixes);
@@ -2294,16 +2306,18 @@ impl RecoveryManager {
.unwrap_or("recovered");
let parent = output.parent().unwrap_or_else(|| Path::new("."));
- let main_tmp = parent.join(format!("{stem}.main.mp4"));
- Self::finalize_fragments_to_progressive_mp4(
- &info.fragments,
- info.init_segment.as_deref(),
- &main_tmp,
- "display",
- video_validation,
- )?;
- temp_paths.push(main_tmp.clone());
- group_outputs.push(main_tmp);
+ if !info.fragments.is_empty() {
+ let main_tmp = parent.join(format!("{stem}.main.mp4"));
+ Self::finalize_fragments_to_progressive_mp4(
+ &info.fragments,
+ info.init_segment.as_deref(),
+ &main_tmp,
+ "display",
+ video_validation,
+ )?;
+ temp_paths.push(main_tmp.clone());
+ group_outputs.push(main_tmp);
+ }
for (n, init, fragments) in respawn_groups {
let group_tmp = parent.join(format!("{stem}.respawn-{n}.mp4"));
@@ -4474,6 +4488,137 @@ mod clean_studio_snapshot_tests {
path
}
+ fn respawn_only_studio_project() -> tempfile::TempDir {
+ let directory = playable_studio_project(StudioRecordingStatus::InProgress);
+ let project = directory.path();
+ let display = project.join(DISPLAY);
+ RecoveryManager::finalize_to_progressive_mp4(
+ &display,
+ &project.join("content/segments/segment-0/camera.mp4"),
+ )
+ .unwrap();
+ let init = fs::read(display.join("init.mp4")).unwrap();
+ let fragment = fs::read(project.join(FRAGMENT)).unwrap();
+ let successful = project.join("successful-muxer");
+ fs::rename(&display, &successful).unwrap();
+ fs::create_dir(&display).unwrap();
+ fs::write(display.join("init.mp4"), init).unwrap();
+ fs::write(display.join("segment_001.m4s.tmp"), &fragment[..24]).unwrap();
+ fs::write(
+ display.join("manifest.json"),
+ br#"{"version":5,"type":"m4s_segments","init_segment":"init.mp4","segments":[{"path":"segment_001.m4s","is_complete":false}]}"#,
+ )
+ .unwrap();
+ fs::rename(successful, display.join("respawn-1")).unwrap();
+ add_fragmented_audio(project, "audio-input", 94);
+ directory
+ }
+
+ #[test]
+ fn respawn_only_studio_recovery_preserves_video_camera_and_audio() {
+ let directory = respawn_only_studio_project();
+ let project = directory.path();
+ let camera = project.join("content/segments/segment-0/camera.mp4");
+ let packets = |path: &Path| {
+ ffmpeg::format::input(path)
+ .unwrap()
+ .packets()
+ .map(|(_, packet)| packet.data().unwrap().to_vec())
+ .collect::<Vec<_>>()
+ };
+ let expected = packets(&camera);
+ assert_eq!(expected.len(), 60);
+ let audio = project.join("content/segments/segment-0/audio-input.m4a");
+ let expected_audio = packets(&audio);
+ assert!(!expected_audio.is_empty());
+ let before = recovery_snapshot(project).unwrap();
+ let recording = RecoveryManager::inspect_recording(project)
+ .expect("Completed respawn footage must be offered for recovery");
+ assert_eq!(recovery_snapshot(project).unwrap(), before);
+ let recovered = RecoveryManager::recover(&recording).unwrap();
+ assert_eq!(packets(&project.join(OUTPUT)), expected);
+ assert_eq!(packets(&camera), expected);
+ assert_eq!(packets(&audio), expected_audio);
+ assert!(valid_recovered_audio(&audio));
+ assert!(matches!(
+ recovered.meta.status(),
+ StudioRecordingStatus::Complete
+ ));
+ let StudioRecordingMeta::MultipleSegments { inner } = recovered.meta else {
+ panic!("Expected segmented Studio metadata");
+ };
+ assert!(inner.segments[0].camera.is_some());
+ assert!(inner.segments[0].mic.is_some());
+ ProjectConfiguration::load(project)
+ .unwrap()
+ .validate()
+ .unwrap();
+ }
+
+ #[test]
+ fn respawn_only_video_finalization_keeps_every_complete_packet() {
+ let directory = respawn_only_studio_project();
+ let project = directory.path();
+ copy_recovery_input(
+ &project.join(format!("{DISPLAY}/respawn-1")),
+ &project.join(format!("{DISPLAY}/respawn-2")),
+ )
+ .unwrap();
+ RecoveryManager::finalize_to_progressive_mp4(&project.join(DISPLAY), &project.join(OUTPUT))
+ .expect("Completed respawn fragments must not require an initial complete fragment");
+ validate_recovered_track(&project.join(OUTPUT), ffmpeg::media::Type::Video).unwrap();
+ let packets = ffmpeg::format::input(&project.join(OUTPUT))
+ .unwrap()
+ .packets()
+ .count();
+ assert_eq!(packets, 120);
+ }
+
+ #[test]
+ fn respawn_only_studio_recovery_salvages_complete_prefix_from_pending_tail() {
+ let directory = respawn_only_studio_project();
+ let project = directory.path();
+ let fragment = project.join(format!("{DISPLAY}/respawn-1/segment_001.m4s"));
+ let mut bytes = fs::read(&fragment).unwrap();
+ bytes.extend_from_slice(b"\0\0\0\x20moof\0\0");
+ fs::write(fragment.with_extension("m4s.tmp"), bytes).unwrap();
+ fs::remove_file(fragment).unwrap();
+ let manifest = project.join(format!("{DISPLAY}/respawn-1/manifest.json"));
+ let mut value: serde_json::Value =
+ serde_json::from_slice(&fs::read(&manifest).unwrap()).unwrap();
+ value["segments"][0]["is_complete"] = false.into();
+ fs::write(manifest, serde_json::to_vec(&value).unwrap()).unwrap();
+ let before = recovery_snapshot(project).unwrap();
+ let recording = RecoveryManager::inspect_recording(project).unwrap();
+ assert_eq!(recovery_snapshot(project).unwrap(), before);
+ RecoveryManager::recover(&recording).unwrap();
+ validate_recovered_track(&project.join(OUTPUT), ffmpeg::media::Type::Video).unwrap();
+ assert_eq!(
+ ffmpeg::format::input(&project.join(OUTPUT))
+ .unwrap()
+ .packets()
+ .count(),
+ 60
+ );
+ }
+
+ #[test]
+ fn corrupt_respawn_recovery_preserves_original_tracks() {
+ let directory = respawn_only_studio_project();
+ let project = directory.path();
+ fs::write(
+ project.join(format!("{DISPLAY}/respawn-1/init.mp4")),
+ b"corrupt init",
+ )
+ .unwrap();
+ let before = recovery_snapshot(project).unwrap();
+ let recording = RecoveryManager::inspect_recording(project)
+ .expect("Respawn fragments must be inspected before full validation");
+ assert!(RecoveryManager::recover(&recording).is_err());
+ assert_eq!(recovery_snapshot(project).unwrap(), before);
+ assert!(!project.join(OUTPUT).exists());
+ }
+
fn completed_preparing_fixture(project: &Path) -> CompletedRecording {
use crate::studio_recording::CleanStoppedStudio;