videoReEncoderWithMetadata.py

import subprocess
import json
import os
from pathlib import Path
from datetime import datetime, timedelta
import pytz


def convert_timezone(timestamp_str, target_timezone_str, treat_as_local=True):
    """Convert timestamp to target timezone with proper offset.

    Args:
        timestamp_str: Original timestamp string (e.g., '2011-12-25T10:34:19.000000Z' or '2011-06-25 14:09:33')
        target_timezone_str: Target timezone (e.g., 'America/New_York')
        treat_as_local: If True, treats the time as already being in the target timezone
                       and just adds the correct offset. If False, converts from UTC.
    """
    if not timestamp_str:
        return None

    try:
        # Remove Z and any existing timezone info
        clean_timestamp = timestamp_str.replace('Z', '').split('+')[0].split('-05:00')[0].split('-04:00')[0]

        # Try multiple timestamp formats
        dt_naive = None
        formats = [
            '%Y-%m-%dT%H:%M:%S.%f',  # ISO format with microseconds
            '%Y-%m-%dT%H:%M:%S',  # ISO format without microseconds
            '%Y-%m-%d %H:%M:%S',  # Space-separated format (common in AVI)
            '%Y-%m-%d %H:%M:%S.%f',  # Space-separated with microseconds
        ]

        for fmt in formats:
            try:
                dt_naive = datetime.strptime(clean_timestamp, fmt)
                break
            except ValueError:
                continue

        if dt_naive is None:
            print(f"  Warning: Could not parse timestamp format: '{timestamp_str}'")
            return timestamp_str

        # Get target timezone
        target_tz = pytz.timezone(target_timezone_str)

        if treat_as_local:
            # Treat the time as already being in the local timezone
            # This handles the case where cameras record local time but mark it as UTC
            dt_local = target_tz.localize(dt_naive)
        else:
            # Convert from actual UTC to target timezone
            dt_utc = pytz.utc.localize(dt_naive)
            dt_local = dt_utc.astimezone(target_tz)

        # Format back to ISO 8601 with timezone offset
        return dt_local.isoformat()
    except Exception as e:
        print(f"  Warning: Could not convert timestamp '{timestamp_str}': {e}")
        return timestamp_str


def get_video_metadata(input_file):
    """Extract metadata from video file using ffprobe."""
    cmd = [
        'ffprobe',
        '-v', 'quiet',
        '-print_format', 'json',
        '-show_format',
        '-show_streams',
        input_file
    ]

    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        return json.loads(result.stdout)
    except subprocess.CalledProcessError as e:
        print(f"Error reading metadata from {input_file}: {e}")
        return None
    except json.JSONDecodeError as e:
        print(f"Error parsing metadata from {input_file}: {e}")
        return None


def extract_metadata_fields(metadata):
    """Extract relevant metadata fields from ffprobe output."""
    fields = {}

    if not metadata:
        return fields

    # Get format-level metadata
    format_tags = metadata.get('format', {}).get('tags', {})

    # Extract creation_time (try multiple variations)
    creation_time = format_tags.get('creation_time') or format_tags.get('com.apple.quicktime.creationdate')
    if creation_time:
        fields['creation_time'] = creation_time

    # Extract make
    make = (format_tags.get('make') or
            format_tags.get('com.apple.quicktime.make') or
            format_tags.get('Make'))
    if make:
        fields['make'] = make

    # Extract model
    model = (format_tags.get('model') or
             format_tags.get('com.apple.quicktime.model') or
             format_tags.get('Model'))
    if model:
        fields['model'] = model

    # Extract comment (always extract this for mapping)
    comment = format_tags.get('comment') or format_tags.get('comment-eng')
    if comment:
        fields['comment'] = comment

    # Extract original_format
    original_format = format_tags.get('original_format') or format_tags.get('original_format-eng')
    if original_format:
        fields['original_format'] = original_format

    return fields


