dataprocess_code/hallo3_data_talkinghead.py

"""
Dataset implementations for video generation.
"""

import os
import json
import cv2
import torch
import torch.nn.functional as F
import random
import numpy as np
from torch.utils.data import Dataset
from omegaconf import DictConfig, ListConfig
from typing import Optional, List, Sequence
from decord import VideoReader
import ffmpeg
import librosa
import warnings
from transformers import Wav2Vec2Processor

# Prefer audioread for MP4 containers to avoid PySoundFile warnings
try:
    if hasattr(librosa, "set_audio_backend"):
        librosa.set_audio_backend("audioread")
except Exception:
    pass

# Suppress noisy backend warnings from librosa when reading MP4
warnings.filterwarnings("ignore", message="PySoundFile failed. Trying audioread instead.")
warnings.filterwarnings(
    "ignore",
    category=FutureWarning,
    message=r"librosa\.core\.audio\.__audioread_load.*",
)

# Import our modular utilities
from .landmark_utils import (
    FACEMESH_LEFT_EYE, FACEMESH_RIGHT_EYE, FACEMESH_LEFT_EYEBROW, 
    FACEMESH_RIGHT_EYEBROW, FACEMESH_LIPS_ALL, FACEMESH_FACE_OVAL,
    LandmarkRenderer, create_valid_landmark_mask
)
from .video_utils import load_video_rgb_fchw, infer_video_path_from_cache, choose_window_start
from .config import DatasetConfig


def _is_audio_silent(audio_array: np.ndarray, threshold: float = 0.001) -> bool:
    """Check if audio is approximately silent via RMS amplitude."""
    if audio_array.size == 0:
        return True
    rms = float(np.sqrt(np.mean(np.square(audio_array, dtype=np.float32))))
    return rms < threshold


def _read_labels_from_video(video_path: str) -> Optional[np.ndarray]:
    """Read grayscale label video back as numpy array: (T, H, W), uint8."""
    try:
        probe = ffmpeg.probe(video_path)
        video_info = next(s for s in probe["streams"] if s["codec_type"] == "video")
        width = int(video_info["width"])
        height = int(video_info["height"])

        out, _ = (
            ffmpeg.input(video_path)
            .output("pipe:", format="rawvideo", pix_fmt="gray")
            .run(capture_stdout=True, capture_stderr=True)
        )

        decoded = np.frombuffer(out, np.uint8).reshape((-1, height, width))
        return decoded
    except Exception as e:
        print(f"Error reading label video {video_path}: {e}")
        return None


