"""MMDF (test-only) deepfake dataset. Layout (verified on 2026-06-03): /test/fake//*.mp4 label=1 /test/real//*.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 /_audio/test/fake//.wav /_audio/test/real//.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 /_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//*.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 /test/fake//.mp4 → /test/fake//.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"], }, }