Spaces:
Running
Running
File size: 5,027 Bytes
8ea8b32 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | """Sound design + TTS helpers (48 kHz stereo float32)."""
import asyncio, os, subprocess, hashlib
import numpy as np
SR = 48000
CACHE = '/tmp/work/tts'
os.makedirs(CACHE, exist_ok=True)
def tts(text, voice, rate='+0%', pitch='+0Hz'):
"""Return trimmed mono float32 voice clip."""
import edge_tts
tag = hashlib.md5(f"{text}|{voice}|{rate}|{pitch}".encode()).hexdigest()[:12]
mp3 = f"{CACHE}/{tag}.mp3"
if not os.path.exists(mp3) or os.path.getsize(mp3) < 2000:
for _ in range(4):
try:
asyncio.run(edge_tts.Communicate(text, voice, rate=rate, pitch=pitch).save(mp3))
if os.path.getsize(mp3) > 2000:
break
except Exception as e: # network hiccup
print('tts retry', e)
raw = subprocess.run(['ffmpeg', '-v', 'error', '-i', mp3, '-f', 'f32le', '-ac', '1', '-ar', str(SR), '-'],
check=True, capture_output=True).stdout
x = np.frombuffer(raw, dtype=np.float32).astype(np.float64)
env = np.convolve(np.abs(x), np.ones(480) / 480, mode='same')
idx = np.where(env > 0.012)[0]
if len(idx):
a = max(0, idx[0] - 720)
b = min(len(x), idx[-1] + 2400)
x = x[a:b]
f = min(480, len(x) // 4)
x[:f] *= np.linspace(0, 1, f)
x[-f:] *= np.linspace(1, 0, f)
return x / (np.abs(x).max() + 1e-6) * 0.92
def _t(d):
return np.arange(int(SR * d)) / SR
def _onepole_lp(x, fc):
"""Time-varying one-pole low-pass (vectorised in blocks)."""
out = np.empty_like(x)
y = 0.0
blk = 64
for s in range(0, len(x), blk):
a = np.exp(-2 * np.pi * fc[s] / SR)
seg = x[s:s + blk]
for i, v in enumerate(seg):
y = (1 - a) * v + a * y
out[s + i] = y
return out
def whoosh(d=0.45):
t = _t(d)
rng = np.random.default_rng(3)
n = rng.standard_normal(len(t))
fc_hi = 500 + 6500 * (t / d) ** 1.4
fc_lo = 150 + 1800 * (t / d) ** 1.4
band = _onepole_lp(n, fc_hi) - _onepole_lp(n, fc_lo)
env = np.sin(np.pi * np.clip(t / d, 0, 1) ** 0.7) ** 2
out = band * env
return out / (np.abs(out).max() + 1e-6) * 0.42
def tick(i):
"""Plucky marimba-ish tick; pitch climbs a pentatonic scale across the word."""
scale = [0, 2, 4, 7, 9, 12, 14, 16, 19, 21, 24, 26, 28, 31, 33, 36]
f = 587.33 * 2 ** (scale[min(i, len(scale) - 1)] / 12)
t = _t(0.18)
s = np.sin(2 * np.pi * f * t) * 0.8 + np.sin(2 * np.pi * f * 4 * t) * 0.15 * np.exp(-t * 70)
s *= np.exp(-t * 26) * (1 - np.exp(-t * 2000))
return s * 0.30
def chime():
out = np.zeros(int(SR * 1.4))
for k, (f, dt) in enumerate([(1046.5, 0.0), (1318.5, 0.055), (1568.0, 0.11), (2093.0, 0.165)]):
t = _t(1.4 - dt)
tone = np.sin(2 * np.pi * f * t) + 0.35 * np.sin(2 * np.pi * f * 2.76 * t) * np.exp(-t * 9) \
+ 0.15 * np.sin(2 * np.pi * f * 5.4 * t) * np.exp(-t * 16)
tone *= np.exp(-t * 4.0) * (1 - np.exp(-t * 900))
s = int(SR * dt)
out[s:s + len(tone)] += tone * (0.9 - k * 0.12)
return out / np.abs(out).max() * 0.26
def pop():
t = _t(0.12)
f = 1100 * np.exp(-t * 22) + 260
ph = 2 * np.pi * np.cumsum(f) / SR
return np.sin(ph) * np.exp(-t * 32) * (1 - np.exp(-t * 3000)) * 0.32
def shimmer(d=1.0):
rng = np.random.default_rng(11)
out = np.zeros(int(SR * d))
for _ in range(30):
st = rng.uniform(0, d * 0.55)
f = rng.uniform(2800, 6800)
t = _t(0.2)
g = np.sin(2 * np.pi * f * t) * np.exp(-t * 28) * rng.uniform(0.2, 0.5)
s = int(st * SR)
n = min(len(g), len(out) - s)
out[s:s + n] += g[:n]
return out * np.exp(-_t(d) * 2.4) * 0.16
class Mixer:
def __init__(self, dur):
self.buf = np.zeros((int(SR * (dur + 2)), 2), dtype=np.float64)
def add(self, clip, at, gain=1.0, pan=0.0):
s = int(round(at * SR))
n = min(len(clip), len(self.buf) - s)
if n <= 0:
return
l = np.cos((pan + 1) * np.pi / 4) * np.sqrt(2)
r = np.sin((pan + 1) * np.pi / 4) * np.sqrt(2)
self.buf[s:s + n, 0] += clip[:n] * gain * l
self.buf[s:s + n, 1] += clip[:n] * gain * r
def render(self, dur, path):
b = self.buf[:int(round(SR * dur))].copy()
b = np.tanh(b * 1.1) / np.tanh(1.1)
fade = int(SR * 0.06)
b[-fade:] *= np.linspace(1, 0, fade)[:, None]
b[:240] *= np.linspace(0, 1, 240)[:, None]
raw = path + '.f32'
b.astype('<f4').tofile(raw)
subprocess.run(['ffmpeg', '-v', 'error', '-y', '-f', 'f32le', '-ar', str(SR), '-ac', '2', '-i', raw,
'-c:a', 'pcm_s16le', path], check=True)
os.remove(raw)
def envelope(clip, fps=30):
hop = SR // fps
n = len(clip) // hop + 1
e = np.array([np.sqrt(np.mean(clip[i * hop:(i + 1) * hop] ** 2) + 1e-12) if len(clip[i * hop:(i + 1) * hop]) else 0
for i in range(n)])
return np.clip(e / (e.max() + 1e-9), 0, 1)
|