Integrácia s prehliadačom a osvedčené postupy
Na tejto strane
Aktualizované 3. novembra 2026 na základe stránky xAI Text to Speech: validácia na strane servera používa aktuálny limit 60 000 znakov na požiadavku. Zdroj: Text to Speech.
Nasadenie TTS vo webovej aplikácii
Integrácia TTS do prehliadača so sebou prináša špecifické výzvy: podpora kodekov, správa pamäte, špecifiká Safari a výkon. Táto záverečná lekcia ti poskytne všetko potrebné pre robustnú produkčnú integráciu.
Podpora kodekov v prehliadači
Nie každý prehliadač podporuje každý audio formát. Vyber správny kodek pre svoje cieľové publikum:
| Kodek | Chrome | Firefox | Safari | Edge | Odporúčané |
|---|---|---|---|---|---|
| MP3 | Áno | Áno | Áno | Áno | Áno |
| WAV | Áno | Áno | Áno | Áno | Áno |
| Surové PCM | Nie | Nie | Nie | Nie | Nie |
| mulaw/alaw | Nie | Nie | Nie | Nie | Nie |
Jednoduché pravidlo: v prehliadači používaj MP3 alebo WAV. Formáty PCM, mulaw a alaw sú určené pre serverové aplikácie a telefóniu, nie pre webovú reprodukciu.
// Požiadaj MP3 z API (cez svoj backend)
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
text: "Hello from the browser.",
voice_id: "eve",
language: "en"
// Nie je potrebné nastaviť output_format: MP3 je predvolené
})
});
Problém s AudioContext v Safari
Safari ukladá bezpečnostné obmedzenie: AudioContext je možné vytvoriť iba vnútri obslužnej rutiny užívateľskej udalosti (kliknutie, stlačenie klávesy, ťuknutie). Ak sa pokúsiš vytvoriť AudioContext pri načítaní stránky, Safari ho ticho zablokuje.
Nesprávny prístup
// V Safari NEFUNGUJE
const audioContext = new AudioContext(); // Zablokované!
async function playTTS() {
const audio = await fetchTTS("Hello");
// audioContext je v Safari pozastavený...
}
Správny prístup
let audioContext = null;
// Vytvor AudioContext pri prvom kliknutí používateľa
document.getElementById("play-btn").addEventListener("click", async () => {
if (!audioContext) {
audioContext = new AudioContext();
}
// Obnov, ak je pozastavený
if (audioContext.state === "suspended") {
await audioContext.resume();
}
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
text: "Hello from Safari.",
voice_id: "eve",
language: "en"
})
});
const arrayBuffer = await response.arrayBuffer();
const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
const source = audioContext.createBufferSource();
source.buffer = audioBuffer;
source.connect(audioContext.destination);
source.start(0);
});
Tento prístup funguje vo všetkých prehliadačoch, nielen v Safari. Je to dobrá univerzálna prax.
URL adresy Blob a úniky pamäte
Keď vytváraš URL adresy Blob na prehrávanie zvuku, každá URL adresa využíva pamäť, kým ju explicitne neuvoľníš. Bez čistenia bude tvoja aplikácia plytvať pamäťou.
Problém
// Každé volanie vytvorí URL adresu Blob, ktorá sa nikdy neuvoľní
async function playTTS(text) {
const response = await fetch("/api/tts", { ... });
const blob = await response.blob();
const url = URL.createObjectURL(blob); // Únik pamäte!
const audio = new Audio(url);
audio.play();
}
Riešenie
async function playTTS(text) {
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ text, voice_id: "eve", language: "en" })
});
const blob = await response.blob();
const url = URL.createObjectURL(blob);
const audio = new Audio(url);
// Uvoľni pamäť po skončení prehrávania
audio.addEventListener("ended", () => {
URL.revokeObjectURL(url);
});
// Uvoľni ju aj pri chybe
audio.addEventListener("error", () => {
URL.revokeObjectURL(url);
});
audio.play();
}
Pre aplikácie, ktoré generujú veľa zvuku, si udržuj zoznam aktívnych URL adries a pravidelne ich čistí:
class AudioManager {
constructor() {
this.activeUrls = new Set();
}
async play(text) {
const response = await fetch("/api/tts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ text, voice_id: "eve", language: "en" })
});
const blob = await response.blob();
const url = URL.createObjectURL(blob);
this.activeUrls.add(url);
const audio = new Audio(url);
audio.addEventListener("ended", () => this.release(url));
audio.addEventListener("error", () => this.release(url));
audio.play();
return audio;
}
release(url) {
URL.revokeObjectURL(url);
this.activeUrls.delete(url);
}
cleanup() {
// Uvoľni každú aktívnu URL adresu
for (const url of this.activeUrls) {
URL.revokeObjectURL(url);
}
this.activeUrls.clear();
}
}
Osvedčené postupy pre produkciu
Obmedzenie rýchlosti na backende
Chráň svoj backend pred zneužitím obmedzením počtu požiadaviek na používateľa:
const rateLimit = require("express-rate-limit");
const ttsLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minúta
max: 10, // 10 požiadaviek za minútu na IP adresu
message: { error: "Príliš veľa požiadaviek TTS" }
});
app.post("/api/tts", ttsLimiter, async (req, res) => {
// ... proxy na API xAI
});
Validácia textu
Pred odoslaním textu do API ho validuj a vyčisti:
function validateTTSInput(text) {
if (!text || typeof text !== "string") {
throw new Error("Text je povinný");
}
if (text.length > 60000) {
throw new Error("Text je príliš dlhý (maximálne 60 000 znakov)");
}
// Odstráň riadiace znaky
return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}
Ukladanie zvuku do vyrovnávacej pamäte
Pre opakujúce sa texty (pozdravy, štandardné inštrukcie) ukladaj vygenerovaný zvuk do vyrovnávacej pamäte:
const audioCache = new Map();
async function getTTS(text, voice, language) {
const cacheKey = `${text}:${voice}:${language}`;
if (audioCache.has(cacheKey)) {
return audioCache.get(cacheKey);
}
const audio = await fetchTTSFromAPI(text, voice, language);
audioCache.set(cacheKey, audio);
return audio;
}
Predgenerovanie
Pre obsah, ktorý poznáš vopred (e-learning, IVR), predgeneruj audio súbory v čase zostavenia (build time) namiesto generovania za behu.
Kľúčové poznatky
- V prehliadači používaj MP3 alebo WAV, nikdy nie PCM/mulaw/alaw
- V Safari vytváraj AudioContext vnútri obslužnej rutiny užívateľskej udalosti
- Vždy uvoľni URL adresy Blob pomocou
URL.revokeObjectURL()po ich použití - Pridaj obmedzenie rýchlosti (rate limiting) do svojho backendového proxy
- Pred odoslaním do API validuj a vyčisti text
- Ukladaj zvuk do vyrovnávacej pamäte pre opakujúce sa texty, aby si ušetril volania API
- Pre vopred známy obsah predgeneruj zvuk
Over si svoje vedomosti
Syntéza reči xAI: od prvého volania až po streamovacie pipeline.
1. Ako funguje základné volanie TTS?
Odpoveď: Ide o požiadavku POST na /v1/tts s textom, zvoleným hlasom (ktorý môžeš zoznamovať cez API) a parametrami. Odpoveďou je zvuk, účtovaný podľa objemu syntetizovaného obsahu.
2. Čo ti umožňujú expresívne tagy?
Odpoveď: Ovládať reč priamo z textu: inline a obaľujúce tagy pre intonáciu, pauzy a dôraz, ktoré môžeš kombinovať pre prirodzené, cielené čítanie.
3. Kedy by si mal prejsť na TTS WebSocket?
Odpoveď: Pre prácu v reálnom čase: text odchádza ako stream a zvuk prichádza nepretržite späť. Je to základ pipeline LLM → TTS, kde sa hlas spustí skôr, než sa generovanie dokončí.
4. Ako zabezpečiť integráciu s prehliadačom?
Odpoveď: Nikdy neumiestňuj API kľúč na stranu klienta: prehliadač komunikuje cez tvoj server alebo používa krátkodobé poverenia a ty správne spracovávaš chyby HTTP.
5. Ako vyzerá kompletné produkčné pipeline?
Odpoveď: Streamovanie LLM → segmenty textu → TTS WebSocket → prehrávanie zvuku. Každý článok streamuje, takže vnímaná latencia sa zrúti a osvedčené postupy z tohto kurzu uzatvárajú celý cyklus.
Tagy pre expresivitu, WebSocket pre reálny čas, tvoj server pre tajné údaje: tvoje aplikácie sú pripravené hovoriť.