Update services/video_service.py

services/video_service.py

@@ -9,79 +9,98 @@ logging.basicConfig(
     format="%(asctime)s - %(levelname)s - %(message)s"
 )
 
-# Global video capture object
-video_cap = None
-current_frame_index = 0
+# Global state
+VIDEO_DIR = "data"
+video_files = []
+video_index = 0
+cap = None
+FRAME_SKIP = 3
+PRELOADED_FRAMES = []
 
-def preload_video(video_path):
-    """
-    Preload the video file.
-    Args:
-        video_path: Path to the video file
-    Returns:
-        str: Status message
-    """
-    global video_cap, current_frame_index
-    try:
-        if not os.path.exists(video_path):
-            raise FileNotFoundError(f"Video file not found at {video_path}")
+def update_video_files(video_path: str = None):
+    global video_files
+    if video_path and os.path.exists(video_path) and video_path.endswith((".mp4", ".avi")):
+        video_files = [video_path]
+    else:
+        if os.path.exists(VIDEO_DIR):
+            video_files = [
+                os.path.join(VIDEO_DIR, file)
+                for file in sorted(os.listdir(VIDEO_DIR))
+                if file.endswith((".mp4", ".avi"))
+            ]
+        else:
+            video_files = []
+    if not video_files:
+        logging.warning("No video files found.")
+    else:
+        logging.info(f"Found video files: {video_files}")
 
-        video_cap = cv2.VideoCapture(video_path)
-        if not video_cap.isOpened():
-            raise RuntimeError("Failed to open video file.")
+def preload_video(video_path: str = None):
+    global cap, video_index, PRELOADED_FRAMES, video_files
+    update_video_files(video_path)
+    if not video_files:
+        logging.error("No video files available to preload.")
+        raise RuntimeError("No video files found in the 'data' directory or provided path.")
 
-        current_frame_index = 0
-        total_frames = int(video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        logging.info(f"Preloaded video: {video_path} with {total_frames} frames.")
-        return f"Successfully loaded video: {video_path} ({total_frames} frames)"
+    try:
+        video_index = 0
+        cap = cv2.VideoCapture(video_files[video_index])
+        if not cap.isOpened():
+            raise RuntimeError(f"Failed to open video {video_files[video_index]}")
+        PRELOADED_FRAMES = []
+        for _ in range(5):
+            ret, frame = cap.read()
+            if ret:
+                frame = cv2.resize(frame, (320, 240))
+                PRELOADED_FRAMES.append(frame)
+            else:
+                break
+        cap.release()
+        cap = None
+        logging.info(f"Preloaded {len(PRELOADED_FRAMES)} frames from {video_files[video_index]}")
     except Exception as e:
         logging.error(f"Error preloading video: {str(e)}")
-        return f"Error loading video: {str(e)}"
+        raise RuntimeError(f"Failed to preload video: {str(e)}")
 
 def get_next_video_frame():
-    """
-    Get the next frame from the video.
-    Returns:
-        numpy array: Frame if successful, None otherwise
-    """
-    global video_cap, current_frame_index
-    if video_cap is None or not video_cap.isOpened():
-        logging.error("Video capture not initialized.")
-        return None
+    global cap, video_index, PRELOADED_FRAMES
+    if not video_files:
+        raise RuntimeError("No video files found.")
+    
+    if PRELOADED_FRAMES:
+        frame = PRELOADED_FRAMES.pop(0)
+        logging.debug(f"Retrieved preloaded frame {len(PRELOADED_FRAMES) + 1}")
+        return frame
+
+    if cap is None or not cap.isOpened():
+        cap = cv2.VideoCapture(video_files[video_index])
 
     try:
-        # Set frame position
-        video_cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame_index)
-        ret, frame = video_cap.read()
-        if not ret:
-            # Loop back to the start
-            current_frame_index = 0
-            video_cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame_index)
-            ret, frame = video_cap.read()
+        for _ in range(FRAME_SKIP):
+            ret, frame = cap.read()
             if not ret:
-                raise RuntimeError("Failed to read frame from video.")
-
-        current_frame_index += 1
-        logging.debug(f"Retrieved frame {current_frame_index} from video.")
+                cap.release()
+                video_index = (video_index + 1) % len(video_files)
+                cap = cv2.VideoCapture(video_files[video_index])
+                ret, frame = cap.read()
+                if not ret:
+                    raise RuntimeError(f"Cannot read video {video_files[video_index]}")
+                break
+        frame = cv2.resize(frame, (320, 240))
+        logging.debug(f"Retrieved frame from {video_files[video_index]}")
         return frame
     except Exception as e:
         logging.error(f"Error retrieving frame: {str(e)}")
-        return None
+        raise RuntimeError(f"Failed to retrieve frame: {str(e)}")
 
 def reset_video_index():
-    """
-    Reset the frame index to the beginning.
-    """
-    global current_frame_index
-    current_frame_index = 0
-    logging.info("Reset video frame index to 0.")
+    global video_index
+    video_index = 0
+    logging.info("Reset video index to 0.")
 
 def release_video():
-    """
-    Release the video capture object.
-    """
-    global video_cap
-    if video_cap is not None:
-        video_cap.release()
-        video_cap = None
+    global cap
+    if cap is not None:
+        cap.release()
+        cap = None
         logging.info("Released video capture object.")