Upload 2 files

cdda_video_extractor.py

@@ -9,22 +9,28 @@ from PIL import Image
 
 # ================= CONFIGURATION =================
 MAX_RES = 1024              # Max pixels for longest side
-# Threshold for detecting change. 
-# 0 = Exact match (good for raw screen recording).
-# 5-10 = Good for compressed video (mp4/mkv) to ignore artifacts.
-DEFAULT_THRESHOLD = 5.0     
+# Threshold for detecting change.
+# 2.0 - 5.0 is usually good for gameplay.
+DEFAULT_THRESHOLD = 3.0     
 # =================================================
 
 def parse_args():
-    parser = argparse.ArgumentParser(description="Extract changed frames from CDDA gameplay video.")
-    parser.add_argument("input_video", help="Path to the video file (mp4, mkv, avi, etc.)")
+    parser = argparse.ArgumentParser(description="Fast 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 for change detection (higher = less sensitive to compression noise).")
+                        help="Sensitivity (higher = ignores more noise).")
+    parser.add_argument("--step", type=int, default=1,
+                        help="Check every Nth frame (e.g. 2 for 2x speed).")
+    parser.add_argument("--start_frame", type=int, default=0,
+                        help="Start processing from this specific frame number.")
     return parser.parse_args()
 
-def process_frame(cv2_frame):
-    """Converts BGR (OpenCV) to RGB (PIL) and resizes."""
-    # Convert BGR to RGB
+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)
     rgb_frame = cv2.cvtColor(cv2_frame, cv2.COLOR_BGR2RGB)
     img = Image.fromarray(rgb_frame)
     
@@ -36,17 +42,7 @@ def process_frame(cv2_frame):
         new_size = (int(w * scale), int(h * scale))
         img = img.resize(new_size, Image.Resampling.LANCZOS)
     
-    return img
-
-def calculate_diff(img1_array, img2_array):
-    """Calculates Mean Squared Error between two image arrays."""
-    # Ensure shapes match (resize might cause off-by-one pixel issues rarely, but PIL handles consistent aspect)
-    if img1_array.shape != img2_array.shape:
-        return float('inf')
-    
-    err = np.sum((img1_array.astype("float") - img2_array.astype("float")) ** 2)
-    err /= float(img1_array.shape[0] * img1_array.shape[1])
-    return err
+    img.save(output_path, "WEBP")
 
 def main():
     args = parse_args()
@@ -55,11 +51,9 @@ def main():
         print(f"[!] Error: File '{args.input_video}' not found.")
         return
 
-    # Create output directory structure
-    # extracted_images / video_filename_timestamp / images
+    # Setup Paths
     video_name = os.path.splitext(os.path.basename(args.input_video))[0]
     timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-    
     base_dir = os.path.join(os.getcwd(), "extracted_images", f"{video_name}_{timestamp}")
     img_dir = os.path.join(base_dir, "images")
     jsonl_path = os.path.join(base_dir, "data.jsonl")
@@ -70,44 +64,59 @@ def main():
     print(f"[*] Output: {base_dir}")
 
     cap = cv2.VideoCapture(args.input_video)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     
-    prev_image_array = None
-    frame_count = 0
+    # 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
     saved_count = 0
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     
     try:
         while True:
+            # Read frame
             ret, frame = cap.read()
             if not ret:
                 break
-            
-            # Process current frame
-            pil_img = process_frame(frame)
-            current_array = np.array(pil_img)
-            
+
+            # 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] 
+
             has_changed = False
             
-            if prev_image_array is None:
-                # Always save the first frame
+            if prev_small_frame is None:
+                # Always save the first processed frame (whether it's frame 0 or frame 5000)
                 has_changed = True
             else:
-                # Calculate difference
-                diff = calculate_diff(current_array, prev_image_array)
-                if diff > args.threshold:
+                # 2. Fast Difference Calculation
+                diff_frame = cv2.absdiff(curr_small_frame, prev_small_frame)
+                score = np.mean(diff_frame)
+                
+                if score > args.threshold:
                     has_changed = True
-            
+
+            # --- SLOW PATH: Saving ---
             if has_changed:
                 filename = f"frame_{frame_count}.webp"
                 filepath = os.path.join(img_dir, filename)
                 
