src/data/mmdf_dataset.py

"""MMDF (test-only) deepfake dataset.

Layout (verified on 2026-06-03):

    <root>/test/fake/<generator>/*.mp4    label=1
    <root>/test/real/<generator>/*.mp4    label=0     (paired with fake by basename
                                                       within each generator)

Each generator has its own paired (real, fake) split — same basename means a
fake video for that real, but different generators DO NOT share basenames.

Audio is embedded in the mp4. We expect wav files pre-extracted to
    <root>/_audio/test/fake/<generator>/<basename>.wav
    <root>/_audio/test/real/<generator>/<basename>.wav
via scripts/prepare_mmdf_audio.sh. If a wav is missing we fall back to silence
(mirroring FFPPTestDataset behavior); audio-related ablation variants would be
misleading in that case, so prepare audio first.
"""
from __future__ import annotations

import warnings
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Sequence

import torch
from torch.utils.data import Dataset

from .fairtalking_dataset import load_video_clip, load_audio_clip


DEFAULT_MMDF_GENERATORS = ("aniportrait", "hunyuan", "megactor-s")


class MMDFTestDataset(Dataset):
    """Test-only dataset for MMDF.

    Returns per sample:
        video:   (T, 3, H, W) float
        audio:   (S,) float
        label:   int (0 = real, 1 = fake)
        meta:    dict with generator + basename + video_path
    """

    def __init__(
        self,
        root: str,
        generators: Sequence[str] = DEFAULT_MMDF_GENERATORS,
        num_frames: int = 16,
        frame_stride: int = 2,
        frame_size: int = 224,
        audio_seconds: float = 2.56,
        audio_sample_rate: int = 16000,
        include_real: bool = True,
        max_fake_per_generator: Optional[int] = None,
        max_real_per_generator: Optional[int] = None,
        audio_cache_dir: Optional[str] = None,
        video_transform: Optional[Callable] = None,
    ) -> None:
        super().__init__()
        self.root = Path(root)
        self.generators = tuple(generators)
        self.num_frames = num_frames
        self.frame_stride = frame_stride
        self.frame_size = frame_size
        self.audio_seconds = audio_seconds
        self.audio_sample_rate = audio_sample_rate
        self.video_transform = video_transform
        # Audio cache dir defaults to <root>/_audio so the extraction script
        # only needs to be told the root.
        self.audio_cache_dir = (
            Path(audio_cache_dir) if audio_cache_dir is not None
            else self.root / "_audio"
        )

        self.include_real = include_real
        self.max_fake_per_generator = max_fake_per_generator
        self.max_real_per_generator = max_real_per_generator

        self.samples: List[Dict[str, Any]] = self._build_samples()
        if not self.samples:
            warnings.warn(
                f"[MMDFTestDataset] no samples discovered under {self.root}/test/; "
                f"check that test/fake/<gen>/*.mp4 exists. Generators={self.generators}"
            )

    # ------------------------------------------------------------------
    def _build_samples(self) -> List[Dict[str, Any]]:
        samples: List[Dict[str, Any]] = []

        fake_root = self.root / "test" / "fake"
        # NOTE: real path is HARD-CODED relative to fake_root. Caller does not
        # need to (and cannot) override this from yaml — that's intentional,
        # because the previous yaml schema was wrong about real path.
        real_root = self.root / "test" / "real"

        for generator in self.generators:
            fake_dir = fake_root / generator
            if not fake_dir.exists():
                warnings.warn(
                    f"[MMDFTestDataset] fake dir not found: {fake_dir}"
                )
                continue
            mp4_files = sorted(fake_dir.glob("*.mp4"))
            if self.max_fake_per_generator is not None:
                mp4_files = mp4_files[: self.max_fake_per_generator]
            for mp4_path in mp4_files:
                samples.append({
                    "video_path": str(mp4_path),
                    "label": 1,
                    "generator": generator,
                    "basename": mp4_path.stem,
                })

            if self.include_real:
                real_dir = real_root / generator
                if not real_dir.exists():
                    warnings.warn(
                        f"[MMDFTestDataset] real dir not found: {real_dir}; "
                        f"only fake samples will be used for {generator}, "
                        f"per-generator AUC will be ill-defined."
                    )
                    continue
                real_mp4_files = sorted(real_dir.glob("*.mp4"))
                if self.max_real_per_generator is not None:
                    real_mp4_files = real_mp4_files[: self.max_real_per_generator]
                for mp4_path in real_mp4_files:
                    samples.append({
                        "video_path": str(mp4_path),
                        "label": 0,
                        # Tag real videos with the generator they were paired
                        # against, so per-generator metrics still aggregate
                        # cleanly. (Same basename is a fake of a different
                        # generator's pair, but each generator owns its real
                        # subset here, so this is safe.)
                        "generator": f"real/{generator}",
                        "basename": mp4_path.stem,
                    })

        return samples

    # ------------------------------------------------------------------
    def __len__(self) -> int:
        return len(self.samples)

    def _audio_path_for(self, video_path: str) -> Optional[str]:
        """Map <root>/test/fake/<gen>/<bn>.mp4 → <audio_cache>/test/fake/<gen>/<bn>.wav."""
        if self.audio_cache_dir is None:
            return None
        try:
            rel = Path(video_path).relative_to(self.root)
        except ValueError:
            rel = Path(Path(video_path).name)
        return str(self.audio_cache_dir / rel.with_suffix(".wav"))

    def _load_sample(self, vpath: str):
        video = load_video_clip(
            vpath, self.num_frames, self.frame_stride, self.frame_size,
        )
        if self.video_transform is not None:
            video = self.video_transform(video)

        apath = self._audio_path_for(vpath)
        if apath is not None and Path(apath).exists():
            audio = load_audio_clip(apath, self.audio_seconds, self.audio_sample_rate)
        else:
            # Audio cache missing → silence. This is correct behavior but
            # makes audio-related variants (M2_audio_only / M6_drop_audio_infer
            # / etc.) misleading. Run scripts/prepare_mmdf_audio.sh first.
            audio = torch.zeros(int(self.audio_seconds * self.audio_sample_rate))
        return video, audio

    def __getitem__(self, idx: int) -> Dict[str, Any]:
        sample = self.samples[idx]
        try:
            video, audio = self._load_sample(sample["video_path"])
        except Exception as e:
            warnings.warn(
                f"[MMDFTestDataset] skipping bad sample idx={idx} "
                f"basename={sample['basename']}: {e}"
            )
            return self.__getitem__((idx + 1) % len(self))

        return {
            "video": video,
            "audio": audio,
            "label": int(sample["label"]),
            "meta": {
                "basename": sample["basename"],
                "generator": sample["generator"],
                "num": sample["basename"],
                "driving": "",
                "video_path": sample["video_path"],
            },
        }