def _compute_lip_bboxes(
    labels: np.ndarray,
    lip_scale: float = 1.2,
    nose_labels: Sequence[int] = (2,),
    face_labels: Sequence[int] = (1,),
) -> List[Optional[tuple[int, int, int, int]]]:
    """Compute per-frame mouth-region bboxes using nose + face masks, with temporal interpolation.

    Copied and adapted from visualize_face_parse_labels_v2._compute_lip_bboxes.
    """
    if labels.ndim != 3:
        raise ValueError("labels must have shape (T, H, W)")

    T, H, W = labels.shape
    lip_scale = max(float(lip_scale), 1.0)

    raw_bboxes: List[Optional[tuple[int, int, int, int]]] = [None] * T

    # First, per-frame bbox from masks (if present).
    for t in range(T):
        frame_labels = labels[t]

        nose_mask = np.isin(frame_labels, nose_labels)
        face_mask = np.isin(frame_labels, face_labels)

        if not np.any(nose_mask) or not np.any(face_mask):
            continue

        # Nose: lowest point (max y) used as top boundary.
        nose_ys, _ = np.where(nose_mask)
        y_top = float(nose_ys.max())

        # Face: use full extent as bottom/left/right.
        face_ys, face_xs = np.where(face_mask)
        y_bottom = float(face_ys.max())
        x_left = float(face_xs.min())
        x_right = float(face_xs.max())

        # Sanity check.
        if y_bottom <= y_top:
            continue

        # Base bbox.
        x_min = x_left
        x_max = x_right
        y_min = y_top
        y_max = y_bottom

        # Size and center.
        w = x_max - x_min + 1.0
        h = y_max - y_min + 1.0
        cx = (x_min + x_max) / 2.0
        cy = (y_min + y_max) / 2.0

        # Apply scaling around center.
        new_w = w * lip_scale
        new_h = h * lip_scale

        x_min_s = int(round(cx - new_w / 2.0))
        x_max_s = int(round(cx + new_w / 2.0))
        y_min_s = int(round(cy - new_h / 2.0))
        y_max_s = int(round(cy + new_h / 2.0))

        x_min_s = max(0, min(x_min_s, W - 1))
        x_max_s = max(0, min(x_max_s, W - 1))
        y_min_s = max(0, min(y_min_s, H - 1))
        y_max_s = max(0, min(y_max_s, H - 1))

        if x_max_s <= x_min_s or y_max_s <= y_min_s:
            continue

        raw_bboxes[t] = (x_min_s, y_min_s, x_max_s, y_max_s)

    # If no frame has a bbox, return all None.
    if not any(bb is not None for bb in raw_bboxes):
        return raw_bboxes

    # Temporal interpolation over time for each coordinate.
    coords: List[List[Optional[int]]] = [[None] * T for _ in range(4)]
    for t, bb in enumerate(raw_bboxes):
        if bb is None:
            continue
        for d in range(4):
            coords[d][t] = bb[d]

    for d in range(4):
        keyframes = [(t, coords[d][t]) for t in range(T) if coords[d][t] is not None]
        if not keyframes:
            continue

        # Fill before first keyframe.
        first_idx, first_val = keyframes[0]
        for t in range(0, first_idx):
            coords[d][t] = first_val

        # Linear interpolation between keyframes.
        for (i, v0), (j, v1) in zip(keyframes, keyframes[1:]):
            coords[d][i] = v0
            coords[d][j] = v1
            gap = j - i
            if gap <= 1:
                continue
            for t in range(i + 1, j):
                alpha = (t - i) / float(gap)
                interp_val = int(round(v0 + (v1 - v0) * alpha))
                coords[d][t] = interp_val

        # Fill after last keyframe.
        last_idx, last_val = keyframes[-1]
        for t in range(last_idx + 1, T):
            coords[d][t] = last_val

    final_bboxes: List[Optional[tuple[int, int, int, int]]] = [None] * T
    for t in range(T):
        if all(coords[d][t] is not None for d in range(4)):
            final_bboxes[t] = (
                int(coords[0][t]),
                int(coords[1][t]),
                int(coords[2][t]),
                int(coords[3][t]),
            )

    return final_bboxes


def _bboxes_to_masks(
    bboxes: List[Optional[tuple[int, int, int, int]]], H: int, W: int
) -> np.ndarray:
    """Convert per-frame bboxes to binary masks (T, H, W) with 1 inside bbox, 0 outside."""
    T = len(bboxes)
    masks = np.zeros((T, H, W), dtype=np.float32)
    for t, bb in enumerate(bboxes):
        if bb is None:
            continue
        x_min, y_min, x_max, y_max = bb
        y1 = int(max(0, min(y_min, H - 1)))
        y2 = int(max(0, min(y_max, H - 1)))
        x1 = int(max(0, min(x_min, W - 1)))
        x2 = int(max(0, min(x_max, W - 1)))
        if x2 <= x1 or y2 <= y1:
            continue
        masks[t, y1 : y2 + 1, x1 : x2 + 1] = 1.0
    return masks


def _infer_label_path(label_root: str, video_name: str) -> Optional[str]:
    """Infer face-parse label video path from original video filename."""
    base, ext = os.path.splitext(video_name)
    candidates = [
        os.path.join(label_root, base + ".mkv"),
        os.path.join(label_root, base + ".mp4"),
        os.path.join(label_root, base + ".avi"),
        os.path.join(label_root, video_name),
        # Common pattern in this repo: "<name>.mp4.mkv"
        os.path.join(label_root, video_name + ".mkv"),
    ]
    for c in candidates:
        if os.path.exists(c):
            return c
    return None


