Update app.py

app.py

@@ -139,16 +139,14 @@ CHUNK_FRAME_COUNT = int(VIDEO_FPS * CHUNK_SIZE_SECONDS)
 TEMP_VIDEO_FILE = "temp_video_chunk.mp4"
 
 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. Now includes detailed timing logs.
-    """
     if frame is None:
         return None, "Status: Inactive", None, state_dict
 
     # Unpack the state
     frame_buffer = state_dict['buffer']
     start_time = state_dict['start_time']
+    last_buffer_fill_time = state_dict['last_buffer_fill_time']
+    last_encoding_time = state_dict['last_encoding_time']
 
     # If the buffer is empty, this is the first frame of a new chunk. Record start time.
     if not frame_buffer:
@@ -165,45 +163,52 @@ def process_video_chunk(frame, state_dict):
     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)
     audio_out = gr.Audio(value=audio_payload, autoplay=True) if audio_payload else None
 
     # --- Video Buffering Logic ---
     frame_buffer.append(processed_frame)
 
-    video_out = None # No video output until the chunk is ready
+    video_out = None
     if len(frame_buffer) >= CHUNK_FRAME_COUNT:
-        # --- 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
+        encoding_start_time = time.perf_counter()
         h, w, _ = frame_buffer[0].shape
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         writer = cv2.VideoWriter(TEMP_VIDEO_FILE, fourcc, VIDEO_FPS, (w, h))
         for f in 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
+        last_buffer_fill_time = buffer_fill_time
+        last_encoding_time = encoding_time
+        frame_buffer = []
+        start_time = None
 
-        video_out = TEMP_VIDEO_FILE # Set the output to the new video file path
-        frame_buffer = [] # Clear the buffer for the next chunk
-        start_time = None # Reset start time
+    # --- NEW: Update status text to include buffer/encoding times ---
+    status_txt = (
+        f"Status: {level} (Score: {score:.2f})\n"
+        f"Buffer Fill Time: {last_buffer_fill_time:.2f}s\n"
+        f"Video Encode Time: {last_encoding_time:.2f}s"
+    )
+    logging.info(f"Status: {status_txt}")
 
     # Pack state back up to return
-    new_state = {'buffer': frame_buffer, 'start_time': start_time}
+    new_state = {
+        'buffer': frame_buffer,
+        'start_time': start_time,
+        'last_buffer_fill_time': last_buffer_fill_time,
+        'last_encoding_time': last_encoding_time
+    }
     
-    # Note: Status and Audio are returned on every frame for real-time feedback
     return video_out, status_txt, audio_out, new_state
 
+    
 # ───────────────────────────── UI Definition
 def create_readme_tab():
     """Creates the content for the 'About' tab."""
@@ -284,7 +289,7 @@ def create_detection_tab():
         )
 
 def create_video_experiment_tab():
-    """Creates the content for the Video Chunk experiment tab."""
+    """Creates the content for the Video Chunk experiment tab - UPDATED."""
     with gr.Blocks() as video_tab:
         gr.Markdown("## 🧪 Video Output Experiment")
         gr.Markdown(f"This feed buffers processed frames and outputs them as **{CHUNK_SIZE_SECONDS}-second video chunks**. Notice the trade-off between smoothness and latency. Alerts remain real-time.")
@@ -292,20 +297,29 @@ def create_video_experiment_tab():
             with gr.Column(scale=2):
                 cam_video = gr.Image(sources=["webcam"], streaming=True, label="Live Camera Feed")
             with gr.Column(scale=1):
-                out_video = gr.Video(label="Processed Video Chunk")
-                out_text_video = gr.Textbox(label="Live Status", lines=3, interactive=False)
+                # --- NEW: Use the blank video as the initial value ---
+                out_video = gr.Video(label="Processed Video Chunk", value=BLANK_VIDEO_FILE)
+                # --- NEW: Textbox is now larger to show more info ---
+                out_text_video = gr.Textbox(label="Live Status", lines=4, interactive=False)
                 out_audio_video = gr.Audio(label="Alert", autoplay=True, visible=False)
 
-        # NEW: State is now a dictionary to hold the buffer and start time
-        frame_buffer_state = gr.State({'buffer': [], 'start_time': None})
+        # --- NEW: State is a dictionary to hold the buffer and timing info ---
+        initial_state = {
+            'buffer': [], 
+            'start_time': None, 
+            'last_buffer_fill_time': 0.0,
+            'last_encoding_time': 0.0
+        }
+        state = gr.State(initial_state)
         
         cam_video.stream(
             fn=process_video_chunk,
-            inputs=[cam_video, frame_buffer_state],
-            outputs=[out_video, out_text_video, out_audio_video, frame_buffer_state]
+            inputs=[cam_video, state],
+            outputs=[out_video, out_text_video, out_audio_video, state]
         )
     return video_tab
-    
+
+
 with gr.Blocks(title="🚗 Drive Paddy – Drowsiness Detection", theme=gr.themes.Soft()) as app:
     gr.Markdown("# 🚗 **Drive Paddy**")
     with gr.Tabs():