dataprocess_code/video_utils.py

"""
Video loading utilities for efficient video processing.
"""

import os
import torch
import numpy as np
from decord import VideoReader


def load_video_rgb_fchw(video_path: str, wh: tuple[int, int], 
                       start: int | None = None, count: int | None = None, 
                       accurate_seek: bool = False, read_full: bool = False):
    """Load video frames as RGB tensor [F,C,H,W] in [-1,1] range.
    
    Args:
        video_path: Path to video file
        wh: Target (width, height) for resizing
        start: Starting frame index
        count: Number of frames to read
        accurate_seek: Whether to use accurate seeking (unused with decord)
        read_full: Whether to read full video first then slice
        
    Returns:
        torch.Tensor: Video frames [F,C,H,W] in [-1,1] range, or None if failed
    """
    W, H = wh
    
    try:
        # Create VideoReader
        vr = VideoReader(video_path)
        total_frames = len(vr)
        
        if total_frames == 0:
            return None
        
        # Determine frame indices to read
        if read_full:
            frame_indices = list(range(total_frames))
        elif start is not None and count is not None:
            start_idx = max(0, min(start, total_frames - 1))
            end_idx = min(start_idx + count, total_frames)
            frame_indices = list(range(start_idx, end_idx))
        elif start is not None:
            start_idx = max(0, min(start, total_frames - 1))
            frame_indices = list(range(start_idx, total_frames))
        elif count is not None:
            frame_indices = list(range(min(count, total_frames)))
        else:
            frame_indices = list(range(total_frames))
        
        if not frame_indices:
            return None
        
        # Batch read frames - much more efficient
        frames_np = vr.get_batch(frame_indices).asnumpy()  # [F,H,W,C] in RGB
        
        if frames_np.size == 0:
            return None
        
        # Resize frames if needed
        if (frames_np.shape[2] != W) or (frames_np.shape[1] != H):
            import cv2
            resized_frames = []
            for frame in frames_np:
                resized_frame = cv2.resize(frame, (W, H), interpolation=cv2.INTER_AREA)
                resized_frames.append(resized_frame)
            frames_np = np.stack(resized_frames, axis=0)
        
        # Convert to torch tensor [F,C,H,W] in [-1,1] range for WAN VAE
        frames_tensor = torch.from_numpy(frames_np).permute(0,3,1,2).float()
        frames_tensor = (frames_tensor / 255.0) * 2.0 - 1.0  # [0,1] -> [-1,1]
        return frames_tensor
        
    except Exception as e:
        print(f"⚠️ Failed to load video {video_path}: {e}")
        return None


def infer_video_path_from_cache(pt_file_path: str, video_root: str | None = None):
    """Infer original video path from cache .pt filename.
    
    Args:
        pt_file_path: Path to .pt cache file
        video_root: Root directory for original videos
        
    Returns:
        str | None: Inferred video path or None if not found
    """
    base_name = os.path.basename(pt_file_path)
    video_name = base_name.replace('.pt', '.mp4')
    
    if video_root:
        candidate = os.path.join(video_root, video_name)
        return candidate if os.path.exists(candidate) else None
    
    # Try alongside cache directory as fallback
    pt_dir = os.path.dirname(pt_file_path)
    candidate = os.path.join(pt_dir, video_name)
    return candidate if os.path.exists(candidate) else None


def choose_window_start(F_lm: int, F_vid: int | None, N: int | None, 
                       valid_mask: torch.Tensor | None, strict: bool = True, 
                       max_invalid: int = 0):
    """Choose optimal window start index for aligned landmark and video data.
    
    Args:
        F_lm: Number of landmark frames
        F_vid: Number of video frames (optional)
        N: Desired window length (optional)
        valid_mask: Boolean mask for valid landmark frames
        strict: Whether to require all frames in window to be valid
        max_invalid: Maximum number of invalid frames allowed in non-strict mode
        
    Returns:
        int: Start index for the window
    """
    if F_lm is None or F_lm <= 0:
        return 0
    
    if valid_mask is None or valid_mask.numel() != F_lm:
        # No mask; choose based on lengths only
        if N is None:
            return 0
        if F_vid is not None:
            max_start = min(F_lm, F_vid) - N
        else:
            max_start = F_lm - N
        if max_start < 0:
            return 0
        return int(torch.randint(0, max_start + 1, (1,)).item())
    
    # Helper to test window validity
    def window_ok(s, n):
        if s < 0 or s + n > F_lm:
            return False
        if strict:
            return bool(valid_mask[s:s+n].all().item())
        else:
            invalid = (~valid_mask[s:s+n]).sum().item()
            return invalid <= max_invalid
    
    if N is None:
        # Choose first valid frame as start
        for s in range(F_lm):
            if valid_mask[s]:
                return s
        return 0
    
    # Candidate range by lengths
    if F_vid is not None:
        max_start = min(F_lm, F_vid) - N
    else:
        max_start = F_lm - N
    if max_start < 0:
        return 0
    
    # Collect all valid starts; random pick for diversity
    valids = [s for s in range(0, max_start + 1) if window_ok(s, N)]
    if valids:
        ridx = int(torch.randint(0, len(valids), (1,)).item())
        return valids[ridx]
    
    # Fallback: pick any start in range
    return int(torch.randint(0, max_start + 1, (1,)).item())