class OpenHumanVidDataset(Dataset):
    """Dataset for OpenHumanVid with filtered CSV."""
    
    def __init__(self, config: DictConfig, split: str = 'train'):
        self.config = config
        self.split = split
        self.csv_path = config.get('csv_path', '/share/st_workspace/openhumanvid_part/csv/OpenHumanVid_filtered.csv')
        # Default resolution if not specified
        res = config.get('resolution', [720, 1280])
        if isinstance(res, ListConfig):
            res = list(res)
        print("🚩###Dataset Res:", res)
        if isinstance(res, (list, tuple)):
            self.sample_size = list(res)
        else:
            self.sample_size = [720, 1280]
            
        self.n_sample_frames = config.get('n_sample_frames', 65)
        
        self.samples = []
        if os.path.exists(self.csv_path):
            import csv
            with open(self.csv_path, 'r', encoding='utf-8') as f:
                reader = csv.reader(f)
                header = next(reader, None) # Skip header
                for row in reader:
                    if len(row) >= 2:
                        self.samples.append({
                            'video_path': row[0],
                            'prompt': row[1]
                        })
        else:
            print(f"⚠️ CSV not found: {self.csv_path}")
            
        print(f"🎯 OpenHumanVidDataset loaded: {len(self.samples)} samples")
        
    def __len__(self):
        return len(self.samples)
        
    def __getitem__(self, idx):
        sample = self.samples[idx]
        video_path = sample['video_path']
        prompt = sample['prompt']
        
        try:
            # Target resolution
            H, W = self.sample_size[0], self.sample_size[1]
            
            video = load_video_rgb_fchw(
                video_path, 
                (W, H), 
                count=self.n_sample_frames,
                accurate_seek=True
            )
            
            if video is None:
                raise ValueError("Video loading returned None")
            
            if video.shape[0] < self.n_sample_frames:
                # Pad with last frame
                pad_len = self.n_sample_frames - video.shape[0]
                last_frame = video[-1:]
                padding = last_frame.repeat(pad_len, 1, 1, 1)
                video = torch.cat([video, padding], dim=0)
            elif video.shape[0] > self.n_sample_frames:
                video = video[:self.n_sample_frames]
                
            return {
                "pixel_values_vid": video,
                "caption_content": prompt,
                "prompt": prompt,
                "video_length": self.n_sample_frames,
                "video_path": video_path
            }
            
        except Exception as e:
            print(f"⚠️ Error loading {video_path}: {e}")
            # Return a dummy sample to avoid crashing
            new_idx = (idx + 1) % len(self)
            return self.__getitem__(new_idx)


