| """Extract and normalize audio from video files using FFmpeg. |
| |
| The extractor shells out to the ``ffmpeg`` binary (the most reliable way to |
| handle the full range of container/codec combinations) and produces mono, |
| 16 kHz, 16-bit PCM WAV — the canonical input for ASR/TTS pipelines. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import shutil |
| import subprocess |
| from dataclasses import dataclass |
| from functools import lru_cache |
| from pathlib import Path |
| from typing import Optional |
|
|
| import numpy as np |
|
|
| from video_vec2wav2_tokenizer.utils.io import ensure_dir |
| from video_vec2wav2_tokenizer.utils.logging import get_logger |
|
|
| logger = get_logger(__name__) |
|
|
|
|
| @lru_cache(maxsize=1) |
| def ffmpeg_available() -> bool: |
| """Return True if the ffmpeg binary is on PATH.""" |
| return shutil.which("ffmpeg") is not None |
|
|
|
|
| class FFmpegError(RuntimeError): |
| """Raised when an ffmpeg invocation fails.""" |
|
|
|
|
| @dataclass(slots=True) |
| class AudioExtractor: |
| """Convert video files to normalized WAV audio.""" |
|
|
| sample_rate: int = 16000 |
| channels: int = 1 |
| overwrite: bool = False |
|
|
| def __post_init__(self) -> None: |
| if not ffmpeg_available(): |
| raise FFmpegError( |
| "ffmpeg not found on PATH. Install it (https://ffmpeg.org/download.html) " |
| "and ensure `ffmpeg` is callable." |
| ) |
|
|
| def extract(self, video_path: str | Path, output_path: str | Path) -> Path: |
| """Extract audio from ``video_path`` to ``output_path`` (PCM WAV). |
| |
| Returns the output path. Skips work if the file already exists and |
| ``overwrite`` is False. |
| """ |
| video_path = Path(video_path) |
| output_path = Path(output_path) |
| if not video_path.exists(): |
| raise FileNotFoundError(f"Video not found: {video_path}") |
|
|
| ensure_dir(output_path.parent) |
| if output_path.exists() and not self.overwrite: |
| logger.debug("Audio already extracted, skipping: %s", output_path) |
| return output_path |
|
|
| cmd = [ |
| "ffmpeg", |
| "-hide_banner", |
| "-loglevel", "error", |
| "-y" if self.overwrite else "-n", |
| "-i", str(video_path), |
| "-vn", |
| "-ac", str(self.channels), |
| "-ar", str(self.sample_rate), |
| "-acodec", "pcm_s16le", |
| "-f", "wav", |
| str(output_path), |
| ] |
| logger.debug("Running ffmpeg: %s", " ".join(cmd)) |
| proc = subprocess.run(cmd, capture_output=True, text=True) |
| if proc.returncode != 0: |
| |
| if output_path.exists() and not self.overwrite: |
| return output_path |
| raise FFmpegError( |
| f"ffmpeg failed for {video_path} (exit {proc.returncode}): {proc.stderr.strip()}" |
| ) |
| return output_path |
|
|
|
|
| def extract_audio( |
| video_path: str | Path, |
| output_path: str | Path, |
| *, |
| sample_rate: int = 16000, |
| channels: int = 1, |
| overwrite: bool = False, |
| ) -> Path: |
| """Convenience wrapper around :class:`AudioExtractor`.""" |
| extractor = AudioExtractor( |
| sample_rate=sample_rate, channels=channels, overwrite=overwrite |
| ) |
| return extractor.extract(video_path, output_path) |
|
|
|
|
| def load_wav( |
| path: str | Path, *, sample_rate: Optional[int] = None |
| ) -> tuple[np.ndarray, int]: |
| """Load a WAV file as float32 mono samples in ``[-1, 1]``. |
| |
| Uses ``soundfile`` if available, falling back to the stdlib ``wave`` module |
| so the core pipeline works without heavy dependencies. |
| """ |
| path = Path(path) |
| try: |
| import soundfile as sf |
|
|
| data, sr = sf.read(str(path), dtype="float32", always_2d=False) |
| if data.ndim > 1: |
| data = data.mean(axis=1) |
| except ImportError: |
| import wave |
|
|
| with wave.open(str(path), "rb") as wf: |
| sr = wf.getframerate() |
| n_frames = wf.getnframes() |
| sampwidth = wf.getsampwidth() |
| n_channels = wf.getnchannels() |
| raw = wf.readframes(n_frames) |
| dtype = {1: np.int8, 2: np.int16, 4: np.int32}.get(sampwidth) |
| if dtype is None: |
| raise ValueError(f"Unsupported PCM sample width: {sampwidth} bytes") |
| ints = np.frombuffer(raw, dtype=dtype).astype(np.float32) |
| max_val = float(np.iinfo(dtype).max) |
| data = ints / max_val |
| if n_channels > 1: |
| data = data.reshape(-1, n_channels).mean(axis=1) |
|
|
| if sample_rate is not None and sr != sample_rate: |
| data = _resample(data, sr, sample_rate) |
| sr = sample_rate |
| return data.astype(np.float32, copy=False), sr |
|
|
|
|
| def _resample(data: np.ndarray, src_sr: int, dst_sr: int) -> np.ndarray: |
| """Resample audio. Prefers librosa; falls back to linear interpolation.""" |
| if src_sr == dst_sr: |
| return data |
| try: |
| import librosa |
|
|
| return librosa.resample(data, orig_sr=src_sr, target_sr=dst_sr) |
| except ImportError: |
| duration = data.shape[0] / src_sr |
| n_target = int(round(duration * dst_sr)) |
| src_idx = np.linspace(0.0, data.shape[0] - 1, num=n_target) |
| return np.interp(src_idx, np.arange(data.shape[0]), data).astype(np.float32) |
|
|
