Update cdda_video_extractor.py

cdda_video_extractor.py

@@ -9,32 +9,36 @@ from PIL import Image
 
 # ================= CONFIGURATION =================
 MAX_RES = 1024              # Max pixels for longest side
-# Threshold for detecting change.
-# 2.0 - 5.0 is usually good for gameplay.
-DEFAULT_THRESHOLD = 3.0     
+
+# NEW THRESHOLD LOGIC:
+# This represents the % of the screen that must change to trigger a save.
+# 0.1 = 0.1% of pixels changed (very sensitive but ignores noise).
+# 1.0 = 1% of the screen changed.
+CHANGE_PERCENTAGE_THRESHOLD = 0.05 
+
+# NOISE FLOOR:
+# How much a single pixel's color must change (0-255) to be considered "changed".
+# Video compression usually fluctuates by 5-15. 
+# Setting this to 25 ignores compression artifacts but detects game updates.
+PIXEL_DIFF_THRESHOLD = 25 
 # =================================================
 
 def parse_args():
-    parser = argparse.ArgumentParser(description="Fast extract changed frames from video.")
+    parser = argparse.ArgumentParser(description="Robust extract changed frames from video.")
     parser.add_argument("input_video", help="Path to the video file.")
-    parser.add_argument("--threshold", type=float, default=DEFAULT_THRESHOLD, 
-                        help="Sensitivity (higher = ignores more noise).")
+    parser.add_argument("--threshold", type=float, default=CHANGE_PERCENTAGE_THRESHOLD, 
+                        help="Percentage of screen area that must change (0.1 - 1.0).")
     parser.add_argument("--step", type=int, default=1,
-                        help="Check every Nth frame (e.g. 2 for 2x speed).")
+                        help="Check every Nth frame.")
     parser.add_argument("--start_frame", type=int, default=0,
-                        help="Start processing from this specific frame number.")
+                        help="Start processing from this frame.")
     return parser.parse_args()
 
 def save_frame(cv2_frame, output_path):
-    """
-    Heavy processing: Only runs when a frame is confirmed to be saved.
-    Converts BGR->RGB, Resizes (Lanczos), and Saves.
-    """
-    # Convert BGR (OpenCV) to RGB (PIL)
+    """Heavy processing: Converts BGR->RGB, Resizes (Lanczos), and Saves."""
     rgb_frame = cv2.cvtColor(cv2_frame, cv2.COLOR_BGR2RGB)
     img = Image.fromarray(rgb_frame)
     
-    # Resize logic
     w, h = img.size
     longest = max(w, h)
     if longest > MAX_RES:
@@ -44,6 +48,24 @@ def save_frame(cv2_frame, output_path):
     
     img.save(output_path, "WEBP")
 
+def preprocess_for_comparison(frame):
+    """
+    Prepares a frame for fast, robust comparison:
+    1. Downscale (speed)
+    2. Grayscale (ignore minor color shifts)
+    3. Blur (remove compression noise)
+    """
+    # Downscale drastically for comparison speed (e.g., 320px width)
+    # This also naturally averages out noise.
+    h, w = frame.shape[:2]
+    scale = 320 / w
+    small = cv2.resize(frame, (320, int(h * scale)))
+    
+    gray = cv2.cvtColor(small, cv2.COLOR_BGR2GRAY)
+    # Gaussian Blur is crucial for ignoring video compression grain
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    return blurred
+
 def main():
     args = parse_args()
     
@@ -62,59 +84,59 @@ def main():
     
     print(f"[*] Processing: {args.input_video}")
     print(f"[*] Output: {base_dir}")
+    print(f"[*] Config: Pixel Diff > {PIXEL_DIFF_THRESHOLD}, Area > {args.threshold}%")
 
     cap = cv2.VideoCapture(args.input_video)
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     
-    # Handle Start Frame Seek
     if args.start_frame > 0:
-        if args.start_frame >= total_frames:
-            print(f"[!] Error: Start frame {args.start_frame} is larger than total frames {total_frames}.")
-            return
-        
-        print(f"[*] Jumping to frame {args.start_frame}...")
         cap.set(cv2.CAP_PROP_POS_FRAMES, args.start_frame)
 
-    prev_small_frame = None
-    frame_count = args.start_frame  # Initialize counter to start frame
+    prev_processed_frame = None
+    frame_count = args.start_frame
     saved_count = 0
     
     try:
         while True:
-            # Read frame
             ret, frame = cap.read()
             if not ret:
                 break
 
-            # Skip frames if step > 1
-            # We use modulo on the relative progress to keep step consistent
             if (frame_count - args.start_frame) % args.step != 0:
                 frame_count += 1
                 continue
 
-            # --- FAST PATH: Change Detection ---
-            # 1. Subsample: Take every 4th pixel.
-            curr_small_frame = frame[::4, ::4] 
+            # --- ROBUST PATH: Change Detection ---
+            # Preprocess current frame (Gray -> Blur)
+            curr_processed = preprocess_for_comparison(frame)
 
             has_changed = False
             
-            if prev_small_frame is None:
-                # Always save the first processed frame (whether it's frame 0 or frame 5000)
+            if prev_processed_frame is None:
                 has_changed = True
             else:
-                # 2. Fast Difference Calculation
-                diff_frame = cv2.absdiff(curr_small_frame, prev_small_frame)
-                score = np.mean(diff_frame)
+                # 1. Calculate Absolute Difference
+                diff = cv2.absdiff(curr_processed, prev_processed_frame)
+                
+                # 2. Apply Noise Floor Threshold
+                # Any pixel difference less than PIXEL_DIFF_THRESHOLD (25) becomes 0.
+                # This removes the "shimmering" of black backgrounds in videos.
+                _, thresh = cv2.threshold(diff, PIXEL_DIFF_THRESHOLD, 255, cv2.THRESH_BINARY)
+                
+                # 3. Count Non-Zero Pixels (The pixels that actually changed significantly)
+                changed_pixels = np.count_nonzero(thresh)
+                total_pixels = thresh.size
+                change_percentage = (changed_pixels / total_pixels) * 100
                 
-                if score > args.threshold:
+                # 4. Check against Area Threshold
+                if change_percentage > args.threshold:
                     has_changed = True
 
-            # --- SLOW PATH: Saving ---
+            # --- Saving ---
             if has_changed:
                 filename = f"frame_{frame_count}.webp"
                 filepath = os.path.join(img_dir, filename)
                 
-                # Perform the heavy resize/save only now
                 save_frame(frame, filepath)
                 
                 entry = {
@@ -125,13 +147,11 @@ def main():
                 with open(jsonl_path, 'a') as f:
                     f.write(json.dumps(entry) + "\n")
                 
-                # Update previous comparison frame
-                prev_small_frame = curr_small_frame
+                prev_processed_frame = curr_processed
                 saved_count += 1
 
             frame_count += 1
             
-            # Update terminal
             if frame_count % 100 == 0:
                 sys.stdout.write(f"\r[Processing] Frame: {frame_count}/{total_frames} | Saved: {saved_count}   ")
                 sys.stdout.flush()