Integrarea în browser și bune practici
Pe această pagină
Actualizat la 3 noiembrie 2026, pe baza paginii xAI Text to Speech: validarea lato-server utilizează limita curentă de 60.000 de caractere per cerere. Sursă: Text to Speech.
Implementarea TTS într-o aplicație web
Integrarea TTS într-un browser prezintă provocări specifice: suportul pentru codec-uri, gestionarea memoriei, particularitățile Safari și performanța. Această ultimă lecție vă oferă tot ce aveți nevoie pentru o integrare robustă în producție.
Suportul pentru codec-uri în browser
Nu fiecare browser suportă fiecare format audio. Alegeți codec-ul potrivit pentru publicul dumneavoastră:
| Codec | Chrome | Firefox | Safari | Edge | Recomandat |
|---|---|---|---|---|---|
| MP3 | Da | Da | Da | Da | Da |
| WAV | Da | Da | Da | Da | Da |
| Raw PCM | Nu | Nu | Nu | Nu | Nu |
| mulaw/alaw | Nu | Nu | Nu | Nu | Nu |
Regula simplă: utilizați MP3 sau WAV în browser. PCM, mulaw și alaw sunt destinate aplicațiilor server și telefoniei, nu redării web.
// Solicitați MP3 de la API (prin backend-ul dumneavoastră)
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"
// Nu este nevoie să setați output_format: MP3 este implicit
})
});
Problema AudioContext în Safari
Safari impune o restricție de securitate: un AudioContext poate fi creat doar în interiorul unui gestionar de evenimente declanșat de utilizator (clic, apăsare de tastă, atingere). Dacă încercați să creați un AudioContext la încărcarea paginii, Safari îl blochează în tăcere.
Abordarea greșită
// NU funcționează în Safari
const audioContext = new AudioContext(); // Blocat!
async function playTTS() {
const audio = await fetchTTS("Hello");
// audioContext este suspendat în Safari...
}
Abordarea corectă
let audioContext = null;
// Creați AudioContext la primul clic al utilizatorului
document.getElementById("play-btn").addEventListener("click", async () => {
if (!audioContext) {
audioContext = new AudioContext();
}
// Reluați dacă este suspendat
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);
});
Această abordare funcționează în fiecare browser, nu doar în Safari. Este o bună practică universală.
URL-uri Blob și scurgeri de memorie
Atunci când creați URL-uri Blob pentru a reda audio, fiecare URL utilizează memorie până când îl eliberați explicit. Fără curățare, aplicația dumneavoastră va avea scurgeri de memorie.
Problema
// Fiecare apel creează un URL Blob care nu este niciodată eliberat
async function playTTS(text) {
const response = await fetch("/api/tts", { ... });
const blob = await response.blob();
const url = URL.createObjectURL(blob); // Scurgere de memorie!
const audio = new Audio(url);
audio.play();
}
Soluția
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);
// Eliberați memoria când redarea se termină
audio.addEventListener("ended", () => {
URL.revokeObjectURL(url);
});
// Eliberați memoria și în caz de eroare
audio.addEventListener("error", () => {
URL.revokeObjectURL(url);
});
audio.play();
}
Pentru aplicațiile care generează mult audio, mențineți o listă a URL-urilor active și curățați-le periodic:
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() {
// Eliberează fiecare URL activ
for (const url of this.activeUrls) {
URL.revokeObjectURL(url);
}
this.activeUrls.clear();
}
}
Bune practici pentru producție
Limitarea ratei la backend
Protejați-vă backend-ul de abuzuri prin limitarea cererilor per utilizator:
const rateLimit = require("express-rate-limit");
const ttsLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minut
max: 10, // 10 cereri pe minut per IP
message: { error: "Prea multe cereri TTS" }
});
app.post("/api/tts", ttsLimiter, async (req, res) => {
// ... proxy către API-ul xAI
});
Validarea textului
Validați și curățați textul înainte de a-l trimite la API:
function validateTTSInput(text) {
if (!text || typeof text !== "string") {
throw new Error("Textul este obligatoriu");
}
if (text.length > 60000) {
throw new Error("Text prea lung (maxim 60.000 de caractere)");
}
// Elimină caracterele de control
return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}
Cache-ul audio
Pentru texte repetitive (saluturi, instrucțiuni standard), stocați în cache audio-ul generat:
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;
}
Pre-generare
Pentru conținutul pe care îl cunoașteți în avans (e-learning, IVR), pre-generați fișierele audio la momentul build-ului, nu din mers.
Puncte cheie
- Utilizați MP3 sau WAV în browser, niciodată PCM/mulaw/alaw
- În Safari, creați AudioContext în interiorul unui gestionar de evenimente declanșat de utilizator
- Eliberați întotdeauna URL-urile Blob cu
URL.revokeObjectURL()după utilizare - Adăugați limitarea ratei la proxy-ul dumneavoastră de backend
- Validați și curățați textul înainte de a-l trimite la API
- Stocați în cache audio-ul pentru texte repetitive pentru a economisi apeluri API
- Pre-generați audio pentru conținutul pe care îl cunoașteți în avans
Verificați-vă cunoștințele
Sinteza vocală xAI: de la primul apel la pipeline-ul de streaming.
1. Cum funcționează apelul TTS de bază?
Răspuns: Un POST către /v1/tts cu textul, vocea aleasă (pe care o puteți lista prin API) și parametrii. Răspunsul este audio-ul, facturat în funcție de volumul sintetizat.
2. Ce vă permit să faceți tag-urile expresive?
Răspuns: Să controlați vorbirea direct din text: tag-uri inline și de învelire pentru intonație, pauze și accentuare, pe care le puteți combina pentru lecturi naturale și direcționate.
3. Când ar trebui să treceți la TTS WebSocket?
Răspuns: Pentru timp real: textul pleacă sub formă de flux, iar audio-ul vine continuu. Este fundamentul pipeline-urilor LLM → TTS, unde vocea începe înainte ca generarea să se termine.
4. Cum securizați o integrare în browser?
Răspuns: Nu puneți niciodată cheia API în client: browserul trece prin serverul dumneavoastră sau folosește credențiale cu durată scurtă de viață, iar dumneavoastră gestionați corect erorile HTTP.
5. Cum arată pipeline-ul complet de producție?
Răspuns: Un LLM streaming → segmente de text → TTS WebSocket → redare audio. Fiecare verigă face streaming, astfel încât latența percepută se prăbușește, iar bunele practici din acest curs închid bucla.
Tag-uri pentru expresivitate, WebSocket pentru timp real, serverul dumneavoastră pentru secrete: aplicațiile dumneavoastră sunt gata să vorbească.