media-engine 0.1.0__py3-none-any.whl

media_engine/extractors/metadata/sony.py

@@ -0,0 +1,442 @@
+"""Sony metadata extraction.
+
+Handles Sony cameras:
+- Professional: FX6, FX3, FX9, Venice
+- Alpha series: A7S, A7R, A1, etc.
+- Consumer: ZV-1, ZV-E1, etc.
+- AVCHD camcorders: HXR-NX5, HDR-CX series, etc.
+- XDCAM: PMW-EX1, PMW-EX3, PMW-200, etc.
+
+Detection methods:
+- make tag: "Sony"
+- major_brand: "XAVC"
+- XML sidecar files (M01.XML pattern)
+- Embedded XML in com.sony.bprl.mxf.nrtmetadata tag (XDCAM)
+- AVCHD structure with embedded GPS in H.264 SEI
+
+Sony XML sidecar files contain:
+- Device info (manufacturer, modelName)
+- GPS coordinates (ExifGPS group)
+- Color space (CaptureGammaEquation, CaptureColorPrimaries)
+- Lens info (FocalLength, FNumber, etc.)
+"""
+
+import logging
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Any
+
+from media_engine.schemas import (
+    GPS,
+    ColorSpace,
+    DetectionMethod,
+    DeviceInfo,
+    LensInfo,
+    MediaDeviceType,
+    Metadata,
+    SpannedRecording,
+)
+
+from .avchd import get_recording_for_file
+from .avchd_gps import extract_avchd_gps, extract_avchd_gps_track
+from .base import SidecarMetadata, parse_dms_coordinate
+from .registry import get_tags_lower, register_extractor
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_xml_sidecar(video_path: str) -> SidecarMetadata | None:
+    """Parse Sony XML sidecar file for additional metadata.
+
+    Sony cameras create XML sidecar files with naming pattern:
+    - Video: 20251014_C0476.MP4
+    - XML:   20251014_C0476M01.XML
+    """
+    path = Path(video_path)
+
+    xml_patterns = [
+        path.with_suffix(".XML"),
+        path.parent / f"{path.stem}M01.XML",
+        path.parent / f"{path.stem}M01.xml",
+    ]
+
+    xml_path = None
+    for pattern in xml_patterns:
+        if pattern.exists():
+            xml_path = pattern
+            break
+
+    if not xml_path:
+        return None
+
+    try:
+        tree = ET.parse(xml_path)
+        root = tree.getroot()
+
+        ns = {"nrt": "urn:schemas-professionalDisc:nonRealTimeMeta:ver.2.20"}
+
+        device: DeviceInfo | None = None
+        gps: GPS | None = None
+        color_space: ColorSpace | None = None
+        lens: LensInfo | None = None
+
+        # Extract device info
+        device_elem = root.find(".//nrt:Device", ns) or root.find(".//{*}Device")
+        if device_elem is not None:
+            manufacturer = device_elem.get("manufacturer")
+            model_name = device_elem.get("modelName")
+
+            if manufacturer or model_name:
+                device = DeviceInfo(
+                    make=manufacturer,
+                    model=model_name,
+                    software=None,
+                    type=MediaDeviceType.CAMERA,
+                    detection_method=DetectionMethod.XML_SIDECAR,
+                    confidence=1.0,
+                )
+
+        # Extract GPS from ExifGPS or GPSinExif group (different Sony models use different names)
+        gps_group = root.find(".//{*}Group[@name='ExifGPS']")
+        if gps_group is None:
+            gps_group = root.find(".//{*}Group[@name='GPSinExif']")
+        if gps_group is not None:
+            gps_items: dict[str, str | None] = {}
+            for item in gps_group.findall(".//{*}Item"):
+                name = item.get("name")
+                if name is not None:
+                    gps_items[name] = item.get("value")
+
+            if gps_items.get("Status") != "V":
+                lat_str = gps_items.get("Latitude")
+                lon_str = gps_items.get("Longitude")
+                lat_ref = gps_items.get("LatitudeRef")
+                lon_ref = gps_items.get("LongitudeRef")
+                alt_str = gps_items.get("Altitude")
+
+                if lat_str and lon_str:
+                    lat = parse_dms_coordinate(lat_str, lat_ref)
+                    lon = parse_dms_coordinate(lon_str, lon_ref)
+
+                    if lat is not None and lon is not None:
+                        try:
+                            gps = GPS(
+                                latitude=lat,
+                                longitude=lon,
+                                altitude=float(alt_str) if alt_str else None,
+                            )
+                        except ValueError:
+                            pass
+
+        # Extract color space
+        color_items: dict[str, str | None] = {}
+        for group_name in ["CameraUnitMetadata", "VideoLayout", "AcquisitionRecord"]:
+            group = root.find(f".//*[@name='{group_name}']")
+            if group is not None:
+                for item in group.findall(".//{*}Item"):
+                    name = item.get("name")
+                    if name:
+                        color_items[name] = item.get("value")
+
+        for item in root.findall(".//{*}Item"):
+            name = item.get("name")
+            if name and name in [
+                "CaptureGammaEquation",
+                "CaptureColorPrimaries",
+                "CodingEquations",
+            ]:
+                color_items[name] = item.get("value")
+
+        lut_file: str | None = None
+        for related in root.findall(".//{*}RelatedTo"):
+            if related.get("rel") == "LUT":
+                lut_file = related.get("file")
+                break
+
+        gamma = color_items.get("CaptureGammaEquation")
+        primaries = color_items.get("CaptureColorPrimaries")
+        coding = color_items.get("CodingEquations")
+
+        if gamma or primaries or coding or lut_file:
+            color_space = ColorSpace(
+                transfer=gamma,
+                primaries=primaries,
+                matrix=coding,
+                lut_file=lut_file,
+                detection_method=DetectionMethod.XML_SIDECAR,
+            )
+
+        # Extract lens info
+        lens_items: dict[str, str | None] = {}
+        for group_name in ["Camera", "Lens", "CameraUnitMetadata"]:
+            group = root.find(f".//*[@name='{group_name}']")
+            if group is not None:
+                for item in group.findall(".//{*}Item"):
+                    name = item.get("name")
+                    if name:
+                        lens_items[name] = item.get("value")
+
+        for item in root.findall(".//{*}Item"):
+            name = item.get("name")
+            if name and name in [
+                "FocalLength",
+                "FocalLength35mm",
+                "FocalLengthIn35mmFilm",
+                "FNumber",
+                "Iris",
+                "FocusDistance",
+            ]:
+                lens_items[name] = item.get("value")
+
+        focal_length = lens_items.get("FocalLength")
+        focal_35mm = lens_items.get("FocalLength35mm") or lens_items.get("FocalLengthIn35mmFilm")
+        f_number = lens_items.get("FNumber")
+        iris = lens_items.get("Iris")
+        focus_dist = lens_items.get("FocusDistance")
+
+        if focal_length or focal_35mm or f_number or iris:
+            lens = LensInfo(
+                focal_length=float(focal_length) if focal_length else None,
+                focal_length_35mm=float(focal_35mm) if focal_35mm else None,
+                aperture=float(f_number) if f_number else None,
+                focus_distance=float(focus_dist) if focus_dist else None,
+                iris=iris,
+                detection_method=DetectionMethod.XML_SIDECAR,
+            )
+
+        if device or gps or color_space or lens:
+            return SidecarMetadata(device=device, gps=gps, color_space=color_space, lens=lens)
+        return None
+
+    except ET.ParseError as e:
+        logger.warning(f"Failed to parse Sony XML sidecar {xml_path}: {e}")
+        return None
+    except Exception as e:
+        logger.warning(f"Error reading Sony XML sidecar {xml_path}: {e}")
+        return None
+
+
+def _parse_embedded_xml(probe_data: dict[str, Any]) -> SidecarMetadata | None:
+    """Parse embedded XML from Sony XDCAM com.sony.bprl.mxf.nrtmetadata tag.
+
+    XDCAM cameras (PMW-EX1, PMW-EX3, etc.) embed metadata as XML in the
+    format tags. Example:
+        <Device manufacturer="Sony" modelName="PMW-EX1" serialNo="0404626"/>
+        <Lens modelName="XT14X5.8"/>
+    """
+    format_tags = probe_data.get("format", {}).get("tags", {})
+
+    # Check for Sony XDCAM embedded metadata tag
+    nrt_metadata = format_tags.get("com.sony.bprl.mxf.nrtmetadata")
+    if not nrt_metadata:
+        return None
+
+    try:
+        # The metadata may be a fragment without root element, wrap it
+        xml_content = nrt_metadata.strip()
+        if not xml_content.startswith("<?xml"):
+            xml_content = f"<root>{xml_content}</root>"
+
+        root = ET.fromstring(xml_content)
+
+        device: DeviceInfo | None = None
+        lens: LensInfo | None = None
+
+        # Extract device info (use {*} wildcard for namespace handling)
+        device_elem = root.find(".//{*}Device")
+        if device_elem is not None:
+            manufacturer = device_elem.get("manufacturer")
+            model_name = device_elem.get("modelName")
+            serial_no = device_elem.get("serialNo")
+
+            if manufacturer or model_name:
+                device = DeviceInfo(
+                    make=manufacturer,
+                    model=model_name,
+                    serial_number=serial_no,
+                    type=MediaDeviceType.CAMERA,
+                    detection_method=DetectionMethod.METADATA,
+                    confidence=1.0,
+                )
+                logger.info(f"Extracted XDCAM device from embedded XML: {manufacturer} {model_name}")
+
+        # Extract lens info (use {*} wildcard for namespace handling)
+        lens_elem = root.find(".//{*}Lens")
+        if lens_elem is not None:
+            lens_model = lens_elem.get("modelName")
+            if lens_model:
+                lens = LensInfo(
+                    model=lens_model,
+                    detection_method=DetectionMethod.METADATA,
+                )
+                logger.info(f"Extracted lens from embedded XML: {lens_model}")
+
+        if device or lens:
+            return SidecarMetadata(device=device, lens=lens)
+
+        return None
+
+    except ET.ParseError as e:
+        logger.warning(f"Failed to parse embedded XDCAM XML: {e}")
+        return None
+    except Exception as e:
+        logger.warning(f"Error parsing embedded XDCAM XML: {e}")
+        return None
+
+
+class SonyExtractor:
+    """Metadata extractor for Sony cameras."""
+
+    def detect(self, probe_data: dict[str, Any], file_path: str) -> bool:
+        """Detect if file is from a Sony camera."""
+        tags = get_tags_lower(probe_data)
+
+        # Check make tag
+        make = tags.get("make") or tags.get("manufacturer")
+        if make and "SONY" in make.upper():
+            return True
+
+        # Check major_brand for XAVC
+        major_brand = tags.get("major_brand", "")
+        if major_brand.upper() == "XAVC":
+            return True
+
+        # Check for embedded XDCAM metadata tag
+        format_tags = probe_data.get("format", {}).get("tags", {})
+        if "com.sony.bprl.mxf.nrtmetadata" in format_tags:
+            return True
+
+        # Check for AVCHD structure (common for Sony camcorders)
+        # Path patterns:
+        #   - .../PRIVATE/AVCHD/BDMV/STREAM/*.MTS (consumer Sony)
+        #   - .../AVCHD/BDMV/STREAM/*.MTS (NX-CAM and other pro Sony)
+        path = Path(file_path)
+        if path.suffix.upper() in (".MTS", ".M2TS"):
+            # Check if in AVCHD/BDMV/STREAM folder structure
+            parts = [p.upper() for p in path.parts]
+            if "AVCHD" in parts and "BDMV" in parts and "STREAM" in parts:
+                return True
+
+        # Check for Sony XML sidecar
+        xml_patterns = [
+            path.with_suffix(".XML"),
+            path.parent / f"{path.stem}M01.XML",
+            path.parent / f"{path.stem}M01.xml",
+        ]
+        for pattern in xml_patterns:
+            if pattern.exists():
+                # Verify it's a Sony XML by checking namespace
+                try:
+                    tree = ET.parse(pattern)
+                    root = tree.getroot()
+                    # Check for Sony namespace or Device manufacturer
+                    if "professionalDisc" in str(root.tag).lower():
+                        return True
+                    device = root.find(".//{*}Device")
+                    if device is not None:
+                        mfr = device.get("manufacturer", "")
+                        if "Sony" in mfr:
+                            return True
+                except Exception:
+                    pass
+
+        return False
+
+    def extract(self, probe_data: dict[str, Any], file_path: str, base_metadata: Metadata) -> Metadata:
+        """Extract Sony-specific metadata."""
+        tags = get_tags_lower(probe_data)
+
+        # Get basic device info from tags
+        make = tags.get("make") or tags.get("manufacturer") or "Sony"
+        model = tags.get("model") or tags.get("model_name")
+
+        # Parse XML sidecar for detailed metadata
+        sidecar = _parse_xml_sidecar(file_path)
+
+        # Try embedded XML if no sidecar (XDCAM format)
+        embedded = None
+        if sidecar is None:
+            embedded = _parse_embedded_xml(probe_data)
+
+        # Build device info (prefer sidecar > embedded > basic tags)
+        if sidecar and sidecar.device:
+            device = sidecar.device
+        elif embedded and embedded.device:
+            device = embedded.device
+        else:
+            device = DeviceInfo(
+                make=make if make else "Sony",
+                model=model,
+                software=tags.get("software"),
+                type=MediaDeviceType.CAMERA,
+                detection_method=DetectionMethod.METADATA,
+                confidence=1.0,
+            )
+
+        # Merge metadata (prefer sidecar > embedded > base)
+        gps = sidecar.gps if sidecar and sidecar.gps else base_metadata.gps
+        color_space = sidecar.color_space if sidecar and sidecar.color_space else base_metadata.color_space
+
+        # Get lens info (prefer sidecar > embedded > base)
+        if sidecar and sidecar.lens:
+            lens = sidecar.lens
+        elif embedded and embedded.lens:
+            lens = embedded.lens
+        else:
+            lens = base_metadata.lens
+
+        # Try to extract GPS from AVCHD SEI if not already found
+        gps_track = None
+        if gps is None:
+            gps = extract_avchd_gps(file_path)
+            # Also extract full track if GPS was found
+            if gps is not None:
+                gps_track = extract_avchd_gps_track(file_path)
+
+        # Check for spanned recordings (AVCHD files split at 2GB)
+        spanned_recording = None
+        path = Path(file_path)
+        if path.suffix.upper() in (".MTS", ".M2TS"):
+            recording = get_recording_for_file(file_path)
+            if recording and recording.is_spanned:
+                # Find this file's position in the recording
+                file_resolved = str(path.resolve())
+                file_index = 0
+                sibling_files = []
+                for i, clip in enumerate(recording.clips):
+                    clip_resolved = str(Path(clip.file_path).resolve())
+                    if clip_resolved == file_resolved:
+                        file_index = i
+                    else:
+                        sibling_files.append(Path(clip.file_path).name)
+
+                spanned_recording = SpannedRecording(
+                    is_continuation=(file_index > 0),
+                    sibling_files=sibling_files,
+                    total_duration=recording.total_duration,
+                    file_index=file_index,
+                )
+                logger.info(f"Detected spanned recording: file {file_index + 1} of {len(recording.clips)}, " f"total duration {recording.total_duration:.1f}s")
+
+        return Metadata(
+            duration=base_metadata.duration,
+            resolution=base_metadata.resolution,
+            codec=base_metadata.codec,
+            video_codec=base_metadata.video_codec,
+            audio=base_metadata.audio,
+            fps=base_metadata.fps,
+            bitrate=base_metadata.bitrate,
+            file_size=base_metadata.file_size,
+            timecode=base_metadata.timecode,
+            created_at=base_metadata.created_at,
+            device=device,
+            gps=gps,
+            gps_track=gps_track,
+            color_space=color_space,
+            lens=lens,
+            spanned_recording=spanned_recording,
+        )
+
+
+# Register this extractor
+register_extractor("sony", SonyExtractor())

