add more debug

app.py

@@ -65,41 +65,46 @@ class ChaplinGradio:
     def process_frame(self, frame):
         """Process frames with buffering"""
         current_time = time.time()
+        debug_log = []  # List to collect debug messages
+        
+        # Add initial debug info
+        debug_log.append(f"Current time: {current_time}")
         
         if current_time - self.last_frame_time < self.frame_interval:
-            return self.last_prediction
+            debug_log.append("Skipping frame - too soon")
+            return self.last_prediction, "\n".join(debug_log)  # Make sure we return both values
             
         self.last_frame_time = current_time
         
         if frame is None:
-            print("Received None frame")
-            return "No video input detected"
+            debug_log.append("Received None frame")
+            return "No video input detected", "\n".join(debug_log)
         
         try:
-            print(f"Received frame with shape: {frame.shape}")
+            debug_log.append(f"Received frame with shape: {frame.shape}")
             
             # Convert frame to grayscale if it's not already
             if len(frame.shape) == 3:
                 frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
-                print("Converted frame to grayscale")
+                debug_log.append("Converted frame to grayscale")
             
             # Add frame to buffer
             self.frame_buffer.append(frame)
-            print(f"Buffer size now: {len(self.frame_buffer)}/{self.min_frames}")
+            debug_log.append(f"Buffer size now: {len(self.frame_buffer)}/{self.min_frames}")
             
             # Process when we have enough frames
             if len(self.frame_buffer) >= self.min_frames:
-                print("Processing buffer - have enough frames")
+                debug_log.append("Processing buffer - have enough frames")
                 # Create temp directory if it doesn't exist
                 os.makedirs("temp", exist_ok=True)
                 
                 # Generate temporary video file path
                 temp_video = f"temp/frames_{time.time_ns()}.mp4"
-                print(f"Created temp video path: {temp_video}")
+                debug_log.append(f"Created temp video path: {temp_video}")
                 
                 # Get frame dimensions from first frame
                 frame_height, frame_width = self.frame_buffer[0].shape[:2]
-                print(f"Video dimensions: {frame_width}x{frame_height}")
+                debug_log.append(f"Video dimensions: {frame_width}x{frame_height}")
                 
                 # Create video writer
                 out = cv2.VideoWriter(
@@ -113,36 +118,38 @@ class ChaplinGradio:
                 # Write all frames to video
                 for i, f in enumerate(self.frame_buffer):
                     out.write(f)
-                print(f"Wrote {i+1} frames to video")
+                debug_log.append(f"Wrote {i+1} frames to video")
                 out.release()
                 
                 # Clear buffer but keep last few frames for continuity
                 self.frame_buffer = self.frame_buffer[-8:]  # Keep last 0.5 seconds
-                print(f"Cleared buffer, kept {len(self.frame_buffer)} frames")
+                debug_log.append(f"Cleared buffer, kept {len(self.frame_buffer)} frames")
                 
                 try:
                     # Process the video file using the pipeline
-                    print("Starting model inference...")
+                    debug_log.append("Starting model inference...")
                     predicted_text = self.vsr_model(temp_video)
-                    print(f"Model prediction: {predicted_text}")
+                    debug_log.append(f"Model prediction: {predicted_text}")
                     if predicted_text:
                         self.last_prediction = predicted_text
-                    return self.last_prediction
+                    return (self.last_prediction or "Waiting for speech..."), "\n".join(debug_log)
                     
                 except Exception as e:
-                    print(f"Error during inference: {str(e)}")
-                    return f"Error processing frames: {str(e)}"
+                    error_msg = f"Error during inference: {str(e)}"
+                    debug_log.append(error_msg)
+                    return f"Error processing frames: {str(e)}", "\n".join(debug_log)
                 finally:
                     # Clean up temp file
                     if os.path.exists(temp_video):
                         os.remove(temp_video)
-                        print("Cleaned up temp video file")
+                        debug_log.append("Cleaned up temp video file")
             
-            return self.last_prediction or "Waiting for speech..."
+            return (self.last_prediction or "Waiting for speech..."), "\n".join(debug_log)
                 
         except Exception as e:
-            print(f"Error processing: {str(e)}")
-            return f"Error processing: {str(e)}"
+            error_msg = f"Error processing: {str(e)}"
+            debug_log.append(error_msg)
+            return f"Error processing: {str(e)}", "\n".join(debug_log)
 
 
 # Create Gradio interface