def build_ffmpeg_command(input_file, output_file, metadata_fields, rotation=None):
    """Build the ffmpeg command with appropriate metadata and optional rotation.

    Args:
        input_file: Input video file path
        output_file: Output video file path
        metadata_fields: Dictionary of metadata to apply
        rotation: Rotation option (None, 'cw', 'ccw', '180')
    """
    cmd = [
        'ffmpeg',
        '-i', input_file,
        '-map_metadata', '0'
    ]

    # Add rotation filter if specified
    if rotation:
        if rotation == 'cw':  # 90 degrees clockwise
            cmd.extend(['-vf', 'transpose=1'])
        elif rotation == 'ccw':  # 90 degrees counter-clockwise
            cmd.extend(['-vf', 'transpose=2'])
        elif rotation == '180':  # 180 degrees
            cmd.extend(['-vf', 'transpose=2,transpose=2'])

    # Add encoding parameters
    cmd.extend([
        '-c:v', 'libx264',
        '-crf', '22',
        '-preset', 'medium',
        '-pix_fmt', 'yuv420p',
        '-color_primaries', 'bt709',
        '-color_trc', 'bt709',
        '-colorspace', 'bt709',
        '-c:a', 'aac',
        '-b:a', '128k',
        '-movflags', '+faststart'
    ])

    # Add format-level metadata
    if 'creation_time' in metadata_fields:
        cmd.extend(['-metadata', f'creation_time={metadata_fields["creation_time"]}'])
        # Also set for video and audio streams
        cmd.extend(['-metadata:s:v:0', f'creation_time={metadata_fields["creation_time"]}'])
        cmd.extend(['-metadata:s:a:0', f'creation_time={metadata_fields["creation_time"]}'])

    # Add format-level metadata
    if 'creation_time' in metadata_fields:
        cmd.extend(['-metadata', f'creation_time={metadata_fields["creation_time"]}'])
        # Also set for video and audio streams
        cmd.extend(['-metadata:s:v:0', f'creation_time={metadata_fields["creation_time"]}'])
        cmd.extend(['-metadata:s:a:0', f'creation_time={metadata_fields["creation_time"]}'])

    # Add format-level metadata
    if 'creation_time' in metadata_fields:
        cmd.extend(['-metadata', f'creation_time={metadata_fields["creation_time"]}'])
        # Also set for video and audio streams
        cmd.extend(['-metadata:s:v:0', f'creation_time={metadata_fields["creation_time"]}'])
        cmd.extend(['-metadata:s:a:0', f'creation_time={metadata_fields["creation_time"]}'])

    if 'make' in metadata_fields:
        cmd.extend(['-metadata', f'make={metadata_fields["make"]}'])

    if 'model' in metadata_fields:
        cmd.extend(['-metadata', f'model={metadata_fields["model"]}'])

    if 'comment' in metadata_fields:
        cmd.extend(['-metadata', f'comment={metadata_fields["comment"]}'])

    if 'original_format' in metadata_fields:
        cmd.extend(['-metadata', f'original_format={metadata_fields["original_format"]}'])

    # Clear rotation metadata if rotation was applied
    if rotation:
        cmd.extend(['-metadata:s:v:0', 'rotate=0'])

    cmd.append(output_file)

    return cmd


