media-engine 0.1.0__py3-none-any.whl

cli/clip.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Extract CLIP embeddings from video file."""
+
+import argparse
+import json
+import logging
+import sys
+import time
+
+from media_engine.extractors import (
+    analyze_motion,
+    decode_frames,
+    extract_clip,
+    get_adaptive_timestamps,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract CLIP embeddings from video")
+    parser.add_argument("file", help="Path to video file")
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=None,
+        help="CLIP model name (e.g., ViT-B-32, ViT-L-14)",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    try:
+        start_time = time.perf_counter()
+
+        # Run motion analysis to get adaptive timestamps
+        motion = analyze_motion(args.file)
+        timestamps = get_adaptive_timestamps(motion)
+
+        # Decode frames once using shared buffer
+        frame_buffer = decode_frames(args.file, timestamps=timestamps)
+
+        # Extract CLIP embeddings using shared frame buffer
+        result = extract_clip(
+            args.file,
+            frame_buffer=frame_buffer,
+            model_name=args.model,
+        )
+        elapsed = time.perf_counter() - start_time
+
+        if args.json:
+            output = result.model_dump()
+            output["elapsed_seconds"] = round(elapsed, 2)
+            print(json.dumps(output, indent=2, default=str))
+        else:
+            print(f"File: {args.file}")
+            print(f"Model: {result.model}")
+            print(f"Segments: {len(result.segments)}")
+            if result.segments:
+                print(f"Embedding dimensions: {len(result.segments[0].embedding)}")
+            print()
+            for i, seg in enumerate(result.segments[:10], 1):  # Show first 10
+                print(f"  {i}: {seg.start:.2f}s-{seg.end:.2f}s embedding[{len(seg.embedding)}]")
+            if len(result.segments) > 10:
+                print(f"  ... and {len(result.segments) - 10} more")
+            print()
+            print(f"Elapsed: {elapsed:.2f}s")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cli/faces.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Detect faces in video file."""
+
+import argparse
+import json
+import logging
+import sys
+import time
+
+from media_engine.extractors import (
+    analyze_motion,
+    decode_frames,
+    extract_faces,
+    get_adaptive_timestamps,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Detect faces in video file")
+    parser.add_argument("file", help="Path to video file")
+    parser.add_argument(
+        "--sample-fps",
+        type=float,
+        default=1.0,
+        help="Sample rate for face detection (default: 1.0)",
+    )
+    parser.add_argument(
+        "--min-face-size",
+        type=int,
+        default=80,
+        help="Minimum face size in pixels (default: 80)",
+    )
+    parser.add_argument(
+        "--min-confidence",
+        type=float,
+        default=0.5,
+        help="Minimum detection confidence (default: 0.5)",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    try:
+        start_time = time.perf_counter()
+
+        # Run motion analysis to get adaptive timestamps
+        motion = analyze_motion(args.file)
+        timestamps = get_adaptive_timestamps(motion)
+
+        # Decode frames once using shared buffer
+        frame_buffer = decode_frames(args.file, timestamps=timestamps)
+
+        # Extract faces using shared frame buffer
+        result = extract_faces(
+            args.file,
+            frame_buffer=frame_buffer,
+            min_face_size=args.min_face_size,
+            min_confidence=args.min_confidence,
+        )
+        elapsed = time.perf_counter() - start_time
+
+        if args.json:
+            output = result.model_dump()
+            output["elapsed_seconds"] = round(elapsed, 2)
+            print(json.dumps(output, indent=2, default=str))
+        else:
+            print(f"File: {args.file}")
+            print(f"Faces detected: {result.count}")
+            print(f"Unique estimate: {result.unique_estimate}")
+            print()
+            for i, face in enumerate(result.detections[:20], 1):  # Show first 20
+                bbox = face.bbox
+                print(f"  {i}: t={face.timestamp:.2f}s " f"box=({bbox.x},{bbox.y},{bbox.width}x{bbox.height}) " f"conf={face.confidence:.2f}")
+            if result.count > 20:
+                print(f"  ... and {result.count - 20} more")
+            print()
+            print(f"Elapsed: {elapsed:.2f}s")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cli/metadata.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""Extract metadata from video file."""
+
+import argparse
+import json
+import logging
+import sys
+import time
+
+from media_engine.extractors import extract_metadata
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract metadata from video file")
+    parser.add_argument("file", help="Path to video file")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON (default: human-readable)")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    try:
+        start_time = time.perf_counter()
+        result = extract_metadata(args.file)
+        elapsed = time.perf_counter() - start_time
+
+        if args.json:
+            output = result.model_dump()
+            output["elapsed_seconds"] = round(elapsed, 2)
+            print(json.dumps(output, indent=2, default=str))
+        else:
+            print(f"File: {args.file}")
+            print(f"Duration: {result.duration}s")
+            print(f"Resolution: {result.resolution.width}x{result.resolution.height}")
+            print(f"FPS: {result.fps}")
+            if result.video_codec:
+                print(f"Codec: {result.video_codec.name}")
+            if result.device:
+                print(f"Device: {result.device.make} {result.device.model}")
+            if result.gps:
+                print(f"GPS: {result.gps.latitude}, {result.gps.longitude}")
+            if result.gps_track:
+                track = result.gps_track
+                bounds = track.bounds
+                if bounds:
+                    lat_range = bounds["max_lat"] - bounds["min_lat"]
+                    lon_range = bounds["max_lon"] - bounds["min_lon"]
+                    print(f"GPS Track: {track.count} points (lat range: {lat_range:.6f}, lon range: {lon_range:.6f})")
+            if result.shot_type:
+                print(f"Shot type: {result.shot_type.primary} ({result.shot_type.confidence:.2f})")
+            if result.keyframes:
+                kf = result.keyframes
+                interval_type = "fixed GOP" if kf.is_fixed_interval else "irregular (likely cuts)"
+                print(f"Keyframes: {kf.count} ({interval_type}, avg {kf.avg_interval}s)")
+            print()
+            print(f"Elapsed: {elapsed:.2f}s")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cli/motion.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Analyze camera motion in video file."""
+
+import argparse
+import json
+import logging
+import sys
+import time
+
+from media_engine.extractors import analyze_motion
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyze camera motion in video")
+    parser.add_argument("file", help="Path to video file")
+    parser.add_argument(
+        "--sample-fps",
+        type=float,
+        default=2.0,
+        help="Sample rate for motion analysis (default: 2.0)",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    try:
+        start_time = time.perf_counter()
+        result = analyze_motion(args.file, sample_fps=args.sample_fps)
+        elapsed = time.perf_counter() - start_time
+
+        if args.json:
+            data = {
+                "duration": result.duration,
+                "fps": result.fps,
+                "primary_motion": result.primary_motion.value,
+                "avg_intensity": float(result.avg_intensity),
+                "is_stable": result.is_stable,
+                "segments": [
+                    {
+                        "start": s.start,
+                        "end": s.end,
+                        "motion_type": s.motion_type.value,
+                        "intensity": float(s.intensity),
+                    }
+                    for s in result.segments
+                ],
+                "elapsed_seconds": round(elapsed, 2),
+            }
+            print(json.dumps(data, indent=2))
+        else:
+            print(f"File: {args.file}")
+            print(f"Duration: {result.duration:.2f}s")
+            print(f"Primary motion: {result.primary_motion.value}")
+            print(f"Avg intensity: {result.avg_intensity:.2f}")
+            print(f"Stable: {result.is_stable}")
+            print(f"Segments: {len(result.segments)}")
+            print()
+            for i, seg in enumerate(result.segments[:10], 1):  # Show first 10
+                print(f"  {i}: {seg.start:.2f}s-{seg.end:.2f}s " f"{seg.motion_type.value} (intensity: {seg.intensity:.2f})")
+            if len(result.segments) > 10:
+                print(f"  ... and {len(result.segments) - 10} more")
+            print()
+            print(f"Elapsed: {elapsed:.2f}s")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cli/objects.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Detect objects in video file."""
+
+import argparse
+import json
+import logging
+import sys
+import time
+
+from media_engine.extractors import (
+    analyze_motion,
+    decode_frames,
+    extract_objects,
+    extract_objects_qwen,
+    get_adaptive_timestamps,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Detect objects in video file")
+    parser.add_argument("file", help="Path to video file")
+    parser.add_argument(
+        "--detector",
+        type=str,
+        default="yolo",
+        choices=["yolo", "qwen"],
+        help="Object detector to use (default: yolo)",
+    )
+    parser.add_argument(
+        "--sample-fps",
+        type=float,
+        default=2.0,
+        help="Sample rate for YOLO detection (default: 2.0)",
+    )
+    parser.add_argument(
+        "--min-confidence",
+        type=float,
+        default=0.5,
+        help="Minimum detection confidence (default: 0.5)",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    try:
+        start_time = time.perf_counter()
+        if args.detector == "qwen":
+            result = extract_objects_qwen(args.file)
+        else:
+            # Run motion analysis to get adaptive timestamps
+            motion = analyze_motion(args.file)
+            timestamps = get_adaptive_timestamps(motion)
+
+            # Decode frames once using shared buffer
+            frame_buffer = decode_frames(args.file, timestamps=timestamps)
+
+            # Extract objects using shared frame buffer
+            result = extract_objects(
+                args.file,
+                frame_buffer=frame_buffer,
+                min_confidence=args.min_confidence,
+            )
+        elapsed = time.perf_counter() - start_time
+
+        if args.json:
+            output = result.model_dump()
+            output["elapsed_seconds"] = round(elapsed, 2)
+            print(json.dumps(output, indent=2, default=str))
+        else:
+            print(f"File: {args.file}")
+            print(f"Detector: {args.detector}")
+            print(f"Detections: {len(result.detections)}")
+            print()
+            print("Summary:")
+            for label, count in sorted(result.summary.items(), key=lambda x: x[1], reverse=True)[:15]:
+                print(f"  {label}: {count}")
+            if len(result.summary) > 15:
+                print(f"  ... and {len(result.summary) - 15} more types")
+            print()
+            print(f"Elapsed: {elapsed:.2f}s")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cli/ocr.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Extract text (OCR) from video file."""
+
+import argparse
+import json
+import logging
+import sys
+import time
+
+from media_engine.extractors import (
+    analyze_motion,
+    decode_frames,
+    extract_ocr,
+    get_adaptive_timestamps,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract text (OCR) from video file")
+    parser.add_argument("file", help="Path to video file")
+    parser.add_argument(
+        "--min-confidence",
+        type=float,
+        default=0.5,
+        help="Minimum detection confidence (default: 0.5)",
+    )
+    parser.add_argument(
+        "--skip-prefilter",
+        action="store_true",
+        help="Skip MSER pre-filter (run OCR on all frames)",
+    )
+    parser.add_argument(
+        "--languages",
+        type=str,
+        default=None,
+        help="OCR languages, comma-separated (e.g., 'en,no,de')",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    languages = None
+    if args.languages:
+        languages = [lang.strip() for lang in args.languages.split(",")]
+
+    try:
+        start_time = time.perf_counter()
+
+        # Run motion analysis to get adaptive timestamps
+        motion = analyze_motion(args.file)
+        timestamps = get_adaptive_timestamps(motion)
+
+        # Decode frames once using shared buffer
+        frame_buffer = decode_frames(args.file, timestamps=timestamps)
+
+        # Extract OCR using shared frame buffer
+        result = extract_ocr(
+            args.file,
+            frame_buffer=frame_buffer,
+            min_confidence=args.min_confidence,
+            skip_prefilter=args.skip_prefilter,
+            languages=languages,
+        )
+        elapsed = time.perf_counter() - start_time
+
+        if args.json:
+            output = result.model_dump()
+            output["elapsed_seconds"] = round(elapsed, 2)
+            print(json.dumps(output, indent=2, default=str))
+        else:
+            print(f"File: {args.file}")
+            print(f"Text regions detected: {len(result.detections)}")
+            print()
+            for i, det in enumerate(result.detections[:20], 1):  # Show first 20
+                print(f'  {i}: t={det.timestamp:.2f}s "{det.text}" (conf={det.confidence:.2f})')
+            if len(result.detections) > 20:
+                print(f"  ... and {len(result.detections) - 20} more")
+            print()
+            print(f"Elapsed: {elapsed:.2f}s")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cli/scenes.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Detect scene boundaries in video file."""
+
+import argparse
+import json
+import logging
+import sys
+import time
+
+from media_engine.extractors import extract_scenes
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Detect scene boundaries in video")
+    parser.add_argument("file", help="Path to video file")
+    parser.add_argument(
+        "--threshold",
+        type=float,
+        default=27.0,
+        help="Content detection threshold (lower=more sensitive, default: 27.0)",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    try:
+        start_time = time.perf_counter()
+        result = extract_scenes(args.file, threshold=args.threshold)
+        elapsed = time.perf_counter() - start_time
+
+        if args.json:
+            output = result.model_dump()
+            output["elapsed_seconds"] = round(elapsed, 2)
+            print(json.dumps(output, indent=2, default=str))
+        else:
+            print(f"File: {args.file}")
+            print(f"Scenes detected: {result.count}")
+            print()
+            for i, scene in enumerate(result.detections, 1):
+                duration = scene.end - scene.start
+                print(f"  Scene {i}: {scene.start:.2f}s - {scene.end:.2f}s ({duration:.2f}s)")
+            print()
+            print(f"Elapsed: {elapsed:.2f}s")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cli/telemetry.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""Extract telemetry (GPS/flight data) from video file."""
+
+import argparse
+import json
+import logging
+import sys
+import time
+
+from media_engine.extractors import extract_telemetry
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract telemetry from video file")
+    parser.add_argument("file", help="Path to video file")
+    parser.add_argument(
+        "--gpx",
+        action="store_true",
+        help="Output as GPX format instead of JSON",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    try:
+        start_time = time.perf_counter()
+        result = extract_telemetry(args.file)
+        elapsed = time.perf_counter() - start_time
+
+        if result is None:
+            print("No telemetry data found", file=sys.stderr)
+            sys.exit(0)
+
+        if args.gpx:
+            print(result.to_gpx())
+        elif args.json:
+            output = result.model_dump()
+            output["elapsed_seconds"] = round(elapsed, 2)
+            print(json.dumps(output, indent=2, default=str))
+        else:
+            print(f"File: {args.file}")
+            print(f"Source: {result.source}")
+            print(f"Points: {len(result.points)}")
+            print()
+            for i, pt in enumerate(result.points[:10], 1):  # Show first 10
+                alt = f" alt={pt.altitude:.1f}m" if pt.altitude else ""
+                print(f"  {i}: ({pt.latitude:.6f}, {pt.longitude:.6f}){alt}")
+            if len(result.points) > 10:
+                print(f"  ... and {len(result.points) - 10} more")
+            print()
+            print(f"Elapsed: {elapsed:.2f}s")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()