Soul_Code/Soul-Bench-Eval/subjects/av_align.py

"""Audio-Video Alignment evaluation using AV-Align metric.

This module evaluates the alignment between audio and video modalities using 
the AV-Align metric from TempoTokens. The metric assesses synchronization by 
detecting audio and video peaks and calculating their Intersection over Union (IoU).
A higher IoU score indicates better alignment.
"""

from __future__ import annotations

import tempfile
from pathlib import Path
from typing import Dict, Iterable, List

import cv2
import librosa
import numpy as np
from tqdm import tqdm

from video import VideoData


SUBJECT_NAME = "av_align"
DEFAULT_DOWNSAMPLE_FACTOR = 1  # Process every Nth frame to speed up computation


def extract_frames_optimized(video_path: str, downsample: int = 1) -> tuple[np.ndarray, float, int]:
    """Extract frames from a video file (optimized version).

    Args:
        video_path: Path to the input video file.
        downsample: Factor to downsample frames (e.g., 2 = every other frame).

    Returns:
        A tuple of (frames, frame_rate, num_frames) where frames is a numpy array
        of shape (N, H, W) containing grayscale frames, frame_rate is the effective FPS
        after downsampling, and num_frames is the total number of frames extracted.
    """
    cap = cv2.VideoCapture(video_path)
    original_fps = cap.get(cv2.CAP_PROP_FPS)
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

    if not cap.isOpened():
        raise ValueError(f"Error: Unable to open the video file: {video_path}")

    # Calculate downsampled frame count
    expected_frames = (total_frames + downsample - 1) // downsample
    
    # Pre-allocate array for grayscale frames
    first_ret, first_frame = cap.read()
    if not first_ret:
        cap.release()
        raise ValueError(f"Error: Cannot read first frame from {video_path}")
    
    h, w = first_frame.shape[:2]
    frames_gray = np.zeros((expected_frames, h, w), dtype=np.uint8)
    
    # Convert first frame to grayscale
    frames_gray[0] = cv2.cvtColor(first_frame, cv2.COLOR_BGR2GRAY)
    
    # Read and convert frames with downsampling
    frame_idx = 1
    actual_frame_count = 1
    
    while actual_frame_count < expected_frames:
        # Skip frames according to downsample factor
        for _ in range(downsample):
            ret, frame = cap.read()
            frame_idx += 1
            if not ret:
                break
        
        if not ret:
            break
            
        frames_gray[actual_frame_count] = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        actual_frame_count += 1
    
    cap.release()
    
    # Trim array if we read fewer frames than expected
    if actual_frame_count < expected_frames:
        frames_gray = frames_gray[:actual_frame_count]
    
    # Adjust FPS based on downsampling
    effective_fps = original_fps / downsample
    
    return frames_gray, effective_fps, actual_frame_count


def detect_audio_peaks(audio_path: str) -> np.ndarray:
    """Detect audio peaks using the Onset Detection algorithm.

    Args:
        audio_path: Path to the audio file.

    Returns:
        Array of times (in seconds) where audio peaks occur.
    """
    y, sr = librosa.load(audio_path)
    # Calculate the onset envelope
    onset_env = librosa.onset.onset_strength(y=y, sr=sr)
    # Get the onset events
    onset_frames = librosa.onset.onset_detect(onset_envelope=onset_env, sr=sr)
    onset_times = librosa.frames_to_time(onset_frames, sr=sr)
    return onset_times


def find_local_max_indexes(arr: np.ndarray, fps: float) -> np.ndarray:
    """Find local maxima in an array (vectorized version).

    Note:
        Local maxima with an optical flow magnitude less than 0.1 are ignored
        to prevent static scenes from being incorrectly calculated as peaks.

    Args:
        arr: NumPy array of values to find local maxima in.
        fps: Frames per second, used to convert indexes to time.

    Returns:
        NumPy array of times (in seconds) where local maxima occur.
    """
    n = len(arr)
    if n < 3:
        return np.array([])
    
    # Vectorized comparison: find where arr[i-1] < arr[i] > arr[i+1]
    is_local_max = (arr[1:-1] > arr[:-2]) & (arr[1:-1] > arr[2:]) & (arr[1:-1] >= 0.1)
    
    # Get indices (add 1 because we're comparing arr[1:-1])
    local_max_indices = np.where(is_local_max)[0] + 1
    
    # Convert to time
    return local_max_indices / fps