media_engine/extractors/metadata/tesla.py

@@ -0,0 +1,157 @@
+"""Tesla dashcam metadata extractor.
+
+Tesla vehicles record dashcam footage from 4 cameras:
+- front: Main forward-facing camera
+- back: Rear camera
+- left_repeater: Left side mirror camera
+- right_repeater: Right side mirror camera
+
+Files are saved in 1-minute segments with naming pattern:
+YYYY-MM-DD_HH-MM-SS-camera.mp4
+
+Sentry mode and dashcam events include:
+- event.json: Contains timestamp, GPS (est_lat, est_lon), city, reason
+- thumb.png: Thumbnail preview
+
+Detection methods:
+- Filename pattern matching
+- event.json sidecar presence
+"""
+
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+from media_engine.schemas import (
+    GPS,
+    DetectionMethod,
+    DeviceInfo,
+    MediaDeviceType,
+    Metadata,
+)
+
+from .registry import register_extractor
+
+logger = logging.getLogger(__name__)
+
+# Tesla filename pattern: YYYY-MM-DD_HH-MM-SS-camera.mp4
+TESLA_FILENAME_PATTERN = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}-(front|back|left_repeater|right_repeater)\.mp4$")
+
+
+def _parse_event_json(video_path: str) -> GPS | None:
+    """Parse Tesla event.json sidecar for GPS coordinates.
+
+    The event.json file is in the parent folder of the video files
+    and contains estimated GPS coordinates.
+    """
+    path = Path(video_path)
+
+    # event.json is in the same directory as the video
+    event_json = path.parent / "event.json"
+
+    if not event_json.exists():
+        return None
+
+    try:
+        with open(event_json, encoding="utf-8") as f:
+            data = json.load(f)
+
+        lat_str = data.get("est_lat")
+        lon_str = data.get("est_lon")
+
+        if lat_str and lon_str:
+            lat = float(lat_str)
+            lon = float(lon_str)
+
+            if lat != 0 and lon != 0:
+                logger.info(f"Extracted GPS from Tesla event.json: {lat}, {lon}")
+                return GPS(latitude=lat, longitude=lon)
+
+        return None
+
+    except Exception as e:
+        logger.warning(f"Error reading Tesla event.json: {e}")
+        return None
+
+
+def _detect_camera_position(filename: str) -> str | None:
+    """Detect which camera the file is from based on filename."""
+    name_lower = filename.lower()
+
+    if "-front" in name_lower:
+        return "front"
+    elif "-back" in name_lower:
+        return "rear"
+    elif "-left_repeater" in name_lower:
+        return "left"
+    elif "-right_repeater" in name_lower:
+        return "right"
+
+    return None
+
+
+class TeslaExtractor:
+    """Metadata extractor for Tesla dashcam footage."""
+
+    def detect(self, probe_data: dict[str, Any], file_path: str) -> bool:
+        """Detect if file is from a Tesla dashcam."""
+        path = Path(file_path)
+
+        # Check filename pattern
+        if TESLA_FILENAME_PATTERN.match(path.name):
+            return True
+
+        # Check for event.json in same directory (Tesla sentry/dashcam event)
+        event_json = path.parent / "event.json"
+        if event_json.exists():
+            try:
+                with open(event_json, encoding="utf-8") as f:
+                    data = json.load(f)
+                # Tesla event.json has specific keys
+                if "est_lat" in data or "reason" in data:
+                    return True
+            except Exception:
+                pass
+
+        return False
+
+    def extract(
+        self,
+        probe_data: dict[str, Any],
+        file_path: str,
+        base_metadata: Metadata,
+    ) -> Metadata:
+        """Extract Tesla dashcam metadata."""
+        path = Path(file_path)
+
+        # Detect camera position
+        camera = _detect_camera_position(path.name)
+
+        # Build model string with camera position
+        model = "Dashcam"
+        if camera:
+            model = f"Dashcam ({camera})"
+
+        device = DeviceInfo(
+            make="Tesla",
+            model=model,
+            type=MediaDeviceType.DASHCAM,
+            detection_method=DetectionMethod.METADATA,
+            confidence=1.0,
+        )
+
+        # Extract GPS from event.json
+        gps = _parse_event_json(file_path)
+        if gps is None:
+            gps = base_metadata.gps
+
+        base_metadata.device = device
+        base_metadata.gps = gps
+
+        return base_metadata
+
+
+# Register the extractor
+register_extractor("tesla", TeslaExtractor())