def modernize_video(input_file, output_file, timezone=None, comment_mappings=None, rotation=None, date_override=None):
    """Modernize a single video file.

    Args:
        input_file: Path to input video
        output_file: Path to output video
        timezone: Target timezone for timestamp conversion
        comment_mappings: Dictionary mapping comments to make/model
        rotation: Rotation option ('cw', 'ccw', '180', or None)
        date_override: ISO format date string to override all timestamps
    """
    print(f"\nProcessing: {input_file}")

    if rotation:
        rotation_text = {'cw': '90° clockwise', 'ccw': '90° counter-clockwise', '180': '180°'}
        print(f"  Rotation: {rotation_text.get(rotation, rotation)}")

    # Get metadata from original file
    metadata = get_video_metadata(input_file)
    metadata_fields = extract_metadata_fields(metadata)

    # Apply comment-based make/model mapping
    if comment_mappings and 'comment' in metadata_fields:
        comment = metadata_fields['comment']
        if comment in comment_mappings:
            mapping = comment_mappings[comment]
            if mapping['make']:
                metadata_fields['make'] = mapping['make']
                print(f"  Applying Make: {mapping['make']} (from comment mapping)")
            if mapping['model']:
                metadata_fields['model'] = mapping['model']
                print(f"  Applying Model: {mapping['model']} (from comment mapping)")

    # Apply date override if specified (takes precedence over timezone conversion)
    if date_override:
        metadata_fields['creation_time'] = date_override
        print(f"  Date override: {date_override}")
    # Otherwise apply timezone conversion if specified and creation_time exists
    elif timezone and 'creation_time' in metadata_fields:
        original_time = metadata_fields['creation_time']
        converted_time = convert_timezone(original_time, timezone)
        if converted_time != original_time:
            metadata_fields['creation_time'] = converted_time
            print(f"  Converted time: {original_time} → {converted_time}")
    # If no creation_time exists but timezone is set, note this
    elif timezone and 'creation_time' not in metadata_fields:
        print(f"  Note: No creation_time in original file, timezone conversion skipped")

    if metadata_fields:
        print(
            f"  Metadata: {', '.join(f'{k}={v[:30]}...' if len(str(v)) > 30 else f'{k}={v}' for k, v in metadata_fields.items())}")
    else:
        print("  No metadata found, proceeding without metadata flags")

    # Build and run ffmpeg command
    cmd = build_ffmpeg_command(input_file, output_file, metadata_fields, rotation)

    try:
        print(f"  Converting to: {output_file}")
        subprocess.run(cmd, check=True, capture_output=True)
        print(f"  ✓ Success!")
        return True
    except subprocess.CalledProcessError as e:
        print(f"  ✗ Error converting {input_file}: {e}")
        if e.stderr:
            print(f"    FFmpeg error: {e.stderr.decode()}")
        return False


def collect_unique_comments(folder_path, video_extensions):
    """Scan folder and collect all unique comment values."""
    folder = Path(folder_path)
    unique_comments = set()

    video_files = [f for f in folder.iterdir()
                   if f.is_file()
                   and f.suffix.lower() in video_extensions
                   and '_modernized' not in f.stem]

    print("\nScanning for unique comments...")
    for video_file in video_files:
        metadata = get_video_metadata(str(video_file))
        fields = extract_metadata_fields(metadata)
        if 'comment' in fields:
            unique_comments.add(fields['comment'])

    return unique_comments


def prompt_comment_mappings(unique_comments):
    """Prompt user to map comments to Make/Model."""
    if not unique_comments:
        return {}

    print(f"\n{'=' * 60}")
    print("COMMENT TO MAKE/MODEL MAPPING")
    print(f"{'=' * 60}")
    print(f"Found {len(unique_comments)} unique comment(s) in videos.")
    print("For each comment, you can specify Make and Model to apply.")
    print("Press Enter to skip (keep existing or leave blank).\n")

    mappings = {}
    for comment in sorted(unique_comments):
        print(f"\nComment: \"{comment}\"")
        make = input("  Enter Make (e.g., Apple, OLYMPUS): ").strip()
        model = input("  Enter Model (e.g., iPhone 6S, E-M10): ").strip()

        mappings[comment] = {
            'make': make if make else None,
            'model': model if model else None
        }

    print(f"\n{'=' * 60}\n")
    return mappings