-                # Save Image
-                pil_img.save(filepath, "WEBP")
+                # Perform the heavy resize/save only now
+                save_frame(frame, filepath)
                 
-                # Log JSONL
-                # Note: Since this is video, we don't have keypresses. 
-                # We log "None" or skip the keypress field. 
-                # The merger script handles "None" automatically.
                 entry = {
                     "image": filename,
                     "original_frame_id": frame_count
@@ -116,21 +125,22 @@ def main():
                 with open(jsonl_path, 'a') as f:
                     f.write(json.dumps(entry) + "\n")
                 
-                prev_image_array = current_array
+                # Update previous comparison frame
+                prev_small_frame = curr_small_frame
                 saved_count += 1
-            
+
             frame_count += 1
             
-            # Progress update
-            if frame_count % 10 == 0:
-                sys.stdout.write(f"\r[Processing] Frame: {frame_count}/{total_frames} | Extracted: {saved_count}   ")
+            # Update terminal
+            if frame_count % 100 == 0:
+                sys.stdout.write(f"\r[Processing] Frame: {frame_count}/{total_frames} | Saved: {saved_count}   ")
                 sys.stdout.flush()
 
     except KeyboardInterrupt:
-        print("\n[!] Interrupted by user.")
+        print("\n[!] Interrupted.")
     finally:
         cap.release()
-        print(f"\n[*] Done. Extracted {saved_count} frames to {base_dir}")
+        print(f"\n[*] Done. Extracted {saved_count} frames.")
 
 if __name__ == "__main__":
     main()

cleanup_dataset.py

@@ -0,0 +1,82 @@
+import os
+import json
+import argparse
+
+def clean_jsonl(jsonl_path):
+    """
+    Reads a jsonl file, checks if referenced images exist, 
+    and rewrites the file without the missing entries.
+    """
+    base_dir = os.path.dirname(jsonl_path)
+    img_dir = os.path.join(base_dir, "images")
+    
+    if not os.path.exists(img_dir):
+        print(f"[!] Skipping {base_dir}: 'images' folder not found.")
+        return
+
+    # Read all lines
+    with open(jsonl_path, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+
+    valid_lines = []
+    removed_count = 0
+    total_count = len(lines)
+
+    for line in lines:
+        if not line.strip():
+            continue
+            
+        try:
+            entry = json.loads(line)
+            image_name = entry.get("image")
+            
+            if image_name:
+                image_path = os.path.join(img_dir, image_name)
+                
+                # THE CORE CHECK: Does the file exist?
+                if os.path.exists(image_path):
+                    valid_lines.append(line)
+                else:
+                    removed_count += 1
+            else:
+                # If entry has no "image" field, decide to keep or drop.
+                # For this dataset format, we drop it.
+                removed_count += 1
+                
+        except json.JSONDecodeError:
+            removed_count += 1
+
+    # Only rewrite if we actually removed something
+    if removed_count > 0:
+        with open(jsonl_path, 'w', encoding='utf-8') as f:
+            f.writelines(valid_lines)
+        print(f"[✓] Cleaned {jsonl_path}")
+        print(f"    - Total Lines: {total_count}")
+        print(f"    - Removed:     {removed_count}")
+        print(f"    - Remaining:   {len(valid_lines)}")
+    else:
+        print(f"[.] No changes needed for {jsonl_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Remove JSONL lines pointing to missing images.")
+    parser.add_argument("dir", default=".", help="Root directory to scan (default: current dir).")
+    args = parser.parse_args()
+
+    print(f"[*] Scanning for data.jsonl files in '{args.dir}'...")
+    
+    found_files = 0
+    
+    # Walk through all directories recursively
+    for root, dirs, files in os.walk(args.dir):
+        if "data.jsonl" in files:
+            found_files += 1
+            full_path = os.path.join(root, "data.jsonl")
+            clean_jsonl(full_path)
+
+    if found_files == 0:
+        print("[!] No 'data.jsonl' files found.")
+    else:
+        print("\n[*] Cleanup complete.")
+
+if __name__ == "__main__":
+    main()