class Hallo3VidwTalkingHeadDataset(Dataset):
    """Dataset for local Hallo3 videos and captions.
    
    Expects a directory structure:
        /mnt/nfs/datasets/hallo3_data/videos   # *.mp4 files
        /mnt/nfs/datasets/hallo3_data/caption  # *.txt captions with same base name
    
    Uses `load_video_rgb_fchw` to load a fixed number of frames.
    Samples whose frame count is smaller than `n_sample_frames` are skipped.
    """

    def __init__(self, config: DictConfig, split: str = "train"):
        self.config = config
        self.split = split

        # Roots for videos and captions
        self.video_root = config.get(
            "video_root", "/mnt/nfs/datasets/hallo3_data/videos"
        )
        self.caption_root = config.get(
            "caption_root", "/mnt/nfs/datasets/hallo3_data/caption"
        )
        self.label_root = config.get(
            "label_root", "/mnt/nfs/datasets/hallo3_data/face_parse_labels"
        )

        # Target resolution [H, W]
        res = config.get("resolution", [720, 1072])
        if isinstance(res, ListConfig):
            res = list(res)
        if isinstance(res, (list, tuple)):
            self.sample_size = list(res)
        else:
            self.sample_size = [720, 1072]

        # Fixed resolution for talking-head clips (default 640x640)
        th_res = config.get("talking_head_resolution", [640, 640])
        if isinstance(th_res, ListConfig):
            th_res = list(th_res)
        if isinstance(th_res, (list, tuple)) and len(th_res) == 2:
            self.talking_head_resolution = [int(th_res[0]), int(th_res[1])]
        else:
            self.talking_head_resolution = [640, 640]

        print("🚩###Dataset Res:", self.sample_size)
        # Number of frames per sample
        self.n_sample_frames = config.get("n_sample_frames", 49)

        # Audio / Wav2Vec2 config (follow TAI2V dataset design)
        self.sample_rate = int(config.get("audio_sample_rate", 16000))
        self.processor_model_id = config.get(
            "audio_feature_model_id", "facebook/wav2vec2-base-960h"
        )
        self.processor = Wav2Vec2Processor.from_pretrained(self.processor_model_id)

        # Additional talking-head sources and sampling probability
        talking_head_prob = float(config.get("talking_head_prob", 0.0))
        self.talking_head_prob = min(max(talking_head_prob, 0.0), 1.0)

        th_roots = config.get(
            "talking_head_roots",
            [
                "/mnt/nfs/datasets/celebv_hq/head_talk",
                "/mnt/nfs/datasets/celebv_hq/head_talk_2",
                "/mnt/nfs/datasets/celebv_hq/lip_sync",
                "/mnt/nfs/datasets/celebv_hq/lip_sync_2",
                "/mnt/nfs/datasets/HDTF/clips",
            ],
        )
        if isinstance(th_roots, ListConfig):
            th_roots = list(th_roots)
        self.talking_head_roots = [r for r in th_roots if r]
        self.talking_head_samples = self._collect_talking_head_videos(
            self.talking_head_roots
        )

        sync_c_cfg = config.get("sync_c_threshold", 7.0)
        sync_d_cfg = config.get("sync_d_threshold", 8.0)
        try:
            self.sync_c_threshold = float(sync_c_cfg)
        except (TypeError, ValueError):
            self.sync_c_threshold = 7.0
        try:
            self.sync_d_threshold = float(sync_d_cfg)
        except (TypeError, ValueError):
            self.sync_d_threshold = 8.0

        mode_cfg = config.get("sync_filter_mode", "tag")
        mode = str(mode_cfg).strip().lower()
        if mode not in {"tag", "only_filter"}:
            mode = "tag"
        self.sync_filter_mode = mode

        self.sync_score_path = config.get(
            "sync_score_path",
            "/raid/yt_workspace/TalkingDataProcess/LipSync/hallo3_1208_scores.jsonl",
        )
        self.syncnet_scores = self._load_syncnet_scores(self.sync_score_path)

        self.samples = []
        if os.path.isdir(self.video_root) and os.path.isdir(self.caption_root):
            for name in sorted(os.listdir(self.video_root)):
                if not name.lower().endswith(".mp4"):
                    continue
                video_path = os.path.join(self.video_root, name)
                base, _ = os.path.splitext(name)
                caption_path = os.path.join(self.caption_root, base + ".txt")
                label_path = (
                    _infer_label_path(self.label_root, name)
                    if os.path.isdir(self.label_root)
                    else None
                )
                # Strictly require all three paths to exist at indexing time
                if (
                    os.path.exists(video_path)
                    and os.path.exists(caption_path)
                    and label_path is not None
                    and os.path.exists(label_path)
                ):
                    sync_tag = self._get_sync_tag(video_path)
                    if not self._tag_passes_filter(sync_tag):
                        continue
                    self.samples.append(
                        {
                            "video_path": video_path,
                            "caption_path": caption_path,
                            "label_path": label_path,
                            "sync_tag": sync_tag,
                        }
                    )
        else:
            print(
                f"⚠️ Invalid Hallo3 data roots: "
                f"videos={self.video_root}, captions={self.caption_root}"
            )

        print(
            f"🎯 Hallo3VidDataset indexed: {len(self.samples)} Hallo3 samples, "
            f"{len(self.talking_head_samples)} extra talking-head clips, "
            f"prob={self.talking_head_prob:.2f}"
        )
        self._report_filtered_sync_stats()

    def __len__(self):
        return len(self.samples)

    def _collect_talking_head_videos(self, roots: List[str]) -> List[str]:
        allowed_exts = {".mp4", ".mov", ".mkv", ".avi", ".webm"}
        collected: List[str] = []
        for root in roots:
            if not root or not os.path.isdir(root):
                continue
            for curr_dir, _, files in os.walk(root):
                for name in files:
                    ext = os.path.splitext(name)[1].lower()
                    if ext not in allowed_exts:
                        continue
                    collected.append(os.path.join(curr_dir, name))
        return collected

    def _load_syncnet_scores(self, score_path: Optional[str]) -> dict:
        scores: dict = {}
        if not score_path:
            return scores
        if not os.path.isfile(score_path):
            print(f"⚠️ Sync score file not found: {score_path}")
            return scores

        try:
            with open(score_path, "r", encoding="utf-8") as f:
                for line_idx, line in enumerate(f, 1):
                    line = line.strip()
                    if not line:
                        continue
                    try:
                        record = json.loads(line)
                    except json.JSONDecodeError as e:
                        print(
                            f"⚠️ Failed to parse sync score line {line_idx} in "
                            f"{score_path}: {e}"
                        )
                        continue

                    video_path = record.get("video")
                    if not video_path:
                        continue
                    normalized_path = os.path.abspath(os.path.realpath(video_path))
                    sync_c = record.get("sync_c_score")
                    sync_d = record.get("sync_d_score")
                    scores[normalized_path] = {
                        "sync_c_score": sync_c,
                        "sync_d_score": sync_d,
                        "tag": self._evaluate_sync_tag(sync_c, sync_d),
                    }
        except Exception as e:
            print(f"⚠️ Failed to load sync scores from {score_path}: {e}")
            return {}

        print(f"🎯 Loaded {len(scores)} sync entries from {score_path}")
        return scores

    def _evaluate_sync_tag(
        self, sync_c_score: Optional[float], sync_d_score: Optional[float]
    ) -> str:
        try:
            sync_c = float(sync_c_score)
            sync_d = float(sync_d_score)
        except (TypeError, ValueError):
            return "I"

        if sync_c > self.sync_c_threshold and sync_d < self.sync_d_threshold:
            return "A"
        return "I"

    def _get_sync_tag(self, video_path: Optional[str]) -> str:
        if not video_path:
            return "I"
        normalized_path = os.path.abspath(os.path.realpath(video_path))
        entry = self.syncnet_scores.get(normalized_path)
        if entry is None:
            return "I"
        return entry.get("tag", "I") or "I"

    def _tag_passes_filter(self, tag: str) -> bool:
        if self.sync_filter_mode == "only_filter":
            return tag == "A"
        return True

    def _report_filtered_sync_stats(self) -> None:
        filtered_entries = [
            entry
            for entry in self.syncnet_scores.values()
            if entry.get("tag") == "A"
        ]

        def _collect_values(key: str) -> List[float]:
            values: List[float] = []
            for entry in filtered_entries:
                try:
                    values.append(float(entry.get(key)))
                except (TypeError, ValueError):
                    continue
            return values

        def _format_stats(values: List[float]) -> tuple[int, float, float, float]:
            if not values:
                return 0, float("nan"), float("nan"), float("nan")
            count = len(values)
            return count, min(values), max(values), sum(values) / count

        c_values = _collect_values("sync_c_score")
        d_values = _collect_values("sync_d_score")

        c_count, c_min, c_max, c_mean = _format_stats(c_values)
        d_count, d_min, d_max, d_mean = _format_stats(d_values)

        print(
            f"📊 Filtered sync_c_score: count={c_count}, min={c_min:.3f}, max={c_max:.3f}, mean={c_mean:.3f}"
        )
        print(
            f"📊 Filtered sync_d_score: count={d_count}, min={d_min:.3f}, max={d_max:.3f}, mean={d_mean:.3f}"
        )

    def _getitem_talking_head(self) -> Optional[dict]:
        if not self.talking_head_samples:
            return None

        num_trials = min(8, len(self.talking_head_samples))
        th_H, th_W = self.talking_head_resolution[0], self.talking_head_resolution[1]

        for _ in range(num_trials):
            sample_idx = random.randint(0, len(self.talking_head_samples) - 1)
            video_path = self.talking_head_samples[sample_idx]

            try:
                vr = VideoReader(video_path)
                total_frames = len(vr)
                if total_frames < self.n_sample_frames:
                    continue

                max_start = total_frames - self.n_sample_frames
                start = random.randint(0, max_start) if max_start > 0 else 0

                video = load_video_rgb_fchw(
                    video_path,
                    (th_W, th_H),
                    start=start,
                    count=self.n_sample_frames,
                    accurate_seek=True,
                )

                if video is None or video.shape[0] < self.n_sample_frames:
                    continue
                if video.shape[0] > self.n_sample_frames:
                    video = video[: self.n_sample_frames]

                try:
                    fps = float(vr.get_avg_fps())
                    if not np.isfinite(fps) or fps <= 0:
                        fps = 25.0
                except Exception:
                    fps = 25.0

                audio_waveform, _ = librosa.load(
                    video_path, sr=self.sample_rate, mono=True
                )
                if audio_waveform.size == 0:
                    continue

                clip_start_time = start / fps
                clip_duration = self.n_sample_frames / fps
                clip_end_time = clip_start_time + clip_duration

                start_sample = int(max(0, clip_start_time * self.sample_rate))
                end_sample = int(max(start_sample, clip_end_time * self.sample_rate))
                end_sample = min(end_sample, audio_waveform.shape[0])

                audio_clip = audio_waveform[start_sample:end_sample]
                if audio_clip.size == 0:
                    audio_clip = audio_waveform
                if audio_clip.size == 0 or _is_audio_silent(audio_clip):
                    continue

                audio_input_values = self.processor(
                    audio_clip,
                    sampling_rate=self.sample_rate,
                    return_tensors="pt",
                ).input_values[0]

                face_mask = torch.zeros(
                    (
                        self.n_sample_frames,
                        1,
                        th_H,
                        th_W,
                    ),
                    dtype=torch.float32,
                )

                caption = "a talking head video"

                sync_tag = self._get_sync_tag(video_path)
                if not self._tag_passes_filter(sync_tag):
                    continue

                return {
                    "pixel_values_vid": video,
                    "face_mask": face_mask,
                    "caption_content": caption,
                    "prompt": caption,
                    "video_length": self.n_sample_frames,
                    "video_path": video_path,
                    "audio_input_values": audio_input_values,
                    "audio_sample_rate": self.sample_rate,
                    "audio_num_samples": int(audio_clip.shape[0]),
                    "sync_tag": sync_tag,
                }

            except Exception as e:
                print(f"⚠️ Error loading talking-head clip {video_path}: {e}")
                continue

        return None

    def _load_caption(self, caption_path: str) -> str:
        try:
            with open(caption_path, "r", encoding="utf-8") as f:
                text = f.read()
            return text.strip()
        except Exception as e:
            print(f"⚠️ Failed to read caption {caption_path}: {e}")
            return ""

    def __getitem__(self, idx):
        if len(self.samples) == 0:
            raise IndexError("Hallo3VidDataset has no samples")

        if (
            self.talking_head_prob > 0
            and self.talking_head_samples
            and random.random() < self.talking_head_prob
        ):
            talking_head_sample = self._getitem_talking_head()
            if talking_head_sample is not None:
                return talking_head_sample

        # Try a few times in case of short or broken videos
        num_trials = min(8, len(self.samples))
        for _ in range(num_trials):
            sample = self.samples[idx]
            video_path = sample["video_path"]
            caption_path = sample["caption_path"]
            label_path = sample["label_path"]
            sync_tag = sample.get("sync_tag", self._get_sync_tag(video_path))
            if not self._tag_passes_filter(sync_tag):
                idx = (idx + 1) % len(self.samples)
                continue

            try:
                # Read face-parse label video and compute lip bboxes
                labels = _read_labels_from_video(label_path)
                if labels is None or labels.ndim != 3:
                    print(f"⚠️ Skipping {video_path}: failed to read labels {label_path}")
                    idx = (idx + 1) % len(self.samples)
                    continue

                T_lab, H_lab, W_lab = labels.shape
                if T_lab < self.n_sample_frames:
                    print(
                        f"⚠️ Skipping {video_path}: "
                        f"label_frames={T_lab}, required={self.n_sample_frames}"
                    )
                    idx = (idx + 1) % len(self.samples)
                    continue

                bboxes = _compute_lip_bboxes(labels)
                if not any(bb is not None for bb in bboxes):
                    print(f"⚠️ Skipping {video_path}: no valid lip bboxes in labels")
                    idx = (idx + 1) % len(self.samples)
                    continue

                # Probe total frame count of original video
                vr = VideoReader(video_path)
                total_frames = len(vr)

                # Both label and video must have enough frames
                max_start_total = min(total_frames, T_lab) - self.n_sample_frames
                if max_start_total < 0:
                    print(
                        f"⚠️ Skipping {video_path}: "
                        f"video_frames={total_frames}, label_frames={T_lab}, "
                        f"required={self.n_sample_frames}"
                    )
                    idx = (idx + 1) % len(self.samples)
                    continue

                # Randomly choose a valid start index shared by video and labels
                if max_start_total > 0:
                    start = int(
                        torch.randint(
                            0, max_start_total + 1, (1,), dtype=torch.int64
                        ).item()
                    )
                else:
                    start = 0

                H, W = self.sample_size[0], self.sample_size[1]

                video = load_video_rgb_fchw(
                    video_path,
                    (W, H),
                    start=start,
                    count=self.n_sample_frames,
                    accurate_seek=True,
                )

                # Skip samples that fail to load or are too short
                if video is None or video.shape[0] < self.n_sample_frames:
                    print(
                        f"⚠️ Skipping {video_path}: "
                        f"frames={0 if video is None else video.shape[0]}, "
                        f"required={self.n_sample_frames}"
                    )
                    idx = (idx + 1) % len(self.samples)
                    continue

                # If more frames were returned, truncate to requested count
                if video.shape[0] > self.n_sample_frames:
                    video = video[: self.n_sample_frames]

                # Audio clip aligned to the sampled RGB window
                try:
                    fps = float(vr.get_avg_fps())
                    if not np.isfinite(fps) or fps <= 0:
                        fps = 25.0
                except Exception:
                    fps = 25.0

                # Read mono audio, resampled to dataset sample_rate
                audio_waveform, _ = librosa.load(
                    video_path, sr=self.sample_rate, mono=True
                )

                # Map frame window [start, start + n_sample_frames) to audio samples
                clip_start_time = start / fps
                clip_duration = self.n_sample_frames / fps
                clip_end_time = clip_start_time + clip_duration

                start_sample = int(max(0, clip_start_time * self.sample_rate))
                end_sample = int(max(start_sample, clip_end_time * self.sample_rate))
                end_sample = min(end_sample, audio_waveform.shape[0])

                audio_clip = audio_waveform[start_sample:end_sample]
                if audio_clip.size == 0:
                    audio_clip = audio_waveform

                # Skip silent audio clips
                if _is_audio_silent(audio_clip):
                    print(f"⚠️ Skipping {video_path}: audio clip is silent")
                    idx = (idx + 1) % len(self.samples)
                    continue

                audio_input_values = self.processor(
                    audio_clip,
                    sampling_rate=self.sample_rate,
                    return_tensors="pt",
                ).input_values[0]

                # Build lip-region mask from bboxes and align to sampled window / resolution
                bboxes_window = bboxes[start : start + self.n_sample_frames]
                masks_lab = _bboxes_to_masks(bboxes_window, H_lab, W_lab)  # (F, H_lab, W_lab)

                # Resize masks to match video resolution if needed
                if (H_lab, W_lab) != (H, W):
                    resized_masks = np.zeros(
                        (self.n_sample_frames, H, W), dtype=np.float32
                    )
                    for i in range(self.n_sample_frames):
                        resized_masks[i] = cv2.resize(
                            masks_lab[i],
                            (W, H),
                            interpolation=cv2.INTER_NEAREST,
                        )
                    masks_lab = resized_masks

                face_mask = torch.from_numpy(masks_lab).unsqueeze(1).float()

                caption = self._load_caption(caption_path)

                return {
                    "pixel_values_vid": video,  # [F, C, H, W] in [-1, 1]
                    "face_mask": face_mask,  # [F, 1, H, W], 1 inside lip bbox, 0 outside
                    "caption_content": caption,
                    "prompt": caption,
                    "video_length": self.n_sample_frames,
                    "video_path": video_path,
                    "audio_input_values": audio_input_values,
                    "audio_sample_rate": self.sample_rate,
                    "audio_num_samples": int(audio_clip.shape[0]),
                    "sync_tag": sync_tag,
                }

            except Exception as e:
                print(f"⚠️ Error loading {video_path}: {e}")
                idx = (idx + 1) % len(self.samples)
                continue

        # If all trials fail, raise to signal issue upstream
        raise RuntimeError("No valid Hallo3 samples with sufficient frames found.")