def prompt_rotation_mappings(video_files):
    """Prompt user to specify which files need rotation."""
    print(f"\n{'=' * 60}")
    print("VIDEO ROTATION (Optional)")
    print(f"{'=' * 60}")
    print("You can specify files that need to be rotated during processing.")
    print("Leave blank if no files need rotation.\n")

    rotate_input = input("Enter filenames to rotate (comma-separated) or press Enter to skip: ").strip()

    if not rotate_input:
        return {}

    # Parse the comma-separated filenames
    files_to_rotate = [f.strip() for f in rotate_input.split(',')]

    rotation_mappings = {}

    print("\nFor each file, specify rotation:")
    print("  cw  = 90° clockwise")
    print("  ccw = 90° counter-clockwise")
    print("  180 = 180°")

    for filename in files_to_rotate:
        # Try to find matching file (case-insensitive, with or without extension)
        matching_files = []
        filename_lower = filename.lower()

        for video_file in video_files:
            # Exact match on full name (with extension)
            if filename_lower == video_file.name.lower():
                matching_files = [video_file]
                break
            # Exact match on stem (without extension)
            elif filename_lower == video_file.stem.lower():
                matching_files.append(video_file)

        if not matching_files:
            print(f"\n⚠ Warning: No file found matching '{filename}', skipping")
            continue

        if len(matching_files) > 1:
            print(f"\n⚠ Warning: Multiple files match '{filename}':")
            for f in matching_files:
                print(f"    - {f.name}")
            print("  Skipping this entry. Be more specific.")
            continue

        matched_file = matching_files[0]
        print(f"\nFile: {matched_file.name}")
        rotation = input("  Rotation (cw/ccw/180): ").strip().lower()

        if rotation in ['cw', 'ccw', '180']:
            rotation_mappings[matched_file.name] = rotation
            print(f"  ✓ Will rotate {rotation}")
        else:
            print(f"  ✗ Invalid rotation '{rotation}', skipping")

    if rotation_mappings:
        print(f"\n✓ {len(rotation_mappings)} file(s) will be rotated")

    print(f"{'=' * 60}\n")
    return rotation_mappings


def prompt_date_overrides(video_files):
    """Prompt user to specify which files need date/time overrides."""
    print(f"\n{'=' * 60}")
    print("DATE/TIME OVERRIDES (Optional)")
    print(f"{'=' * 60}")
    print("You can manually set the creation date/time for specific files.")
    print("This overrides any existing timestamps and timezone conversion.")
    print("Leave blank if no files need date overrides.\n")

    date_input = input("Enter filenames that need date adjustments (comma-separated) or press Enter to skip: ").strip()

    if not date_input:
        return {}

    # Parse the comma-separated filenames
    files_for_dates = [f.strip() for f in date_input.split(',')]

    date_mappings = {}

    print("\nFor each file, enter the date/time.")
    print("Format: YYYY-MM-DD HH:MM:SS (24-hour format)")
    print("Example: 2007-01-01 00:00:00")

    for filename in files_for_dates:
        # Try to find matching file (case-insensitive, with or without extension)
        matching_files = []
        filename_lower = filename.lower()

        for video_file in video_files:
            # Exact match on full name (with extension)
            if filename_lower == video_file.name.lower():
                matching_files = [video_file]
                break
            # Exact match on stem (without extension)
            elif filename_lower == video_file.stem.lower():
                matching_files.append(video_file)

        if not matching_files:
            print(f"\n⚠ Warning: No file found matching '{filename}', skipping")
            continue

        if len(matching_files) > 1:
            print(f"\n⚠ Warning: Multiple files match '{filename}':")
            for f in matching_files:
                print(f"    - {f.name}")
            print("  Skipping this entry. Be more specific.")
            continue

        matched_file = matching_files[0]
        print(f"\nFile: {matched_file.name}")
        date_str = input("  Date/Time (YYYY-MM-DD HH:MM:SS): ").strip()

        # Allow colons in date part (common mistake: 2011:01:01 instead of 2011-01-01)
        # Split by space to separate date and time parts
        parts = date_str.split()
        if len(parts) == 2:
            date_part = parts[0].replace(':', '-')  # Fix date separators
            time_part = parts[1]  # Leave time as-is (already has colons)
            date_str = f"{date_part} {time_part}"

        # Validate format
        try:
            datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S')
            # Convert to ISO format
            iso_date = date_str.replace(' ', 'T')
            date_mappings[matched_file.name] = iso_date
            print(f"  ✓ Will set date to {date_str}")
        except ValueError:
            print(f"  ✗ Invalid date format '{date_str}', skipping")

    if date_mappings:
        print(f"\n✓ {len(date_mappings)} file(s) will have date overrides")

    print(f"{'=' * 60}\n")
    return date_mappings


