Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Integrácia s prehliadačom a osvedčené postupy

Lekcia 14 z 14 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Nasadenie TTS vo webovej aplikácii
  2. Podpora kodekov v prehliadači
  3. Problém s AudioContext v Safari
  4. URL adresy Blob a úniky pamäte
  5. Osvedčené postupy pre produkciu
  6. Kľúčové poznatky
  7. Over si svoje vedomosti

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:

KodekChromeFirefoxSafariEdgeOdporúčané
MP3ÁnoÁnoÁnoÁnoÁno
WAVÁnoÁnoÁnoÁnoÁno
Surové PCMNieNieNieNieNie
mulaw/alawNieNieNieNieNie

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ť.