def compute_optical_flow_batch(frames_gray: np.ndarray) -> np.ndarray:
    """Compute optical flow magnitudes for consecutive frame pairs (vectorized).

    Args:
        frames_gray: NumPy array of grayscale frames with shape (N, H, W).

    Returns:
        NumPy array of average optical flow magnitudes for each frame pair.
        Length is N (first element is computed from frames 0->1).
    """
    n_frames = len(frames_gray)
    if n_frames < 2:
        return np.array([0.0])
    
    flow_magnitudes = np.zeros(n_frames, dtype=np.float32)
    
    # Compute optical flow for each consecutive pair
    for i in range(n_frames - 1):
        flow = cv2.calcOpticalFlowFarneback(
            frames_gray[i], frames_gray[i + 1], None, 
            0.5, 3, 15, 3, 5, 1.2, 0
        )
        # Calculate magnitude
        magnitude = np.sqrt(flow[..., 0]**2 + flow[..., 1]**2)
        flow_magnitudes[i] = magnitude.mean()
    
    # Last frame uses the same value as second-to-last transition
    flow_magnitudes[-1] = flow_magnitudes[-2] if n_frames > 1 else 0.0
    
    return flow_magnitudes


def detect_video_peaks(frames_gray: np.ndarray, fps: float) -> tuple[np.ndarray, np.ndarray]:
    """Detect video peaks using Optical Flow (optimized version).

    Args:
        frames_gray: NumPy array of grayscale frames with shape (N, H, W).
        fps: Frame rate of the video.

    Returns:
        A tuple of (flow_trajectory, video_peaks) where flow_trajectory is a 
        NumPy array of optical flow magnitudes for each frame and video_peaks 
        is a NumPy array of times (in seconds) where video peaks occur.
    """
    flow_trajectory = compute_optical_flow_batch(frames_gray)
    video_peaks = find_local_max_indexes(flow_trajectory, fps)
    return flow_trajectory, video_peaks


def calculate_iou(audio_peaks: np.ndarray, video_peaks: np.ndarray, fps: float) -> float:
    """Calculate Intersection over Union (IoU) between audio and video peaks (optimized).

    Note:
        A video peak is matched to at most one audio peak to ensure that a 
        single video peak does not correspond to multiple audio peaks.

    Args:
        audio_peaks: Array of audio peak times (in seconds).
        video_peaks: Array of video peak times (in seconds).
        fps: Frame rate of the video.

    Returns:
        Intersection over Union score.
    """
    if len(audio_peaks) == 0 or len(video_peaks) == 0:
        return 0.0
    
    window = 1.0 / fps
    intersection_length = 0
    used_video_peaks = np.zeros(len(video_peaks), dtype=bool)
    
    # For each audio peak, find the closest unused video peak within window
    for audio_peak in audio_peaks:
        # Vectorized distance calculation
        distances = np.abs(video_peaks - audio_peak)
        
        # Find candidates within window that haven't been used
        valid_mask = (distances < window) & (~used_video_peaks)
        
        if np.any(valid_mask):
            # Get the closest valid peak
            valid_indices = np.where(valid_mask)[0]
            closest_idx = valid_indices[np.argmin(distances[valid_indices])]
            
            intersection_length += 1
            used_video_peaks[closest_idx] = True
    
    union_length = len(audio_peaks) + len(video_peaks) - intersection_length
    if union_length == 0:
        return 0.0
    
    return intersection_length / union_length


def _extract_audio_from_video(video_path: str, audio_path: str) -> None:
    """Extract audio from video file using ffmpeg.

    Args:
        video_path: Path to the video file.
        audio_path: Path where the extracted audio should be saved.
    """
    import subprocess
    
    subprocess.run([
        'ffmpeg', '-i', video_path, '-vn', '-acodec', 'pcm_s16le', 
        '-ar', '44100', '-ac', '2', audio_path, '-y'
    ], check=True, capture_output=True)


