Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Böngészőintegráció és bevált gyakorlatok

14. lecke 14 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. TTS üzembe helyezése webalkalmazásban
  2. Böngészők kodektámogatása
  3. A Safari AudioContext problémája
  4. Blob URL-ek és memóriaszivárgás
  5. Éles környezeti bevált gyakorlatok
  6. Főbb megállapítások
  7. Ellenőrizd a tudásod

Frissítve: 2026. november 3., az xAI Text to Speech oldala alapján: a szerveroldali validáció a kérelmenkénti jelenlegi, 60 000 karakteres korlátot használja. Forrás: Text to Speech.

TTS üzembe helyezése webalkalmazásban

A TTS böngészőbe történő integrálása sajátos kihívásokkal jár: kodektámogatás, memóriakezelés, Safari-specifikus sajátosságok és teljesítmény. Ez az utolsó lecke megadja neked mindazt, amire egy robosztus éles környezeti integrációhoz szükséged van.

Böngészők kodektámogatása

Nem minden böngésző támogat minden audioformátumot. Válaszd ki a közönségednek megfelelő kodeket:

KodekChromeFirefoxSafariEdgeAjánlott
MP3IgenIgenIgenIgenIgen
WAVIgenIgenIgenIgenIgen
Nyers PCMNemNemNemNemNem
mulaw/alawNemNemNemNemNem

Az egyszerű szabály: a böngészőben használj MP3-at vagy WAV-ot. A PCM, a mulaw és az alaw szerveroldali alkalmazásokhoz és telefonrendszerhez készültek, nem webes lejátszásra.

// MP3 kérése az API-tól (a backendeden keresztül)
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"
    // Nem szükséges beállítani az output_formatot: az MP3 az alapértelmezett
  })
});

A Safari AudioContext problémája

A Safari biztonsági korlátozást vezetett be: az AudioContext csak felhasználói eseménykezelőn belül (kattintás, billentyűleütés, érintés) hozható létre. Ha oldalbetöltéskor próbálsz AudioContextet létrehozni, a Safari csendben blokkolja azt.

A helytelen megközelítés

// Safari-ban NEM működik
const audioContext = new AudioContext(); // Blokkolva!

async function playTTS() {
  const audio = await fetchTTS("Hello");
  // az audioContext felfüggesztett állapotban van Safari-ban...
}

A helyes megközelítés

let audioContext = null;

// Az AudioContext létrehozása a felhasználó első kattintásakor
document.getElementById("play-btn").addEventListener("click", async () => {
  if (!audioContext) {
    audioContext = new AudioContext();
  }

  // Folytatás, ha felfüggesztett
  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);
});

Ez a megközelítés minden böngészőben működik, nem csak a Safariban. Ez egy jó univerzális gyakorlat.

Blob URL-ek és memóriaszivárgás

Amikor Blob URL-eket hozol létre audio lejátszásához, minden URL memóriát foglal addig, amíg explicit fel nem szabadítod azt. Tisztítás nélkül az alkalmazásod memóriaszivárgást okoz.

A probléma

// Minden hívás létrehoz egy Blob URL-t, amelyet soha nem szabadítanak fel
async function playTTS(text) {
  const response = await fetch("/api/tts", { ... });
  const blob = await response.blob();
  const url = URL.createObjectURL(blob); // Memóriaszivárgás!
  const audio = new Audio(url);
  audio.play();
}

A megoldás

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

  // Memória felszabadítása a lejátszás végén
  audio.addEventListener("ended", () => {
    URL.revokeObjectURL(url);
  });

  // Felszabadítás hiba esetén is
  audio.addEventListener("error", () => {
    URL.revokeObjectURL(url);
  });

  audio.play();
}

Olyan alkalmazásoknál, amelyek sok audiót generálnak, tartsd nyilván az aktív URL-ek listáját, és tisztítsd őket időszakosan:

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() {
    // Minden aktív URL felszabadítása
    for (const url of this.activeUrls) {
      URL.revokeObjectURL(url);
    }
    this.activeUrls.clear();
  }
}