def batch_modernize(folder_path, video_extensions=None):
    """Batch modernize all videos in a folder."""
    if video_extensions is None:
        video_extensions = {'.mov', '.mp4', '.avi', '.mkv', '.m4v'}

    folder = Path(folder_path)

    if not folder.exists():
        print(f"Error: Folder '{folder_path}' does not exist")
        return

    # Find all video files
    video_files = [f for f in folder.iterdir()
                   if f.is_file()
                   and f.suffix.lower() in video_extensions
                   and '_modernized' not in f.stem]

    if not video_files:
        print(f"No video files found in '{folder_path}'")
        return

    print(f"Found {len(video_files)} video(s) to process")

    # Ask about timezone conversion
    print(f"\n{'=' * 60}")
    print("TIMEZONE ADJUSTMENT (Optional)")
    print(f"{'=' * 60}")
    print("Many cameras record local time but incorrectly mark it as UTC.")
    print("This option adds the correct timezone offset to your timestamps.")
    print("\nExample: Video recorded at 10:34 AM EST on Dec 25, 2011")
    print("  Current:  2011-12-25T10:34:19.000000Z (incorrect UTC marker)")
    print("  Corrected: 2011-12-25T10:34:19-05:00 (correct EST offset)")
    print("\nCommon US timezones: America/New_York, America/Chicago,")
    print("                     America/Denver, America/Los_Angeles")
    print("Leave blank to keep original timestamps.\n")

    timezone = input("Enter timezone where videos were recorded (or press Enter to skip): ").strip()
    if timezone:
        try:
            # Validate timezone
            pytz.timezone(timezone)
            print(f"✓ Will add correct timezone offset for {timezone}")
            print("  (DST will be calculated automatically based on each video's date)")
        except pytz.exceptions.UnknownTimeZoneError:
            print(f"✗ Unknown timezone '{timezone}', keeping original timestamps")
            timezone = None
    else:
        timezone = None

    # Collect unique comments and prompt for mappings
    unique_comments = collect_unique_comments(folder_path, video_extensions)
    comment_mappings = prompt_comment_mappings(unique_comments)

    # Prompt for rotation mappings
    rotation_mappings = prompt_rotation_mappings(video_files)

    # Prompt for date overrides
    date_mappings = prompt_date_overrides(video_files)

    # Process videos
    print(f"\n{'=' * 60}")
    print("PROCESSING VIDEOS")
    print(f"{'=' * 60}")

    successful = 0
    failed = 0

    for video_file in video_files:
        # Create output filename
        # Convert AVI to MOV for better compatibility
        if video_file.suffix.lower() == '.avi':
            output_name = f"{video_file.stem}_modernized.mov"
        else:
            output_name = f"{video_file.stem}_modernized{video_file.suffix}"

        output_file = video_file.parent / output_name

        # Skip if output already exists
        if output_file.exists():
            print(f"\nSkipping {video_file.name} (output already exists)")
            continue

        # Check if this file needs rotation
        rotation = rotation_mappings.get(video_file.name, None)

        # Check if this file has a date override
        date_override = date_mappings.get(video_file.name, None)

        # Process the video
        if modernize_video(str(video_file), str(output_file), timezone, comment_mappings, rotation, date_override):
            successful += 1
        else:
            failed += 1

    print(f"\n{'=' * 50}")
    print(f"Batch processing complete!")
    print(f"  Successful: {successful}")
    print(f"  Failed: {failed}")
    print(f"{'=' * 50}")


if __name__ == "__main__":
    import sys

    # Get folder path from command line argument or use current directory
    if len(sys.argv) > 1:
        folder_path = sys.argv[1]
    else:
        folder_path = input("Enter folder path (or press Enter for current directory): ").strip()
        if not folder_path:
            folder_path = "."

    batch_modernize(folder_path)