Update app.py

app.py

@@ -93,7 +93,6 @@ class AlertManager:
 alert_manager = AlertManager(CFG["alerting"])
 
 # ───────────────────────────── frame processing <--- MAJOR CHANGE
-# Simplified by the AlertManager. No longer needs to pass 'last_alert_ts' back and forth.
 def process_live_frame(frame):
     if frame is None:
         return (
@@ -105,7 +104,6 @@ def process_live_frame(frame):
     t0 = time.perf_counter()
 
     try:
-        # Assuming your detector returns (processed_image, indicators_dict)
         processed, indic = detector.process_frame(frame)
     except Exception as e:
         logging.error(f"Error processing frame: {e}")
@@ -125,30 +123,36 @@ def process_live_frame(frame):
            else f"Status: {level}\nScore: {score:.2f}")
     )
 
-    # Check for an alert and get the audio payload if ready
     audio_payload = alert_manager.trigger_alert(level, lighting)
 
-    # This is the key: return a new gr.Audio component when an alert fires.
-    # Otherwise, return None to clear the component on the frontend.
     if audio_payload:
         return processed, status_txt, gr.Audio(value=audio_payload, autoplay=True)
     else:
         return processed, status_txt, None
 
 
+
 # Constants for the video experiment
 VIDEO_FPS = 30.0
 CHUNK_SIZE_SECONDS = 2
 CHUNK_FRAME_COUNT = int(VIDEO_FPS * CHUNK_SIZE_SECONDS)
 TEMP_VIDEO_FILE = "temp_video_chunk.mp4"
 
-def process_video_chunk(frame, frame_buffer):
+def process_video_chunk(frame, state_dict):
     """
     Processes a single frame, adds it to a buffer, and encodes a video chunk
-    when the buffer is full. The alert system remains real-time.
+    when the buffer is full. Now includes detailed timing logs.
     """
     if frame is None:
-        return None, "Status: Inactive", None, [] # Return empty buffer
+        return None, "Status: Inactive", None, state_dict
+
+    # Unpack the state
+    frame_buffer = state_dict['buffer']
+    start_time = state_dict['start_time']
+
+    # If the buffer is empty, this is the first frame of a new chunk. Record start time.
+    if not frame_buffer:
+        start_time = time.perf_counter()
 
     # --- Real-time detection and alerting (This is not delayed) ---
     try:
@@ -161,6 +165,7 @@ def process_video_chunk(frame, frame_buffer):
     level = indic.get("drowsiness_level", "Awake")
     lighting = indic.get("lighting", "Good")
     score = indic.get("details", {}).get("Score", 0.0)
+    # The status text is updated on every single frame.
     status_txt = f"Lighting: {lighting}\nStatus: {level}\nScore: {score:.2f}"
     
     audio_payload = alert_manager.trigger_alert(level, lighting)
@@ -171,7 +176,13 @@ def process_video_chunk(frame, frame_buffer):
 
     video_out = None # No video output until the chunk is ready
     if len(frame_buffer) >= CHUNK_FRAME_COUNT:
-        logging.info(f"Buffer full. Encoding {len(frame_buffer)} frames to video chunk...")
+        # --- NEW: Logging buffer fill time ---
+        buffer_fill_time = time.perf_counter() - start_time
+        logging.info(f"BUFFER: Filled {len(frame_buffer)} frames in {buffer_fill_time:.2f} seconds.")
+
+        # --- NEW: Logging encoding time ---
+        encoding_start_time = time.perf_counter()
+        
         # Encode the buffer to a video file
         h, w, _ = frame_buffer[0].shape
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
@@ -180,13 +191,18 @@ def process_video_chunk(frame, frame_buffer):
             writer.write(f)
         writer.release()
         
+        encoding_time = time.perf_counter() - encoding_start_time
+        logging.info(f"ENCODING: Video chunk encoded in {encoding_time:.2f} seconds.")
+
         video_out = TEMP_VIDEO_FILE # Set the output to the new video file path
         frame_buffer = [] # Clear the buffer for the next chunk
-        logging.info("Encoding complete. Sending video to frontend.")
+        start_time = None # Reset start time
 
+    # Pack state back up to return
+    new_state = {'buffer': frame_buffer, 'start_time': start_time}
+    
     # Note: Status and Audio are returned on every frame for real-time feedback
-    return video_out, status_txt, audio_out, frame_buffer
-
+    return video_out, status_txt, audio_out, new_state
 
 # ───────────────────────────── UI Definition
 def create_readme_tab():
@@ -280,8 +296,8 @@ def create_video_experiment_tab():
                 out_text_video = gr.Textbox(label="Live Status", lines=3, interactive=False)
                 out_audio_video = gr.Audio(label="Alert", autoplay=True, visible=False)
 
-        # State to hold the buffer of frames between updates
-        frame_buffer_state = gr.State([])
+        # NEW: State is now a dictionary to hold the buffer and start time
+        frame_buffer_state = gr.State({'buffer': [], 'start_time': None})
         
         cam_video.stream(
             fn=process_video_chunk,