| """Cut normalized audio into clips according to transcript timestamps.""" |
|
|
| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Iterable, Optional |
|
|
| import numpy as np |
|
|
| from video_vec2wav2_tokenizer.audio.extractor import load_wav |
| from video_vec2wav2_tokenizer.utils.io import Segment, ensure_dir |
| from video_vec2wav2_tokenizer.utils.logging import get_logger |
|
|
| logger = get_logger(__name__) |
|
|
|
|
| def normalize_segments( |
| segments: Iterable[Segment], |
| *, |
| min_length: float = 1.0, |
| max_length: float = 20.0, |
| padding: float = 0.0, |
| total_duration: Optional[float] = None, |
| ) -> list[Segment]: |
| """Filter and split segments to respect length constraints. |
| |
| - Drops segments shorter than ``min_length``. |
| - Splits segments longer than ``max_length`` into equal sub-spans (text is |
| kept on the first sub-span to avoid duplicating words). |
| - Applies symmetric ``padding`` clamped to ``[0, total_duration]``. |
| """ |
| out: list[Segment] = [] |
| for seg in segments: |
| start = max(0.0, seg.start - padding) |
| end = seg.end + padding |
| if total_duration is not None: |
| end = min(end, total_duration) |
| if end <= start: |
| continue |
|
|
| length = end - start |
| if length < min_length: |
| continue |
|
|
| if length <= max_length: |
| out.append(Segment(start=start, end=end, text=seg.text)) |
| continue |
|
|
| |
| n_chunks = int(np.ceil(length / max_length)) |
| chunk = length / n_chunks |
| for i in range(n_chunks): |
| c_start = start + i * chunk |
| c_end = min(end, c_start + chunk) |
| text = seg.text if i == 0 else "" |
| out.append(Segment(start=c_start, end=c_end, text=text)) |
| return out |
|
|
|
|
| @dataclass(slots=True) |
| class Segmenter: |
| """Slice a WAV file into per-segment clips.""" |
|
|
| sample_rate: int = 16000 |
|
|
| def segment_file( |
| self, |
| audio_path: str | Path, |
| segments: list[Segment], |
| output_dir: str | Path, |
| *, |
| start_index: int = 1, |
| index_width: int = 6, |
| ) -> list[tuple[Path, Segment]]: |
| """Write one WAV clip per segment. |
| |
| Returns ``(clip_path, segment)`` pairs. Filenames are zero-padded |
| sequential numbers continuing from ``start_index``. |
| """ |
| output_dir = ensure_dir(output_dir) |
| samples, sr = load_wav(audio_path, sample_rate=self.sample_rate) |
| results: list[tuple[Path, Segment]] = [] |
|
|
| for offset, seg in enumerate(segments): |
| idx = start_index + offset |
| i0 = int(round(seg.start * sr)) |
| i1 = int(round(seg.end * sr)) |
| i0 = max(0, min(i0, samples.shape[0])) |
| i1 = max(i0, min(i1, samples.shape[0])) |
| clip = samples[i0:i1] |
| if clip.size == 0: |
| logger.warning("Empty clip for segment %s, skipping", idx) |
| continue |
|
|
| name = f"{idx:0{index_width}d}.wav" |
| clip_path = output_dir / name |
| _write_wav(clip_path, clip, sr) |
| results.append((clip_path, seg)) |
|
|
| logger.info("Wrote %d clips from %s", len(results), Path(audio_path).name) |
| return results |
|
|
|
|
| def _write_wav(path: Path, samples: np.ndarray, sample_rate: int) -> None: |
| """Write float32 samples as 16-bit PCM WAV (soundfile or stdlib fallback).""" |
| samples = np.clip(samples, -1.0, 1.0) |
| try: |
| import soundfile as sf |
|
|
| sf.write(str(path), samples, sample_rate, subtype="PCM_16") |
| except ImportError: |
| import wave |
|
|
| ints = (samples * 32767.0).astype(np.int16) |
| with wave.open(str(path), "wb") as wf: |
| wf.setnchannels(1) |
| wf.setsampwidth(2) |
| wf.setframerate(sample_rate) |
| wf.writeframes(ints.tobytes()) |
|
|
