Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Integrace do prohlížeče a osvědčené postupy

Lekce 14 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Nasazení TTS ve webové aplikaci
  2. Podpora kodeků v prohlížečích
  3. Problém s AudioContext v Safari
  4. URL adresy Blob a úniky paměti
  5. Osvědčené postupy pro produkci
  6. Klíčové poznatky
  7. Ověř si své znalosti

Aktualizováno 3. listopadu 2026 na základě stránky xAI Text to Speech: validace na straně serveru používá aktuální limit 60 000 znaků na požadavek. Zdroj: Text to Speech.

Nasazení TTS ve webové aplikaci

Integrace TTS do prohlížeče přináší specifické výzvy: podpora kodeků, správa paměti, záludnosti Safari a výkon. Tato závěrečná lekce ti dá vše potřebné pro robustní produkční integraci.

Podpora kodeků v prohlížečích

Ne každý prohlížeč podporuje každý audio formát. Vyber správný kodek pro své publikum:

KodekChromeFirefoxSafariEdgeDoporučeno
MP3AnoAnoAnoAnoAno
WAVAnoAnoAnoAnoAno
Raw PCMNeNeNeNeNe
mulaw/alawNeNeNeNeNe

Jednoduché pravidlo: v prohlížeči používej MP3 nebo WAV. PCM, mulaw a alaw jsou určeny pro serverové aplikace a telefonii, nikoliv pro přehrávání na webu.

// Požadavek na MP3 z API (přes tvůj 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"
    // Není třeba nastavovat output_format: MP3 je výchozí
  })
});

Problém s AudioContext v Safari

Safari ukládá bezpečnostní omezení: AudioContext lze vytvořit pouze uvnitř obslužné rutiny uživatelské události (kliknutí, stisk klávesy, klepnutí). Pokud se pokusíš vytvořit AudioContext při načtení stránky, Safari jej tiše zablokuje.

Špatný přístup

// V Safari NEFUNGUJE
const audioContext = new AudioContext(); // Zablokováno!

async function playTTS() {
  const audio = await fetchTTS("Hello");
  // audioContext je v Safari pozastaven...
}

Správný přístup

let audioContext = null;

// Vytvoř AudioContext při prvním kliknutí uživatele
document.getElementById("play-btn").addEventListener("click", async () => {
  if (!audioContext) {
    audioContext = new AudioContext();
  }

  // Obnov, pokud 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 přístup funguje ve všech prohlížečích, nejen v Safari. Je to dobrá univerzální praxe.

URL adresy Blob a úniky paměti

Když vytvoříš URL adresy Blob pro přehrávání zvuku, každá URL spotřebuje paměť, dokud ji explicitně neuvolníš. Bez čištění bude tvá aplikace trpět úniky paměti.

Problém

// Každé volání vytvoří URL Blob, která se nikdy neuvolní
async function playTTS(text) {
  const response = await fetch("/api/tts", { ... });
  const blob = await response.blob();
  const url = URL.createObjectURL(blob); // Únik paměti!
  const audio = new Audio(url);
  audio.play();
}

Řešení

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);

  // Uvolni paměť po skončení přehrávání
  audio.addEventListener("ended", () => {
    URL.revokeObjectURL(url);
  });

  // Uvolni ji také při chybě
  audio.addEventListener("error", () => {
    URL.revokeObjectURL(url);
  });

  audio.play();
}

Pro aplikace, které generují hodně zvuku, udržuj seznam aktivních URL a pravidelně je čistěte:

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() {
    // Uvolni každou aktivní URL
    for (const url of this.activeUrls) {
      URL.revokeObjectURL(url);
    }
    this.activeUrls.clear();
  }
}

Osvědčené postupy pro produkci

Omezování rychlosti na backendu

Chraň svůj backend před zneužitím omezením počtu požadavků na uživatele:

const rateLimit = require("express-rate-limit");

const ttsLimiter = rateLimit({
  windowMs: 60 * 1000, // 1 minuta
  max: 10, // 10 požadavků za minutu na IP adresu
  message: { error: "Příliš mnoho požadavků TTS" }
});

app.post("/api/tts", ttsLimiter, async (req, res) => {
  // ... proxy na API xAI
});

Validace textu

Před odesláním textu do API jej 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 příliš dlouhý (maximálně 60 000 znaků)");
  }
  // Odstraň řídicí znaky
  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}

Mezipaměť zvuku

Pro opakující se texty (pozdravy, standardní pokyny) ukládej vygenerovaný zvuk do mezipaměti:

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;
}

Předběžná generace

Pro obsah, který znáš předem (e-learning, IVR), generuj zvukové soubory předem v době sestavení, nikoliv za běhu.

Klíčové poznatky

  • V prohlížeči používej MP3 nebo WAV, nikdy PCM/mulaw/alaw
  • V Safari vytvoř AudioContext uvnitř obslužné rutiny uživatelské události
  • Vždy uvolni URL adresy Blob pomocí URL.revokeObjectURL() po použití
  • Přidej omezování rychlosti ke svému backendovému proxy
  • Před odesláním do API text validuj a vyčisti
  • Pro opakující se texty ukládej zvuk do mezipaměti, abys ušetřil volání API
  • Pro obsah, který znáš předem, generuj zvuk předem

Ověř si své znalosti

Syntéza řeči xAI: od prvního volání až po streamovací pipeline.

1. Jak funguje základní volání TTS?

Odpověď: POST na /v1/tts s textem, zvoleným hlasem (který můžeš vypsat přes API) a parametry. Odpovědí je zvuk, účtovaný podle objemu syntézy.

2. Co ti umožňují expresivní tagy?

Odpověď: Ovládat řeč přímo v textu: řádkové a obalující tagy pro intonaci, pauzy a důraz, které můžeš kombinovat pro přirozené, řízené přednesy.

3. Kdy bys měl přejít na TTS WebSocket?

Odpověď: Pro reálný čas: text odchází jako stream a zvuk přichází nepřetržitě zpět. Je to základ pipeline LLM → TTS, kde hlas začne dříve, než skončí generování.

4. Jak zabezpečit integraci do prohlížeče?

Odpověď: Nikdy nedávej API klíč do klienta: prohlížeč prochází přes tvůj server nebo používá krátkodobé pověření a ty správně zpracováváš chyby HTTP.

5. Jak vypadá kompletní produkční pipeline?

Odpověď: Streamovací LLM → segmenty textu → TTS WebSocket → přehrávání zvuku. Každý článek streamuje, takže vnímaná latence se hroutí a osvědčené postupy z tohoto kurzu uzavírají smyčku.

Tagy pro expresivitu, WebSocket pro reálný čas, tvůj server pro tajemství: tvé aplikace jsou připraveny mluvit.