Spaces:
Running
Running
Download app.js from KaleComputer/kale-tts-1: direct link, hf CLI and curl.
- Browser
- Download file 32.3 kB
-
https://huggingface.co/spaces/KaleComputer/kale-tts-1/resolve/main/app.js
- Command line
-
hf download hf://spaces/KaleComputer/kale-tts-1/app.js
-
curl -L -o app.js https://huggingface.co/spaces/KaleComputer/kale-tts-1/resolve/main/app.js
32.3 kB
| // kale-tts-1 space: type -> speech in the browser. nano (default) or tiny, onnxruntime-web 1.31.1 through the kale-tts JS API. | |
| // WebGPU first on desktops (nano's float32 graph); the CPU / wasm (int8) on phones (WebGPU ran an iPhone out of memory in our phone | |
| // tests), and where WebGPU is missing, fails, or crashed before (gpuTrial.js). A failed WebGPU load reloads the page on the CPU, so | |
| // only one runtime is ever in memory. A loaded model stays loaded when you switch to the other one (desktops; phones keep one), and | |
| // its graph stays in the browser's cache, so switching back or reloading doesn't download it again. Everything runs in this tab. | |
| import { Listener, drawHeroLine, onDemandLoop, reducedMotion } from "./visual.js"; | |
| import { Waterfall } from "./waterfall.js"; | |
| import { gpuTrial, webGpuWorks } from "./gpuTrial.js"; | |
| const SR = 24000; | |
| // graph per backend; sha256 per graph file: the key of its copy in the browser's cache (ttsWorker.js), so a new build is downloaded once | |
| const MODELS = { | |
| "kale-tts-1-nano": { params: "7.5M", size: "14.8 MB", graph: { webgpu: "fp32", wasm: "int8" }, shas: { | |
| "model.onnx": "4d5269974de4fba7a66f947608a9a5381b4e39c1a8a6073df6001ab7e7f76288", | |
| "model.fp32.onnx": "34d408a127f35f732a6860db5b1f7e8e1baac43ee3e32874f2007b5c6360e73a" } }, | |
| "kale-tts-1-tiny": { params: "45.7M", size: "79.9 MB", graph: { webgpu: "fp32", wasm: "int8" }, shas: { | |
| "model.onnx": "8f255ef6f2b22c130cce15bdf92c5d420a821b2e5e39dbdef34064d52d6dc495", | |
| "model.fp32.onnx": "885675190d58a5f28f096f4698526fa2a2f2378d9d1897b6b0721596f585f64f" } }, | |
| }; | |
| // the 10 public voices by id: name, what they are, colour (women, then men) | |
| const NAMES = { | |
| s057b: { name: "Kenzie", about: "esports hype woman", c: "#34d399" }, | |
| f06: { name: "Simone", about: "deep and confident woman", c: "#fb923c" }, | |
| d03: { name: "Amy", about: "british woman, crisp news-style", c: "#eab308" }, | |
| w165: { name: "Frankie", about: "hard-boiled detective's partner", c: "#ec4899" }, | |
| w602: { name: "Darlene", about: "rough low-voiced old trucker woman", c: "#a855f7" }, | |
| m3: { name: "Owen", about: "bright young host", c: "#3b82f6" }, | |
| t071: { name: "Toby", about: "mischievous prankster", c: "#22d3ee" }, | |
| d13: { name: "Jack", about: "british man, crisp news-style", c: "#6366f1" }, | |
| x328: { name: "Earl", about: "African American jazz granddad", c: "#8b5cf6" }, | |
| h013f: { name: "Magnus", about: "deep dramatic trailer narrator", c: "#db2777" }, | |
| }; | |
| const PALETTE = ["#34d399", "#f472b6", "#22d3ee", "#facc15", "#a3e635", "#f87171"]; // voices of older builds, not in NAMES | |
| const $ = (s, r = document) => r.querySelector(s), $$ = (s, r = document) => [...r.querySelectorAll(s)]; | |
| const isPhone = /Android|iPhone|iPad|iPod|Mobile/i.test(navigator.userAgent) || (navigator.maxTouchPoints > 1 && /Macintosh/.test(navigator.userAgent)); | |
| const toast = (m) => { const t = $("#toast"); t.textContent = m; t.classList.add("on"); clearTimeout(t._h); t._h = setTimeout(() => t.classList.remove("on"), 3200); }; | |
| // ------------------------------------------------------------------------------------------ audio out | |
| class Player { | |
| constructor() { this.ctx = null; this.src = []; this.segs = []; this.next = 0; this.onend = null; } | |
| async ensure() { | |
| if (!this.ctx) { | |
| this.ctx = new AudioContext({ sampleRate: SR }); this.out = this.ctx.createGain(); this.an = this.ctx.createAnalyser(); | |
| this.an.fftSize = 2048; this.an.smoothingTimeConstant = 0.6; this.out.connect(this.an); this.an.connect(this.ctx.destination); L = new Listener(this.an); | |
| } | |
| if (this.ctx.state !== "running") await this.ctx.resume(); | |
| } | |
| reset() { for (const s of this.src) { try { s.stop(); } catch {} } this.src = []; this.segs = []; this.next = 0; } | |
| push(audio, meta, gap = 0) { | |
| const b = this.ctx.createBuffer(1, audio.length, SR); b.copyToChannel(audio, 0); const s = this.ctx.createBufferSource(); s.buffer = b; s.connect(this.out); | |
| const at = Math.max(this.ctx.currentTime + 0.04, this.next + gap); s.start(at); this.next = at + b.duration; this.src.push(s); this.segs.push({ start: at, end: this.next, meta }); loop.kick(); | |
| s.onended = () => { const i = this.src.indexOf(s); if (i < 0) return; this.src.splice(i, 1); if (!this.src.length) this.onend?.(); }; | |
| } | |
| get now() { return this.ctx ? this.ctx.currentTime : 0; } | |
| get playing() { return this.src.length > 0; } | |
| } | |
| const player = new Player(); let L = null; | |
| window.kaleDemo = { player, get level() { return L ? L.level : 0; } }; // for tests and recordings | |
| // ------------------------------------------------------------------------------------------ where it runs | |
| const gpu = gpuTrial("kale-tts-1", () => toast("WebGPU stopped this tab last time, so this device runs on the CPU now.")); | |
| let hasGpu = false; | |
| const q = new URLSearchParams(location.search); // ?model= ?backend= (tests, and the CPU reload), ?gpufail, ?embed | |
| const preferred = () => (!isPhone && hasGpu && gpu.allowed() && !q.has("gpufail") ? "webgpu" : "wasm"); | |
| /** start over on the CPU in a fresh page: what a WebGPU load left behind (its runtime, GPU memory) goes with the old one */ | |
| function reloadOn(backend, extra = {}) { | |
| const u = new URL(location.href); u.searchParams.set("backend", backend); u.searchParams.delete("gpufail"); | |
| for (const [k, v] of Object.entries(extra)) u.searchParams.set(k, v); | |
| gpu.passed(); location.replace(u); return new Promise(() => {}); | |
| } | |
| const beName = (b) => (b === "webgpu" ? "WebGPU" : "CPU"); | |
| /** the status, for screen readers only: loading, ready, speaking or what went wrong */ | |
| function live(said, busy = false) { | |
| $("#status").textContent = said; // read by screen readers only; loading shows on the model card, errors in a toast | |
| $("#retry").hidden = !(M?.b === "wasm" && hasGpu && gpu.benched() && !busy); | |
| } | |
| // the stats under the model cards: the backend in use, and the first sound and speed of the last sentence played here | |
| const TYPICAL = { "kale-tts-1-nano": [50, 100], "kale-tts-1-tiny": [60, 50] }; | |
| // estimates lead with "≈" | |
| const ms = (v, est) => `${est ? "≈" : ""}${Math.round(v)} ms`, x = (v, est) => `${est ? "≈" : ""}${Math.round(v)}×`; | |
| const typical = (name) => { const [f, r] = TYPICAL[name] ?? [50, 100]; return { first: ms(f, true), rt: x(r, true), typical: true }; }; | |
| function metrics({ be, first, rt, typical } = {}) { | |
| if (be !== undefined) $("#m-be").textContent = be; | |
| if (first !== undefined) $("#m-first").textContent = first; | |
| if (rt !== undefined) $("#m-rt").textContent = rt; | |
| $(".metrics").classList.toggle("typical", !!typical); | |
| if (typical) $(".metrics").title = "typical: an estimate until you press play"; else $(".metrics").removeAttribute("title"); | |
| } | |
| /** the status once a model is ready (for screen readers): ready, or the crash note if WebGPU is benched */ | |
| const idle = () => { | |
| const benched = M.b === "wasm" && hasGpu && gpu.benched(); | |
| const said = heardSaid; heardSaid = null; | |
| live(benched ? "ready, on the CPU: WebGPU is off here after a crash" : said ?? "ready"); | |
| }; | |
| const liveReady = () => { | |
| idle(); | |
| $(".metrics").classList.remove("loading"); | |
| metrics({ be: beName(M.b), ...typical(M.name) }); | |
| }; | |
| // ------------------------------------------------------------------------------------------ the model (one in use, others kept) | |
| let M = null, loading = null, booted = false; // booted: the first use() has started | |
| // loaded models by name + backend: switching back to one is instant (no download, no new session). Phones keep only the one in use | |
| // (memory); its graph is still in the browser's cache there, so loading it again doesn't download it. | |
| const kept = new Map(), keyOf = (name, b) => `${name}|${b}`; | |
| /** the model in its own worker (ttsWorker.js), behind the same small surface the page used before: voices, backend, stream() */ | |
| function workerTTS(name, b, opts) { | |
| const w = new Worker(new URL("./ttsWorker.js", import.meta.url), { type: "module" }); | |
| let seq = 0, loaded = null; const on = new Map(); | |
| w.onmessage = ({ data: m }) => on.get(m.id)?.(m); | |
| w.onerror = (e) => { e.preventDefault?.(); for (const f of on.values()) f({ type: "error", message: e.message || "the model's worker failed" }); | |
| if (loaded && kept.get(keyOf(name, b))?.tts === loaded) kept.delete(keyOf(name, b)); | |
| if (b === "webgpu" && loaded && M?.tts === loaded) reloadOn("wasm", { model: name, gpufail: "1" }); }; | |
| const call = (msg, handler) => { const id = ++seq; on.set(id, handler); w.postMessage({ ...msg, id }); return id; }; | |
| return new Promise((resolve, reject) => call({ type: "load", name, b, shas: MODELS[name].shas, ...opts }, (m) => { | |
| if (m.type === "status") cardState(name, m.text); | |
| else if (m.type === "progress") progress(name, m.got, m.total); | |
| else if (m.type === "error") { w.terminate(); reject(new Error(m.message)); } | |
| else if (m.type === "loaded") resolve(loaded = { | |
| voices: m.voices, backend: { graph: m.graph }, | |
| session: { release: async () => w.terminate() }, | |
| async *stream(text, { voice }) { | |
| const q = []; let wake = null, done = false, err = null; | |
| const id = call({ type: "stream", text, voice }, (x) => { | |
| if (x.type === "chunk") q.push(x); else { done = true; if (x.type === "error") err = new Error(x.message); } | |
| wake?.(); | |
| }); | |
| try { | |
| for (;;) { if (q.length) { yield q.shift(); continue; } if (done) break; await new Promise((r) => (wake = r)); wake = null; } | |
| if (err) throw err; | |
| } finally { on.delete(id); if (!done) w.postMessage({ type: "cancel", id }); } | |
| }, | |
| }); | |
| })); | |
| } | |
| async function openModel(name, b) { | |
| const tts = await workerTTS(name, b, { graph: MODELS[name].graph[b], | |
| threads: self.crossOriginIsolated ? Math.min(4, navigator.hardwareConcurrency || 4) : 1, | |
| sessionOptions: b === "wasm" && isPhone ? { graphOptimizationLevel: "disabled" } : {} }); | |
| return { tts, name, b }; | |
| } | |
| async function use(name, b) { | |
| if (!MODELS[name].graph[b]) b = "wasm"; | |
| if (M && M.name === name && M.b === b) return; | |
| gen++; busy = false; player.reset(); setInert(true); markModel(name); | |
| $$(".mcard").forEach((x) => x.setAttribute("aria-disabled", String(x.dataset.m !== name))); | |
| const old = M; M = null; goState(); gpu.passed(); | |
| if (old && isPhone) { kept.delete(keyOf(old.name, old.b)); try { await old.tts.session.release?.(); } catch {} } // phones: one model in memory | |
| const have = kept.get(keyOf(name, b)); | |
| if (have) { // loaded before: use it again as it is | |
| M = have; if (M.b === "webgpu") gpu.begin(); else gpu.passed(); | |
| $$(".mcard").forEach((x) => x.removeAttribute("aria-disabled")); | |
| $("#loadbar").className = "loadbar off"; cardState(name, null); liveReady(); | |
| buildKeys(M.tts.voices); setInert(false); goState(); return; | |
| } | |
| said50 = false; cardState(name, "starting…", { p: 0 }); | |
| $("#loadbar").className = "loadbar wait"; live(`loading ${name}${b === "webgpu" ? " on WebGPU" : ""}…`, true); | |
| $(".metrics").classList.add("loading"); metrics({ be: beName(b), ...typical(name) }); // while loading: the typical values | |
| if (b === "webgpu") gpu.begin(); | |
| // a GPU that hangs (after a crash, a lost device) must not leave the page loading forever: give up and use the CPU | |
| const hung = new Promise((_, no) => setTimeout(() => no(new Error("WebGPU didn't answer")), b === "webgpu" ? 45000 : 180000)); | |
| try { M = await (loading = Promise.race([openModel(name, b), hung])); } | |
| catch (e) { | |
| console.warn(e); gpu.passed(); | |
| if (b === "webgpu") return reloadOn("wasm", { model: name, gpufail: "1" }); | |
| $("#loadbar").className = "loadbar off"; $(".metrics").classList.remove("loading"); cardState(name, "couldn't load · retry", { error: true }); | |
| live("couldn't load the model · press its card to try again"); toast("Couldn't load the model. Press its card to try again."); return; | |
| } | |
| finally { loading = null; $$(".mcard").forEach((x) => x.removeAttribute("aria-disabled")); } | |
| kept.set(keyOf(name, b), M); | |
| if (M.b === "wasm") gpu.passed(); // on WebGPU the mark stays for as long as the model runs there (see render) | |
| $("#loadbar").className = "loadbar off"; cardState(name, null); liveReady(); | |
| buildKeys(M.tts.voices); setInert(false); goState(); | |
| } | |
| /** the card of the model being loaded shows where it is: a thin bar for the download and a line of text (in place of its traits) */ | |
| function cardState(name, text, { p = null, error = false } = {}) { | |
| const c = $(`.mcard[data-m="${name}"]`); if (!c) return; | |
| const bar = $("#mprogress"); bar.hidden = text == null || error || p == null; bar.setAttribute("aria-label", `Downloading ${name}`); | |
| if (p != null) bar.setAttribute("aria-valuenow", String(Math.round(p * 100))); | |
| c.classList.toggle("busy", text != null); c.classList.toggle("failed", error); | |
| $(".mstate", c).textContent = text ?? ""; | |
| if (p != null) c.style.setProperty("--p", String(p)); else if (text == null) c.style.removeProperty("--p"); | |
| } | |
| let said50 = false; // the status (for screen readers) says it at the start, at half way and when ready, not every percent | |
| function progress(name, got, total) { | |
| const p = total ? Math.min(1, got / total) : null; | |
| // a percentage only: sizes belong to the cards' CPU / GPU facts; a second MB figure next to them read as one of them | |
| cardState(name, p != null ? `downloading ${Math.round(p * 100)}%` : "downloading…", { p: p ?? 0 }); | |
| if (p >= 0.5 && !said50) { said50 = true; live(`downloading ${name} · 50%`, true); } | |
| } | |
| function markModel(name) { | |
| $("#mtitle").textContent = name; document.title = `${name} · speech in your browser`; | |
| $$(".mcard").forEach((x) => { x.setAttribute("aria-checked", String(x.dataset.m === name)); x.tabIndex = x.dataset.m === name ? 0 : -1; }); | |
| fx?.setMode(name.endsWith("tiny") ? 1 : 0); placeHalo(); loop.kick(); // nano: the waterfall; tiny: mountains rising up the page | |
| } | |
| // ------------------------------------------------------------------------------------------ state + ui | |
| let voice = null, keys = [], gen = 0, busy = false; | |
| // the terrain and its waterfall (one shader); without WebGL2 a plain 2D line in the stage | |
| let fx = null; try { fx = new Waterfall($("#fx")); if (!fx.ok) fx = null; } catch (e) { console.warn(e); fx = null; } | |
| document.documentElement.classList.toggle("nofx", !fx); | |
| const look = {}; const colorOf = (id) => look[id]?.c ?? "#34d399"; | |
| function setColor(id) { const c = colorOf(id); document.documentElement.style.setProperty("--vc", c); fx?.setColor(c); } | |
| /** the voice keys. Drawn straight away from the known ten (no keys popping in later); inert until a model is loaded. Redrawn | |
| * only if a loaded model has a different set of voices. */ | |
| const STATIC_VOICES = Object.keys(NAMES).map((id, order) => ({ id, name: NAMES[id].name, order })); | |
| let builtFor = ""; | |
| function buildKeys(list = STATIC_VOICES) { | |
| const vs = [...list].sort((a, b) => (a.order ?? 0) - (b.order ?? 0)); | |
| const ids = vs.map((v) => v.id).join(","); | |
| if (ids === builtFor) return; | |
| builtFor = ids; | |
| vs.forEach((v, i) => { look[v.id] = NAMES[v.id] ?? { name: v.name.split("(")[0].trim(), about: (v.name.match(/\(([^)]*)\)/)?.[1] ?? ""), c: PALETTE[i % PALETTE.length] }; }); | |
| const box = $("#keys"); | |
| box.innerHTML = vs.map((v) => { const l = look[v.id]; | |
| return `<button class="key" data-v="${v.id}" style="--c:${l.c}" aria-label="${l.name}, ${l.about}" title="${l.about}"><kbd></kbd><b>${l.name}</b><small class="own" id="own-${v.id}"></small></button>`; }).join(""); | |
| keys = $$(".key").map((el) => ({ el, id: el.dataset.v })); | |
| keys.forEach((k) => (k.el.onclick = () => speak(k.id))); | |
| labelKeys(); showLines(); | |
| if (!vs.some((v) => v.id === voice)) voice = vs[0].id; select(voice); | |
| } | |
| /** the picked voice: coloured, and current for screen readers (keys replay, they don't toggle) */ | |
| const markSel = (id) => keys.forEach((k) => { k.el.classList.toggle("sel", k.id === id); if (k.id === id) k.el.setAttribute("aria-current", "true"); else k.el.removeAttribute("aria-current"); }); | |
| function select(id) { voice = id; markSel(id); setColor(id); goState(); loop.redraw(); } | |
| /** before a model is ready the keys are there but can't be played */ | |
| function setInert(on) { $("#keys").classList.toggle("inert", on); keys.forEach((k) => (on ? k.el.setAttribute("aria-disabled", "true") : k.el.removeAttribute("aria-disabled"))); } | |
| // ------------------------------------------------------------------------------------------ one line per voice (the a-line-per-voice Off | On picker) | |
| // Off (the default): every voice speaks the text in the composer. On: every voice has its own line, shown on its key; picking a | |
| // voice puts its line in the composer, and what you type there becomes that voice's line. Play the keys like an instrument. | |
| // every voice starts without a line of its own and speaks the shared sentence until you type one (no examples) | |
| const own = (() => { try { localStorage.removeItem("kale-tts-1:lines"); return JSON.parse(localStorage.getItem("kale-tts-1:voice-lines") || "{}"); } catch { return {}; } })(); | |
| let perKey = (() => { try { return localStorage.getItem("kale-tts-1:per-key") === "1"; } catch { return false; } })(); | |
| let shared = $("#text").value; // the sentence every voice speaks (and the fallback in the lines mode) | |
| const textFor = (id) => (perKey ? own[id]?.trim() || shared : $("#text").value).trim(); | |
| /** the composer shows what you'd edit: in the lines mode the picked voice's own line (empty if it has none), else the shared one */ | |
| function fillComposer(id = voice) { | |
| const t = $("#text"); | |
| if (perKey) { t.value = own[id] ?? ""; t.placeholder = `Write ${look[id]?.name ?? "this voice"}'s line, or leave it empty to use the shared text.`; } | |
| else { t.value = shared; t.placeholder = "Type something to say"; } | |
| } | |
| function showLines() { | |
| syncSegs(); $("#keys").classList.toggle("lines-on", perKey); | |
| keys.forEach((k) => { $(".own", k.el).textContent = own[k.id]?.trim() ?? ""; | |
| if (perKey) k.el.setAttribute("aria-describedby", `own-${k.id}`); else k.el.removeAttribute("aria-describedby"); }); | |
| } | |
| function setPerKey(on) { | |
| perKey = on; try { localStorage.setItem("kale-tts-1:per-key", on ? "1" : "0"); } catch {} | |
| fillComposer(); showLines(); goState(); | |
| } | |
| /** the typed text in one voice: stream sentence by sentence into the speakers; the stats line under the cards shows how fast */ | |
| async function render(id, { gap = 0, my }) { | |
| const text = textFor(id), t0 = performance.now(); let first = null, audioS = 0, chunks = 0; | |
| for await (const ch of M.tts.stream(text, { voice: id })) { | |
| if (my !== gen) return null; const now = performance.now(); | |
| if (first === null) first = now - t0; | |
| player.push(ch.audio, { id }, chunks ? 0.12 : gap); if (!chunks++) goState(); audioS += ch.audio.length / SR; | |
| metrics({ first: ms(first), rt: x(audioS / ((now - t0) / 1000)) }); | |
| } | |
| if (first !== null) { const rt = audioS / ((performance.now() - t0) / 1000); // written (and said) once it has been heard | |
| heardStats = { first: ms(first), rt: x(rt), said: `First sound ${Math.round(first)} ms, real time ${Math.round(rt)} times` }; } | |
| return true; | |
| } | |
| /** the play button is a stop button while something is being made or heard */ | |
| let heardStats = null, heardSaid = null; // heardSaid: the measured stats, said once by the hidden status after playback | |
| function goState() { | |
| const on = busy || player.playing, b = $("#go"); b.classList.toggle("stop", on); b.setAttribute("aria-label", on ? "Stop" : "Play"); | |
| b.disabled = !on && !(M && textFor(voice)); // nothing to say (or no model yet): no Play that does nothing | |
| b.title = !b.disabled ? "" : M ? "Type something to say" : "Loading the model…"; | |
| b.classList.toggle("playing", player.playing); | |
| } | |
| /** resolves when what was queued has been heard (or this run was replaced); one timer per wait, no polling loop */ | |
| const heard = (my) => new Promise((done) => { const check = () => (my !== gen || !player.playing ? done() : setTimeout(check, Math.max(30, (player.next - player.now) * 1000))); check(); }); | |
| async function speak(id = voice) { | |
| if (!M) return; // keys are inert while a model loads: nothing changes, not even the composer | |
| if (perKey && id !== voice) fillComposer(id); // the composer shows (and edits) the picked voice's line | |
| if (!textFor(id)) { select(id); toast("Type something to say first."); return; } | |
| const my = ++gen; let failed = false; | |
| select(id); busy = true; goState(); // Stop shows in the same frame as the press | |
| try { | |
| await player.ensure(); player.reset(); heardStats = null; | |
| live("speaking"); // for screen readers; on screen the Stop icon and its ring say it | |
| // Stop stays up until the sentence has been heard to its end | |
| if (await render(id, { my }) && my === gen) await heard(my); | |
| } catch (e) { | |
| console.warn(e); failed = true; | |
| if (my === gen) { player.reset(); live("couldn't say that · press play to try again"); toast("Couldn't say that. Press play to try again."); } | |
| } finally { | |
| if (my === gen) { busy = false; if (!failed) idle(); } goState(); | |
| } | |
| } | |
| function stop() { gen++; busy = false; player.reset(); goState(); if (M) idle(); loop.redraw(); } | |
| // ------------------------------------------------------------------------------------------ drawing (only while sound plays) | |
| let shownId = null; | |
| const frame = (dt, active) => { | |
| const now = player.now; let seg = null; for (const s of player.segs) if (now >= s.start - 0.06 && now < s.end) seg = s; | |
| const id = seg?.meta.id ?? null, moving = active && !reducedMotion.matches; | |
| if (L && dt > 0) L.update(dt); | |
| if (id && id !== shownId) { setColor(id); markSel(id); } | |
| if (fx) fx.draw(L, dt, moving, player.playing); else drawHeroLine($("#line"), L, colorOf(id ?? voice), moving); | |
| if (id !== shownId) { shownId = id; goState(); } | |
| }; | |
| /** the waterfall always flows (flat when nobody speaks), but only while the page is shown and the water is on screen; phones at | |
| * 30 fps; reduced motion: one still picture. Without the shader the 2D line draws only while sound plays. */ | |
| function flowing(frame) { | |
| let raf = 0, last = 0, inView = true; | |
| const slow = matchMedia("(max-width: 760px)").matches, want = () => !document.hidden && inView && !reducedMotion.matches; | |
| const step = (now) => { | |
| const dt = (now - last) / 1000; | |
| if (slow && dt < 1 / 31) { raf = requestAnimationFrame(step); return; } | |
| last = now; frame(Math.min(0.05, dt), true); | |
| raf = want() ? requestAnimationFrame(step) : 0; | |
| }; | |
| const start = () => { if (!raf && want()) { last = performance.now(); raf = requestAnimationFrame(step); } }; | |
| document.addEventListener("visibilitychange", start); | |
| new IntersectionObserver(([e]) => { inView = e.isIntersecting; start(); }).observe($("#fx")); | |
| reducedMotion.addEventListener?.("change", start); | |
| return { kick: start, redraw() { if (!raf) frame(0, false); }, get running() { return !!raf; } }; | |
| } | |
| const loop = fx ? flowing(frame) : onDemandLoop(frame, () => player.playing); | |
| window.kaleDemo.loop = loop; window.kaleDemo.fx = fx; | |
| // the end of the sound restores Play (an event, so it works with reduced motion, when no frames run) and announces the stats; | |
| // a run that is still going keeps its Stop | |
| player.onend = () => { if (heardStats) { metrics(heardStats); heardSaid = heardStats.said; heardStats = null; } if (!busy) goState(); loop.redraw(); }; | |
| let halo = null; | |
| /** the haze the lines come out of: as wide as the lines (plus a margin), centred on the line where they start (nano: the water's | |
| * edge; tiny: the live line in front), gliding along with the picture when the model changes */ | |
| function placeHalo() { | |
| if (!halo) return; const tiny = $("#mtitle").textContent.endsWith("tiny"), el = $("#halo"); | |
| el.style.top = `${(tiny ? halo.rise : halo.fall) - halo.h / 2}px`; | |
| } | |
| /** the shader's canvas: from just above the edge to the end of the fall (the page grows to fit it if it is shorter), from left of | |
| * the stage to the right edge; and the glow on the edge. The fall is a fixed length, so every screen ends it the same way. */ | |
| function placeFall() { | |
| if (!fx) return; | |
| // the whole page wide, from the top (tiny's mountains rise up to it) to the end of nano's fall; the picture is centred in the | |
| // right column, its live line (where the water falls from) at the height of the model cards' middle | |
| const cv = $("#fx"), mc = $(".models").getBoundingClientRect(), vw = document.documentElement.clientWidth; | |
| const fall = vw <= 760 ? 560 : 820, edge = Math.round(mc.top + scrollY + mc.height / 2); | |
| const height = Math.max(document.documentElement.scrollHeight, edge + fall + 60); | |
| Object.assign(cv.style, { left: "0px", top: "0px", width: `${vw}px`, height: `${height}px` }); | |
| // the right column's middle (the whole width on a phone, where the column goes away) | |
| const art = $(".art").getBoundingClientRect(), wide = art.width > 40, cx = wide ? art.left + art.width / 2 : vw / 2; | |
| const w = wide ? Math.min(art.width * 1.15, 980) : Math.min(vw * 0.94, 980), h = vw <= 760 ? 220 : 300; | |
| // the projection puts the edge at 0.848 of the box height: shift the box so the edge lands where we want it | |
| const box = { x: cx - w / 2, y: edge - h * 0.848, w, h }; | |
| // tiny's mountains start lower: from the middle of the first row of voices (the women) | |
| const row = $("#keys .key")?.getBoundingClientRect(), riseEdge = row ? Math.round(row.top + scrollY + row.height / 2) : edge; | |
| fx.place({ ...box, streamX: cx, fall, rise: Math.max(120, riseEdge - 16), riseDy: riseEdge - edge }); | |
| halo = { fall: edge, rise: riseEdge, w: w * 0.83 * 1.18, h: h * 0.3 }; | |
| Object.assign($("#halo").style, { left: `${cx - halo.w / 2}px`, width: `${halo.w}px`, height: `${halo.h}px` }); placeHalo(); | |
| loop.redraw(); | |
| } | |
| // ------------------------------------------------------------------------------------------ controls | |
| const pickModel = (x) => { if (!booted || loading || M?.name === x.dataset.m) return; use(x.dataset.m, preferred()); }; | |
| $$(".mcard").forEach((x) => (x.onclick = () => pickModel(x))); | |
| // one radio group: Tab reaches the checked card, the arrows move to (and pick) the other | |
| $(".models").addEventListener("keydown", (e) => { | |
| const step = { ArrowLeft: -1, ArrowUp: -1, ArrowRight: 1, ArrowDown: 1 }[e.key]; if (!step) return; | |
| e.preventDefault(); if (!booted || loading) return; // focus never lands on a card that can't be picked | |
| const cards = $$(".mcard"), x = cards[(cards.indexOf(e.target.closest(".mcard")) + step + cards.length) % cards.length]; | |
| x.focus(); pickModel(x); | |
| }); | |
| $("#retry").onclick = () => { gpu.reset(); reloadOn("webgpu", M ? { model: M.name } : {}); }; | |
| $("#go").onclick = () => (busy || player.playing ? stop() : speak()); | |
| // ------------------------------------------------------------------------------------------ keyboard: the home row plays the voices | |
| // Bound to physical keys (KeyboardEvent.code), so the same row works on every layout; only the printed letters differ. The labels | |
| // come from the browser's layout map where it has one (Chrome, Edge), else from the layout picked with the keyboard button. | |
| const ROW = ["KeyA", "KeyS", "KeyD", "KeyF", "KeyG", "KeyH", "KeyJ", "KeyK", "KeyL", "Semicolon"]; | |
| const LAYOUTS = { | |
| QWERTY: "A S D F G H J K L ;", QWERTZ: "A S D F G H J K L Ö", AZERTY: "Q S D F G H J K L M", Dvorak: "A O E U I D H T N S", | |
| }; | |
| const PICKS = ["auto", ...Object.keys(LAYOUTS)]; | |
| const stored = (() => { try { return localStorage.getItem("kale-tts-1:keys"); } catch { return null; } })(); | |
| let layout = PICKS.includes(stored) ? stored : "auto", detected = null; | |
| // the key letters (and the home row that plays the voices) on or off: off for a new visitor; a saved choice stays, and so does an | |
| // older saved layout pick (letters on, as they were then) | |
| let lettersOn = (() => { try { const v = localStorage.getItem("kale-tts-1:key-letters"); return v === null ? PICKS.includes(stored) : v === "1"; } catch { return false; } })(); | |
| navigator.keyboard?.getLayoutMap?.().then((map) => { detected = ROW.map((c) => (map.get(c) ?? "").toUpperCase()); labelKeys(); }).catch(() => {}); | |
| function labelKeys() { | |
| const marks = !lettersOn ? [] : layout === "auto" ? (detected?.every(Boolean) ? detected : LAYOUTS.QWERTY.split(" ")) : LAYOUTS[layout].split(" "); | |
| keys.forEach((k, i) => { const kbd = $("kbd", k.el), m = marks[i]; kbd.textContent = m ?? ""; kbd.hidden = !m; | |
| if (m) k.el.setAttribute("aria-keyshortcuts", m); else k.el.removeAttribute("aria-keyshortcuts"); }); | |
| syncSegs(); | |
| $("#layout").textContent = `layout: ${layout}`; $("#layout").classList.toggle("off", !lettersOn); | |
| $("#layout").setAttribute("aria-label", `keyboard layout: ${layout === "auto" ? `auto${detected ? "" : " (QWERTY)"}` : layout}`); | |
| } | |
| function setLetters(on) { | |
| lettersOn = on; | |
| try { localStorage.setItem("kale-tts-1:key-letters", lettersOn ? "1" : "0"); } catch {} | |
| labelKeys(); | |
| } | |
| /** the Off | On pickers (radio groups) of the two options: checked, in the tab order, and the label brighter while On */ | |
| function syncSegs() { | |
| for (const b of $$(".seg [role=radio]")) { | |
| const on = b.dataset.seg === "lines" ? perKey : lettersOn, picked = on === (b.dataset.v === "1"); | |
| b.setAttribute("aria-checked", String(picked)); b.tabIndex = picked ? 0 : -1; b.closest(".opt").classList.toggle("on", on); | |
| } | |
| } | |
| const pickSeg = (b) => (b.dataset.seg === "lines" ? setPerKey(b.dataset.v === "1") : setLetters(b.dataset.v === "1")); | |
| $$(".seg [role=radio]").forEach((b) => (b.onclick = () => pickSeg(b))); | |
| $$(".seg").forEach((g) => g.addEventListener("keydown", (e) => { | |
| if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(e.key)) return; | |
| e.preventDefault(); const other = $$("[role=radio]", g).find((b) => b !== e.target); other.focus(); pickSeg(other); | |
| })); | |
| $("#layout").onclick = () => { | |
| layout = PICKS[(PICKS.indexOf(layout) + 1) % PICKS.length]; | |
| try { localStorage.setItem("kale-tts-1:keys", layout); } catch {} | |
| labelKeys(); | |
| }; | |
| addEventListener("keydown", (e) => { | |
| if (e.repeat || e.ctrlKey || e.metaKey || e.altKey) return; | |
| // Enter with nothing focused plays the picked voice (a focused button or the composer handles its own Enter) | |
| if (e.key === "Enter" && (e.target === document.body || e.target === document.documentElement)) { e.preventDefault(); speak(); return; } | |
| if (!lettersOn || e.target.closest?.("textarea, input, select, [contenteditable]")) return; | |
| const i = ROW.indexOf(e.code); if (i < 0 || !keys[i]) return; | |
| e.preventDefault(); speak(keys[i].id); | |
| }); | |
| // the text stays on its 24px line grid as it scrolls (Chrome's caret scroll can stop a few pixels short) | |
| $("#text").addEventListener("input", () => { | |
| requestAnimationFrame(() => { const t = $("#text"); t.scrollTop = Math.round(t.scrollTop / 24) * 24; }); | |
| if (perKey) { own[voice] = $("#text").value; try { localStorage.setItem("kale-tts-1:voice-lines", JSON.stringify(own)); } catch {} showLines(); } | |
| else shared = $("#text").value; | |
| goState(); | |
| }); | |
| $("#text").addEventListener("keydown", (e) => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); speak(); } }); | |
| /** the Kale wordmark as wide as the "brought to you by" line above it */ | |
| const sizeBrand = () => { const t = $(".brand span"), l = $(".brand svg"); if (t && l) l.style.width = `${t.getBoundingClientRect().width}px`; }; | |
| sizeBrand(); document.fonts?.ready.then(sizeBrand); | |
| let rz; addEventListener("resize", () => { clearTimeout(rz); rz = setTimeout(placeFall, 120); }); | |
| reducedMotion.addEventListener?.("change", () => loop.redraw()); | |
| // ?embed (the canvas card's frame): no tall empty end. Not "inside a frame", since Hugging Face frames every Space. | |
| if (q.has("embed")) document.documentElement.classList.add("framed"); | |
| buildKeys(); setInert(true); | |
| setColor("s057b"); placeFall(); loop.kick(); | |
| await gpu.ready(); hasGpu = await Promise.race([webGpuWorks(), new Promise((r) => setTimeout(() => r(false), 4000))]); | |
| if (q.has("gpufail")) toast("WebGPU didn't start here, so the CPU runs it."); | |
| const qModel = MODELS[q.get("model")] ? q.get("model") : "kale-tts-1-nano", qB = q.get("backend"); | |
| booted = true; | |
| await use(qModel, qB === "wasm" || (qB === "webgpu" && hasGpu) ? qB : preferred()); | |
| if (perKey) fillComposer(); // the lines mode was on last time | |
| placeFall(); | |
| window.__ready = true; | |