scrub optimization

cht/stream/manager.py

@@ -65,6 +65,7 @@ class StreamManager:
         self._threads = {}
         self._stop_flags = set()
         self._segment = 0
+        self._segment_offsets = {0: 0.0}  # segment_index → global_offset
         self.scene_threshold = SCENE_THRESHOLD
         self.readonly = False  # True when loaded from existing session
         log.info("Session: %s", session_id)
@@ -72,6 +73,7 @@ class StreamManager:
     @classmethod
     def from_existing(cls, session_id):
         """Load an existing session without starting any ffmpeg processes."""
+        from cht.session import rebuild_manifest
         mgr = cls(session_id=session_id)
         if not mgr.session_dir.exists():
             raise FileNotFoundError(f"Session not found: {session_id}")
@@ -80,10 +82,35 @@ class StreamManager:
         segments = mgr.recording_segments
         if segments:
             mgr._segment = len(segments) - 1
+        mgr._rebuild_offsets()
+        rebuild_manifest(mgr.session_dir)
         log.info("Loaded existing session: %s (%d segments, %d frames)",
                  session_id, len(segments), mgr.frame_count)
         return mgr
 
+    @property
+    def current_global_offset(self) -> float:
+        """Global time offset for the current recording segment."""
+        return self._segment_offsets.get(self._segment, 0.0)
+
+    def _rebuild_offsets(self):
+        """Compute global offsets from all segments on disk."""
+        from cht.session import probe_duration
+        offset = 0.0
+        self._segment_offsets = {}
+        for i, seg in enumerate(self.recording_segments):
+            self._segment_offsets[i] = offset
+            offset += probe_duration(seg)
+
+    def _advance_segment_offset(self, completed_segment_path):
+        """Update offsets after a segment completes and a new one begins."""
+        from cht.session import probe_duration
+        dur = probe_duration(completed_segment_path)
+        prev_offset = self._segment_offsets.get(self._segment, 0.0)
+        self._segment_offsets[self._segment + 1] = prev_offset + dur
+        log.info("Segment %d completed (%.1fs), next offset: %.1fs",
+                 self._segment, dur, prev_offset + dur)
+
     @property
     def frame_count(self):
         index_path = self.frames_dir / "index.json"
@@ -144,6 +171,7 @@ class StreamManager:
         # Start after existing segments (for resumed sessions)
         existing = self.recording_segments
         self._segment = len(existing)
+        self._rebuild_offsets()
         self._launch_recorder()
 
     def restart_recorder(self):
@@ -151,8 +179,11 @@ class StreamManager:
         old = self._procs.pop("recorder", None)
         if old:
             ff.stop_proc(old)
+        completed_path = self.recording_path
+        self._advance_segment_offset(completed_path)
         self._segment += 1
-        log.info("Restarting recorder → segment %d", self._segment)
+        log.info("Restarting recorder → segment %d (offset %.1fs)",
+                 self._segment, self.current_global_offset)
         self._launch_recorder()
 
     def recorder_alive(self):
@@ -297,6 +328,7 @@ class StreamManager:
         index_path = self.frames_dir / "index.json"
         index = json.loads(index_path.read_text()) if index_path.exists() else []
 
+        offset = self.current_global_offset
         frame_num = start_number
         for line in stderr.splitlines():
             if "showinfo" not in line:
@@ -309,7 +341,7 @@ class StreamManager:
                 if frame_path.exists():
                     entry = {
                         "id": frame_id,
-                        "timestamp": pts_time,
+                        "timestamp": pts_time + offset,
                         "path": str(frame_path),
                         "sent_to_agent": False,
                     }
@@ -332,7 +364,8 @@ class StreamManager:
                 log.warning("capture_now: recording too short")
                 return
 
-            timestamp = safe_duration - 1
+            local_timestamp = safe_duration - 1
+            timestamp = local_timestamp + self.current_global_offset
             index_path = self.frames_dir / "index.json"
             index = json.loads(index_path.read_text()) if index_path.exists() else []
             frame_num = len(index) + 1
@@ -340,7 +373,7 @@ class StreamManager:
             frame_path = self.frames_dir / f"{frame_id}.jpg"
 
             try:
-                ff.extract_frame_at(self.recording_path, frame_path, timestamp)
+                ff.extract_frame_at(self.recording_path, frame_path, local_timestamp)
             except Exception as e:
                 log.error("capture_now failed: %s", e)
                 return
@@ -421,10 +454,14 @@ class StreamManager:
                     continue
 
                 if wav_path.exists() and wav_path.stat().st_size > 100:
-                    log.info("Audio chunk: %s (%.1fs → %.1fs)",
-                             wav_path.name, processed_time, process_to)
+                    global_start = processed_time + self.current_global_offset
+                    log.info("Audio chunk: %s (%.1fs → %.1fs, global %.1fs)",
+                             wav_path.name, processed_time, process_to, global_start)
                     if self._on_new_audio:
-                        self._on_new_audio(wav_path, processed_time, chunk_duration)
+                        self._on_new_audio(
+                            wav_path, global_start, chunk_duration,
+                            segment_path=seg, local_start=processed_time,
+                        )
                     chunk_num += 1
 
                 processed_time = process_to