"""FaceForensics++ test dataset. This module provides a standalone dataset class to run inference on the FaceForensics++ (FF++) dataset. We deliberately do NOT reuse the TalkingHeadBench file layout: videos are scanned directly from the native FF++ directory tree, which looks like: /manipulated_sequences//c23/videos/*.mp4 (fake, label=1) /original_sequences/youtube/c23/videos/*.mp4 (real, label=0, optional) FF++ videos do not carry audio that matches our FairTalking pipeline, so the dataset returns silent audio for every sample (no audio cache needed). The whole set is treated as a *test-only* dataset; we never split train/val here. """ from __future__ import annotations import warnings from pathlib import Path from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple import torch from torch.utils.data import Dataset from .fairtalking_dataset import load_video_clip, load_audio_clip # Default generator directories inside /manipulated_sequences/ DEFAULT_FFPP_GENERATORS: Tuple[str, ...] = ( "Deepfakes", "Face2Face", "FaceSwap", "NeuralTextures", ) # Default relative path for real (pristine) videos DEFAULT_FFPP_REAL_REL = "original_sequences/youtube/c23/videos" # Relative path template for fake videos of a given generator def _fake_dir_for(generator: str, compression: str = "c23") -> str: return f"manipulated_sequences/{generator}/{compression}/videos" class FFPPTestDataset(Dataset): """Standalone FaceForensics++ test dataset. Returns per sample: video: (T, 3, H, W) float audio: (S,) float (silent; FF++ has no paired audio in this layout) label: int (0 = real, 1 = fake) meta: dict with generator + basename + video_path """ def __init__( self, root: str, generators: Sequence[str] = DEFAULT_FFPP_GENERATORS, compression: str = "c23", 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, real_rel_dir: Optional[str] = None, real_root: Optional[str] = None, max_fake_per_generator: Optional[int] = None, max_real: 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.compression = compression 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 self.audio_cache_dir = Path(audio_cache_dir) if audio_cache_dir else None self.include_real = include_real self.real_rel_dir = real_rel_dir or DEFAULT_FFPP_REAL_REL # `real_root` lets callers point real videos to a completely different # directory than `root` (e.g. TalkingHeadBench's FF++ real copy). # When set, real videos are read from `//*.mp4` # (or directly from `/*.mp4` if already points at # the videos folder -- we try the nested path first, then fall back). self.real_root = Path(real_root) if real_root else None # Optional caps (useful to keep test set balanced, e.g. 200 reals to # match 200 fakes per generator). self.max_fake_per_generator = max_fake_per_generator self.max_real = max_real self.samples: List[Dict[str, Any]] = self._build_samples() if not self.samples: warnings.warn( f"[FFPPTestDataset] no samples discovered under {self.root}; " f"check that manipulated_sequences//{compression}/videos/*.mp4 exists." ) # ------------------------------------------------------------------ def _build_samples(self) -> List[Dict[str, Any]]: samples: List[Dict[str, Any]] = [] # ---- fake videos -------------------------------------------------- for generator in self.generators: gen_dir = self.root / _fake_dir_for(generator, self.compression) if not gen_dir.exists(): warnings.warn(f"[FFPPTestDataset] fake dir not found: {gen_dir}") continue mp4_files = sorted(gen_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, }) # ---- real videos (optional) -------------------------------------- if self.include_real: real_dir = self._resolve_real_dir() if real_dir is not None and real_dir.exists(): mp4_files = sorted(real_dir.glob("*.mp4")) if self.max_real is not None: mp4_files = mp4_files[: self.max_real] for mp4_path in mp4_files: samples.append({ "video_path": str(mp4_path), "label": 0, "generator": "real/FFPP", "basename": mp4_path.stem, }) else: warnings.warn( f"[FFPPTestDataset] real dir not found (tried {real_dir}); " f"only fake samples will be used, test/auc will be meaningless." ) return samples def _resolve_real_dir(self) -> Optional[Path]: """Find the directory that actually contains real .mp4 files. Probe order: 1. / (both configured) 2. (real_root already points at videos) 3. / (legacy default) Return the first existing path, or None if nothing is found. """ candidates: List[Path] = [] if self.real_root is not None: candidates.append(self.real_root / self.real_rel_dir) candidates.append(self.real_root) candidates.append(self.root / self.real_rel_dir) for c in candidates: if c.exists() and any(c.glob("*.mp4")): return c # Fall back to the preferred path even if empty so the warning is # useful to the user. return candidates[0] if candidates else None # ------------------------------------------------------------------ def __len__(self) -> int: return len(self.samples) def _audio_path_for(self, video_path: str) -> Optional[str]: 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) -> Tuple[torch.Tensor, torch.Tensor]: 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: # FF++ videos in this layout have no paired audio cache; use silence. 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"[FFPPTestDataset] 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"], }, }