Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

Merge remote-tracking branch 'origin/main' into HEAD

Richie McIlroycc48bf455f00
diff --cc crates/recording/src/recovery.rs
index 6098bf900,a2efd2da3..3c3887c11
--- a/crates/recording/src/recovery.rs
+++ b/crates/recording/src/recovery.rs
@@@ -368,10 -398,28 +398,9 @@@ impl RecoveryManager
.and_then(|s| s.parse().ok())
.unwrap_or(0);
- let display_info =
- Self::segment_track_fragments(&segment_path, "display", "display.mp4");
- let display_dir = segment_path.join("display");
- let display_info = Self::find_studio_fragments_with_init(&display_dir);
- let mut display_fragments = display_info.fragments;
- let mut display_init_segment = display_info.init_segment;
-
- if display_fragments.is_empty()
- && let Some(display_mp4) =
- Self::probe_single_file(&segment_path.join("display.mp4"))
- {
- display_fragments = vec![display_mp4];
- 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;
- }
++ let display_info = Self::segment_track_fragments(&segment_path, "display", true);
+ let display_fragments = display_info.fragments;
+ let display_init_segment = display_info.init_segment;
if display_fragments.is_empty() {
debug!(
@@@ -381,13 -429,18 +410,10 @@@
continue;
}
- let camera_info = Self::segment_track_fragments(&segment_path, "camera", "camera.mp4");
- let camera_dir = segment_path.join("camera");
- let (camera_fragments, camera_init_segment) = {
- let camera_info = Self::find_studio_fragments_with_init(&camera_dir);
- if camera_info.fragments.is_empty() {
- (
- Self::probe_single_file(&segment_path.join("camera.mp4")).map(|p| vec![p]),
- None,
- )
- } else {
- (Some(camera_info.fragments), camera_info.init_segment)
- }
- };
++ let camera_info = Self::segment_track_fragments(&segment_path, "camera", false);
+ let camera_init_segment = camera_info.init_segment;
- let camera_fragments = if camera_info.fragments.is_empty() {
- None
- } else {
- Some(camera_info.fragments)
- };
++ let camera_fragments =
++ (!camera_info.fragments.is_empty()).then_some(camera_info.fragments);
let mic_fragments = Self::find_audio_fragments(&segment_path.join("audio-input"));
let system_audio_fragments =
@@@ -604,60 -717,7 +690,57 @@@
}
}
- /// The fragmented media a single track of a segment directory holds, falling
- /// back to the equivalent single file. Shared by segment collection and by
++ /// One track of a segment directory: its fragments, else the single-file
++ /// fallback, else (when `respawn` is set) the first respawned muxer
++ /// directory holding fragments. Shared by segment collection and by
+ /// recovery validation so neither can disagree about what a segment holds.
- fn segment_track_fragments(
- segment_path: &Path,
- track: &str,
- single_file: &str,
- ) -> FragmentsInfo {
- let info = Self::find_complete_fragments_with_init(&segment_path.join(track));
-
++ fn segment_track_fragments(segment_path: &Path, track: &str, respawn: bool) -> FragmentsInfo {
++ let dir = segment_path.join(track);
++ let info = Self::find_studio_fragments_with_init(&dir);
+ if !info.fragments.is_empty() {
+ return info;
+ }
+
- match Self::probe_single_file(&segment_path.join(single_file)) {
- Some(fragment) => FragmentsInfo {
- fragments: vec![fragment],
- init_segment: None,
- },
- None => FragmentsInfo {
- fragments: Vec::new(),
++ if let Some(file) = Self::probe_single_file(&segment_path.join(format!("{track}.mp4"))) {
++ return FragmentsInfo {
++ fragments: vec![file],
+ init_segment: None,
- },
++ };
++ }
++
++ if respawn
++ && let Some(info) = Self::respawn_directories(&dir)
++ .into_iter()
++ .map(|(_, directory)| Self::find_studio_fragments_with_init(&directory))
++ .find(|info| !info.fragments.is_empty())
++ {
++ return info;
++ }
++
++ FragmentsInfo {
++ fragments: Vec::new(),
++ init_segment: None,
+ }
+ }
+
+ /// Whether a segment directory holds any recoverable media at all.
+ ///
+ /// A directory with nothing in it is the residue of a resume that failed
+ /// before it wrote a frame, and recovery can ignore it. One holding any
+ /// track at all is a real inconsistency: skipping it would leave that
+ /// footage out of the recovered recording, so it has to be surfaced rather
+ /// than waved through.
+ fn segment_holds_recoverable_media(segment_path: &Path) -> bool {
- for track in ["display", "camera"] {
- let single_file = format!("{track}.mp4");
-
- if !Self::segment_track_fragments(segment_path, track, &single_file)
++ ["display", "camera"].iter().any(|track| {
++ !Self::segment_track_fragments(segment_path, track, true)
+ .fragments
+ .is_empty()
- {
- return true;
- }
- }
-
- ["audio-input", "system_audio"]
++ }) || ["audio-input", "system_audio"]
+ .iter()
+ .any(|track| Self::find_audio_fragments(&segment_path.join(track)).is_some())
+ }
+
- fn collect_respawn_groups(
- dir: &Path,
- health_tx: Option<&HealthSender>,
- ) -> 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();
};