def evaluate_single_video(
    video_path: str,
    audio_path: str | None = None,
    temp_dir: Path | None = None,
    downsample: int = 1,
) -> Dict:
    """Evaluate AV-Align score for a single video.

    Args:
        video_path: Path to the video file.
        audio_path: Path to the audio file. If None, audio will be extracted 
                   from the video.
        temp_dir: Temporary directory for audio extraction. Required if 
                 audio_path is None.
        downsample: Factor to downsample video frames (e.g., 2 = every other frame).
                   Higher values = faster but less accurate.

    Returns:
        Dictionary containing the evaluation results with keys:
        - iou_score: The AV-Align IoU score
        - num_audio_peaks: Number of detected audio peaks
        - num_video_peaks: Number of detected video peaks
        - fps: Frame rate of the video (after downsampling)
        - downsample_factor: The downsampling factor used
    """
    # Extract audio if not provided
    need_cleanup = False
    if audio_path is None or not Path(audio_path).exists():
        if temp_dir is None:
            raise ValueError("temp_dir must be provided when audio_path is None")
        audio_path = str(temp_dir / "extracted_audio.wav")
        _extract_audio_from_video(video_path, audio_path)
        need_cleanup = True
    
    try:
        # Extract frames from video (optimized: grayscale only, with downsampling)
        frames_gray, fps, num_frames = extract_frames_optimized(video_path, downsample=downsample)
        
        # Detect audio peaks
        audio_peaks = detect_audio_peaks(audio_path)
        
        # Detect video peaks
        flow_trajectory, video_peaks = detect_video_peaks(frames_gray, fps)
        
        # Calculate IoU score
        iou_score = calculate_iou(audio_peaks, video_peaks, fps)
        
        result = {
            "iou_score": float(iou_score),
            "num_audio_peaks": int(len(audio_peaks)),
            "num_video_peaks": int(len(video_peaks)),
            "fps": float(fps),
            "downsample_factor": int(downsample),
        }
    except Exception as exc:
        result = {"error": str(exc)}
    finally:
        # Clean up extracted audio if needed
        if need_cleanup and Path(audio_path).exists():
            Path(audio_path).unlink()
    
    return result


def evaluate(
    data_list: Iterable[VideoData],
    device: str = "cuda",
    batch_size: int | None = None,
    model_args: Dict | None = None,
    sampling: int | None = None,
) -> List[VideoData]:
    """Evaluate AV-Align score for each :class:`VideoData`.

    Args:
        data_list: Iterable of VideoData objects to evaluate.
        device: Device to use (not used by this metric).
        batch_size: Batch size (not used by this metric).
        model_args: Additional model arguments (optional).
                   - subject_name: Custom result key name (default: "av_align")
                   - downsample: Frame downsampling factor (default: 2)
                                Higher = faster but less accurate
                                1 = no downsampling (slowest, most accurate)
                                2 = every other frame (2x faster)
                                4 = every 4th frame (4x faster)
        sampling: Sampling parameter (not used by this metric).

    Returns:
        List of VideoData objects with AV-Align results registered.
    """
    del device, batch_size, sampling  # These parameters are not used by this metric.
    model_args = model_args or {}
    
    subject_name = model_args.get("subject_name", SUBJECT_NAME)
    downsample = int(model_args.get("downsample", DEFAULT_DOWNSAMPLE_FACTOR))
    
    # Validate downsample factor
    if downsample < 1:
        downsample = 1
    
    for video_data in tqdm(data_list, desc=f"Evaluating AV-Align (downsample={downsample}x)"):
        with tempfile.TemporaryDirectory(prefix="av_align_eval_") as tmpdir:
            temp_dir = Path(tmpdir)
            
            result = evaluate_single_video(
                video_path=video_data.video_path,
                audio_path=video_data.audio_path,
                temp_dir=temp_dir,
                downsample=downsample,
            )
            
            video_data.register_result(subject_name, result)
    
    return list(data_list)