added additional files

old/scene_detector_old.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+import subprocess
+import json
+import os
+import sys
+import argparse
+
+def get_best_hwaccel():
+    """
+    Checks for available FFmpeg hardware acceleration methods and returns the best one.
+    Priority is defined as: cuda > qsv > dxva2.
+    Returns the name of the best available method, or None if none are found.
+    """
+    priority = ['cuda', 'qsv', 'dxva2']
+    print("Checking for available hardware acceleration...")
+    try:
+        # Run ffmpeg to list available hardware acceleration methods
+        result = subprocess.run(
+            ['ffmpeg', '-hide_banner', '-hwaccels'],
+            capture_output=True, text=True, encoding='utf-8', check=False
+        )
+        
+        if result.returncode != 0:
+            print("Warning: Could not query FFmpeg for hardware acceleration. Using software decoding.")
+            return None
+
+        # Parse the output to get a list of available methods
+        available_methods = result.stdout.strip().split('\n')
+        if len(available_methods) > 1:
+            available_methods = available_methods[1:]
+
+        # Check for our preferred methods in order of priority
+        for method in priority:
+            if method in available_methods:
+                print(f"Found best available hardware acceleration: {method}")
+                return method
+        
+        print("No high-priority hardware acceleration (cuda, qsv, dxva2) found. Using software decoding.")
+        return None
+
+    except FileNotFoundError:
+        # This will be handled by the main ffmpeg call later, so we just return None.
+        return None
+    except Exception as e:
+        print(f"Warning: An error occurred while checking for hwaccel: {e}. Using software decoding.")
+        return None
+
+def detect_scenes(video_path, hwaccel=None, threshold=0.4):
+    """
+    Uses FFmpeg to detect scene changes in a video and saves the timestamps to a JSON file.
+    """
+    print(f"Starting scene detection for: {os.path.basename(video_path)}")
+    
+    # Define the output JSON file path based on the input video name
+    base_name = os.path.splitext(video_path)[0]
+    json_output_path = f"{base_name}.scenes.json"
+
+    # Base FFmpeg command
+    command = ['ffmpeg', '-hide_banner']
+
+    # If hardware acceleration is specified, add the relevant flags
+    if hwaccel:
+        print(f"Attempting to use hardware acceleration: {hwaccel}")
+        command.extend(['-hwaccel', hwaccel])
+
+    # Add the rest of the command arguments
+    # The filter string is now built dynamically with the specified threshold
+    filter_string = f"select='gt(scene,{threshold})',showinfo"
+    command.extend([
+        '-i', video_path,
+        '-vf', filter_string,
+        '-f', 'null',
+        '-'
+    ])
+
+    # Execute the FFmpeg command
+    try:
+        # Use Popen to start the process and read its output in real-time
+        process = subprocess.Popen(command, stderr=subprocess.PIPE, text=True, encoding='utf-8')
+
+        scene_timestamps = []
+        
+        # Read stderr line by line as it's produced
+        for line in iter(process.stderr.readline, ''):
+            # Check for scene detection output (which contains pts_time)
+            if 'pts_time:' in line:
+                timestamp_str = line.split('pts_time:')[1].split()[0]
+                scene_timestamps.append(float(timestamp_str))
+            # Check for ffmpeg's progress line (which starts with 'frame=')
+            # and print it to the actual stderr to show progress
+            elif line.strip().startswith('frame='):
+                # Use sys.stderr to avoid interfering with stdout prints
+                # Use '\r' to have the line overwrite itself, mimicking ffmpeg's behavior
+                sys.stderr.write(f'\r{line.strip()}')
+                sys.stderr.flush()
+
+        # Wait for the process to finish and get the return code
+        process.wait()
+        
+        # Print a newline to move past the progress bar
+        sys.stderr.write('\n')
+        sys.stderr.flush()
+
+        if process.returncode != 0:
+            print(f"\nWarning: FFmpeg may have encountered an error (exit code: {process.returncode}).")
+
+        if not scene_timestamps:
+            print("Warning: No scenes were detected. The output file will be empty.")
+
+        # Save the detected scenes to a JSON file
+        with open(json_output_path, 'w') as json_file:
+            json.dump(scene_timestamps, json_file, indent=4)
+
+        print(f"Scene detection completed. {len(scene_timestamps)} scenes found.")
+        print(f"Results saved to: {json_output_path}")
+
+    except FileNotFoundError:
+        print("Error: 'ffmpeg' command not found. Is it installed and in your system's PATH?")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+def main():
+    """
+    Main function to handle command-line arguments.
+    """
+    parser = argparse.ArgumentParser(description="Detect scene changes in a video using FFmpeg.")
+    parser.add_argument("video_path", help="Path to the video file.")
+    parser.add_argument(
+        "-t", "--threshold",
+        type=float,
+        default=0.4,
+        help="Set the scene detection threshold (0.0 to 1.0). Lower is more sensitive. Default: 0.4"
+    )
+    
+    args = parser.parse_args()
+
+    if not os.path.isfile(args.video_path):
+        print(f"Error: Input file not found: '{args.video_path}'")
+        sys.exit(1)
+        
+    # Automatically determine the best hardware acceleration method
+    hwaccel_method = get_best_hwaccel()
+    
+    detect_scenes(args.video_path, hwaccel_method, args.threshold)
+
+if __name__ == "__main__":
+    main()