Integrācija pārlūkprogrammā un labākā prakse
Šajā lapā
Atjaunināts 2026. gada 3. novembrī, pamatojoties uz xAI Text to Speech lapu: servera puses validācija izmanto pašreizējo limitu – 60 000 rakstzīmju vienā pieprasījumā. Avots: Text to Speech.
TTS izvietošana tīmekļa lietotnē
TTS integrēšana pārlūkprogrammā saistīta ar specifiskiem izaicinājumiem: kodeku atbalsts, atmiņas pārvaldība, Safari īpatnības un veiktspēja. Šī noslēdzošā nodarbība sniedz visu nepieciešamo, lai nodrošinātu stabilu integrāciju ražošanas vidē.
Pārlūkprogrammu kodeku atbalsts
Ne katra pārlūkprogramma atbalsta visus audio formātus. Izvēlies pareizo kodeku savai auditorijai:
| Kodeks | Chrome | Firefox | Safari | Edge | Ieteicams |
|---|---|---|---|---|---|
| MP3 | Jā | Jā | Jā | Jā | Jā |
| WAV | Jā | Jā | Jā | Jā | Jā |
| Raw PCM | Nē | Nē | Nē | Nē | Nē |
| mulaw/alaw | Nē | Nē | Nē | Nē | Nē |
Vienkāršais likums: pārlūkprogrammā izmanto MP3 vai WAV. PCM, mulaw un alaw ir paredzēti servera lietotnēm un telefonijai, nevis atskaņošanai tīmeklī.
// Pieprasiet MP3 no API (caur savu 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"
// Nav jānorāda output_format: MP3 ir noklusējuma vērtība
})
});
Safari AudioContext problēma
Safari uzliek drošības ierobežojumu: AudioContext var izveidot tikai lietotāja notikuma apstrādātāja ietvaros (klikšķis, taustiņa nospiešana, pieskāriens). Ja mēģini izveidot AudioContext lapas ielādes brīdī, Safari to klusi bloķē.
Nepareizā pieeja
// Nedarbojas Safari vidē
const audioContext = new AudioContext(); // Bloķēts!
async function playTTS() {
const audio = await fetchTTS("Hello");
// audioContext ir apturēts Safari vidē...
}
Pareizā pieeja
let audioContext = null;
// Izveido AudioContext pie lietotāja pirmā klikšķa
document.getElementById("play-btn").addEventListener("click", async () => {
if (!audioContext) {
audioContext = new AudioContext();
}
// Atjauno, ja tas ir apturēts
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);
});
Šī pieeja darbojas visās pārlūkprogrammās, ne tikai Safari. Tā ir laba universāla prakse.
Blob URL un atmiņas noplūdes
Veidojot Blob URL audio atskaņošanai, katra URL izmanto atmiņu, līdz to eksplicīti atbrīvo. Bez tīrīšanas tava lietotne piedzīvos atmiņas noplūdi.
Problēma
// Katrs izsaukums rada Blob URL, kas nekad netiek atbrīvots
async function playTTS(text) {
const response = await fetch("/api/tts", { ... });
const blob = await response.blob();
const url = URL.createObjectURL(blob); // Atmiņas noplūde!
const audio = new Audio(url);
audio.play();
}
Risinājums
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);
// Atbrīvo atmiņu, kad atskaņošana beigusies
audio.addEventListener("ended", () => {
URL.revokeObjectURL(url);
});
// Atbrīvo atmiņu arī kļūdas gadījumā
audio.addEventListener("error", () => {
URL.revokeObjectURL(url);
});
audio.play();
}
Lietotnēm, kas ģenerē daudz audio, uzturi aktīvo URL sarakstu un periodiski tos attīri:
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() {
// Atbrīvo katru aktīvo URL
for (const url of this.activeUrls) {
URL.revokeObjectURL(url);
}
this.activeUrls.clear();
}
}
Labākā prakse ražošanas vidē
Backend pieprasījumu limita ierobežošana
Aizsargā savu backend no ļaunprātīgas izmantošanas, ierobežojot pieprasījumu skaitu vienam lietotājam:
const rateLimit = require("express-rate-limit");
const ttsLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minūte
max: 10, // 10 pieprasījumi minūtē vienai IP adresei
message: { error: "Too many TTS requests" }
});
app.post("/api/tts", ttsLimiter, async (req, res) => {
// ... starpniekserveris uz xAI API
});
Teksta validācija
Validē un attīri tekstu pirms tā nosūtīšanas API:
function validateTTSInput(text) {
if (!text || typeof text !== "string") {
throw new Error("Text is required");
}
if (text.length > 60000) {
throw new Error("Text too long (60,000 characters max)");
}
// Noņem vadības rakstzīmes
return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}
Audio kešošana
Atkārtotiem tekstiem (sveicieni, standarta instrukcijas) kešo ģenerēto audio:
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;
}
Ģenerēšana iepriekš
Sataram, ko zini iepriekš (e-mācības, IVR), ģenerē audio failus būvēšanas laikā, nevis reāllaikā.
Galvenās atziņas
- Pārlūkprogrammā izmanto MP3 vai WAV, nekad PCM/mulaw/alaw
- Safari vidē izveido AudioContext lietotāja notikuma apstrādātāja ietvaros
- Vienmēr atbrīvo Blob URL, izmantojot
URL.revokeObjectURL()pēc lietošanas - Pievieno pieprasījumu limita ierobežošanu savam backend starpniekserverim
- Validē un attīri tekstu pirms tā nosūtīšanas API
- Kešo audio atkārtotiem tekstiem, lai ietaupītu API izsaukumus
- Ģenerē audio iepriekš saturam, ko zini jau iepriekš
Pārbaudi savas zināšanas
xAI runas sintēze: no pirmā izsaukuma līdz straumēšanas konveijeram.
1. Kā darbojas pamata TTS izsaukums?
Atbilde: POST pieprasījums uz /v1/tts ar tekstu, izvēlēto balsi (ko vari uzskaitīt caur API) un parametriem. Atbilde ir audio, kas tiek tarifēts pēc ģenerētā apjoma.
2. Ko ļauj darīt izteiksmes tagi?
Atbilde: Kontrolē runu teksta ietvaros: rindiņas un aptverošie tagi intonācijai, pauzēm un uzsvariem, kurus vari kombinēt dabiskai, virzītai lasīšanai.
3. Kad jāpāriet uz TTS WebSocket?
Atbilde: Reāllaika scenārijiem: teksts tiek nosūtīts kā plūsma, un audio tiek saņemts nepārtraukti. Tas ir LLM → TTS konveijeru pamats, kur balss sāk skanēt pirms ģenerēšanas pabeigšanas.
4. Kā nodrošināt pārlūkprogrammas integrācijas drošību?
Atbilde: Nekad neievieto API atslēgu klientā: pārlūkprogramma sazinās caur tavu serveri vai izmanto īslaicīgus akreditācijas datus, un tu pareizi apstrādā HTTP kļūdas.
5. Kā izskatās pilns ražošanas konveijers?
Atbilde: Straumējošs LLM → teksta segmenti → TTS WebSocket → audio atskaņošana. Katrs posms straumē, tāpēc uztvertā latentums sabrūk, un šī kursa labākā prakse noslēdz ciklu.
Tagi izteiksmīgumam, WebSocket reāllaikam, tavs serveris noslēpumiem: tavas lietotnes ir gatavas runāt.