Éles környezeti bevált gyakorlatok

Backend sebességkorlátozás (Rate Limiting)

Védd meg backendedet a visszaélésektől a felhasználónkénti kérelmek korlátozásával:

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

const ttsLimiter = rateLimit({
  windowMs: 60 * 1000, // 1 perc
  max: 10, // 10 kérelem percenként IP-címenként
  message: { error: "Túl sok TTS kérés" }
});

app.post("/api/tts", ttsLimiter, async (req, res) => {
  // ... továbbítás az xAI API felé
});

Szövegvalidálás

Validáld és tisztítsd meg a szöveget, mielőtt elküldenéd az API-nak:

function validateTTSInput(text) {
  if (!text || typeof text !== "string") {
    throw new Error("A szöveg kötelező");
  }
  if (text.length > 60000) {
    throw new Error("A szöveg túl hosszú (max. 60 000 karakter)");
  }
  // Vezérlőkarakterek eltávolítása
  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}

Audio gyorsítótárazás

Ismétlődő szövegeknél (köszöntések, szabványos utasítások) gyorsítótárazd a generált audiót:

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

Előgenerálás

Olyan tartalmaknál, amelyeket előre ismersz (e-learning, IVR), generáld előre az audiofájlokat build időben, ne menet közben.

Főbb megállapítások

  • A böngészőben használj MP3-at vagy WAV-ot, soha ne PCM/mulaw/alaw formátumot
  • Safari-ban az AudioContextet felhasználói eseménykezelőn belül hozd létre
  • Használat után mindig szabadítsd fel a Blob URL-eket a URL.revokeObjectURL() hívásával
  • Adj hozzá sebességkorlátozást a backend proxyhoz
  • Validáld és tisztítsd meg a szöveget, mielőtt elküldenéd az API-nak
  • Gyorsítótárazd az audiót ismétlődő szövegeknél az API-hívások csökkentése érdekében
  • Generáld előre az audiót az előre ismert tartalmakhoz

Ellenőrizd a tudásod

xAI beszédszintézis: az első hívástól a streaming pipeline-ig.

1. Hogyan működik az alapvető TTS hívás?

Válasz: Egy POST kérés a /v1/tts végpontra a szöveggel, a választott hanggal (amit az API-n keresztül listázhatsz) és a paraméterekkel. A válasz az audió, amelyet a szintetizált mennyiség alapján számláznak.

2. Mire adnak lehetőséget a kifejező címkék (expressive tags)?

Válasz: A beszéd vezérlésére magán a szövegen belül: inline és záró címkék a hanglejtéshez, szünetekhez és hangsúlyozáshoz, amelyek kombinálhatók természetes, irányított felolvasás érdekében.

3. Mikor kell átváltani a TTS WebSocketre?

Válasz: Valós idejű használat esetén: a szöveg streamként távozik, és az audió folyamatosan érkezik vissza. Ez az LLM → TTS pipeline-ok alapja, ahol a hang a generálás befejezése előtt megszólal.

4. Hogyan biztosítod a böngészőintegrációt?

Válasz: Soha ne helyezd el az API kulcsot a kliens oldalon: a böngésző a szervereden keresztül kommunikál, vagy rövid életű hitelesítő adatokat használ, és megfelelően kezeled a HTTP hibákat.

5. Hogyan néz ki a teljes éles környezeti pipeline?

Válasz: Egy streaming LLM → szövegszegmensek → TTS WebSocket → audio lejátszás. Minden láncszem streamel, így az érzékelt késleltetés drasztikusan csökken, és ebből a tanfolyamból származó bevált gyakorlatok zárják le a kört.

Címkék a kifejezőkészséghez, WebSocket a valós idejű működéshez, a szervered a titkokhoz: az alkalmazásaid készen állnak a beszédre.