| """Extract an auditable prosody profile from a GLaDOS reference clip.""" |
| import argparse |
| import json |
| import subprocess |
| from pathlib import Path |
|
|
| import librosa |
| import numpy as np |
| import soundfile as sf |
|
|
|
|
| def finite_percentiles(values, percentiles): |
| values = np.asarray(values) |
| values = values[np.isfinite(values)] |
| if len(values) == 0: |
| return [None for _ in percentiles] |
| return [round(float(x), 3) for x in np.percentile(values, percentiles)] |
|
|
|
|
| def analyze(path: Path, text: str | None = None) -> dict: |
| audio, sr = librosa.load(str(path), sr=16000, mono=True) |
| duration = len(audio) / sr |
| hop = 160 |
| f0, voiced, _ = librosa.pyin( |
| audio, |
| fmin=65, |
| fmax=500, |
| sr=sr, |
| frame_length=1024, |
| hop_length=hop, |
| ) |
| rms = librosa.feature.rms(y=audio, frame_length=1024, hop_length=hop)[0] |
| rms_db = librosa.amplitude_to_db(np.maximum(rms, 1e-8), ref=1.0) |
| centroid = librosa.feature.spectral_centroid(y=audio, sr=sr, hop_length=hop)[0] |
| flatness = librosa.feature.spectral_flatness(y=audio, hop_length=hop)[0] |
| intervals = librosa.effects.split(audio, top_db=32, frame_length=1024, hop_length=hop) |
| pauses = [] |
| for left, right in zip(intervals, intervals[1:]): |
| start = right[0] / sr |
| end = left[1] / sr |
| if start - end >= 0.08: |
| pauses.append({"start": round(end, 3), "end": round(start, 3), "duration": round(start - end, 3)}) |
|
|
| voiced_f0 = f0[np.isfinite(f0) & voiced] |
| times = np.arange(len(f0)) * hop / sr |
| valid = np.isfinite(f0) |
| contour_times = np.linspace(0, duration, 20) |
| if valid.any(): |
| contour_f0 = np.interp(contour_times, times[valid], f0[valid]) |
| else: |
| contour_f0 = np.full_like(contour_times, np.nan) |
| energy_times = np.arange(len(rms_db)) * hop / sr |
| contour_energy = np.interp(contour_times, energy_times, rms_db) |
|
|
| profile = { |
| "file": str(path), |
| "sample_rate_for_analysis": sr, |
| "duration_sec": round(duration, 3), |
| "voiced_fraction": round(float(np.mean(voiced)), 3), |
| "pause_map": pauses, |
| "f0_hz": { |
| "median": finite_percentiles(voiced_f0, [50])[0], |
| "p10_p90": finite_percentiles(voiced_f0, [10, 90]), |
| "contour_20_points": [round(float(x), 2) for x in contour_f0], |
| }, |
| "energy_db": { |
| "p10_p50_p90": finite_percentiles(rms_db, [10, 50, 90]), |
| "dynamic_range_db": round(float(np.percentile(rms_db, 90) - np.percentile(rms_db, 10)), 3), |
| "contour_20_points": [round(float(x), 2) for x in contour_energy], |
| }, |
| "timbral_proxies": { |
| "spectral_centroid_hz_median": finite_percentiles(centroid, [50])[0], |
| "spectral_flatness_median": finite_percentiles(flatness, [50])[0], |
| }, |
| "interpretation": { |
| "target": "soft, close-mic, restrained mechanical delivery", |
| "sarcasm": "low-to-moderate pitch movement with deliberate clause-final timing", |
| "smile": "look for local energy/brightness lift around emphasized words; do not synthesize a broad cheerful smile", |
| }, |
| } |
| if text: |
| profile["text"] = text |
| profile["text_chars_per_sec"] = round(len(text) / duration, 3) |
| return profile |
|
|
|
|
| def warp_duration(source: Path, reference: Path, output: Path) -> None: |
| reference_duration = librosa.get_duration(path=str(reference)) |
| output.parent.mkdir(parents=True, exist_ok=True) |
| subprocess.run( |
| [ |
| "rubberband", |
| "-3", |
| "-D", |
| f"{reference_duration:.6f}", |
| str(source), |
| str(output), |
| ], |
| check=True, |
| stdout=subprocess.DEVNULL, |
| stderr=subprocess.DEVNULL, |
| ) |
| audio, sr = sf.read(output, always_2d=False) |
| peak = float(np.max(np.abs(audio))) |
| if peak > 0.95: |
| audio = audio * (0.95 / peak) |
| sf.write(output, audio, sr, subtype="PCM_16") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--reference", type=Path, required=True) |
| parser.add_argument("--source", type=Path) |
| parser.add_argument("--text") |
| parser.add_argument("--output-profile", type=Path, required=True) |
| parser.add_argument("--warp-source", type=Path) |
| args = parser.parse_args() |
|
|
| profile = analyze(args.reference, args.text) |
| if args.source: |
| profile["source"] = analyze(args.source, args.text) |
| args.output_profile.parent.mkdir(parents=True, exist_ok=True) |
| args.output_profile.write_text(json.dumps(profile, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
| if args.warp_source: |
| if not args.source: |
| raise SystemExit("--warp-source requires --source") |
| warp_duration(args.source, args.reference, args.warp_source) |
| print(json.dumps(profile, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
