Integracja z przeglądarką i najlepsze praktyki
Na tej stronie
Zaktualizowano 3 listopada 2026 r. na podstawie strony Text to Speech od xAI: walidacja po stronie serwera wykorzystuje obecny limit 60 000 znaków na żądanie. Źródło: Text to Speech.
Wdrażanie TTS w aplikacji internetowej
Integracja TTS w przeglądarce wiąże się ze specyficznymi wyzwaniami: obsługą kodeków, zarządzaniem pamięcią, osobliwościami Safari i wydajnością. Ta ostatnia lekcja dostarczy Ci wszystkiego, czego potrzebujesz do solidnej integracji produkcyjnej.
Obsługa kodeków w przeglądarce
Nie każda przeglądarka obsługuje każdy format audio. Wybierz odpowiedni kodek dla swojej grupy odbiorców:
| Kodek | Chrome | Firefox | Safari | Edge | Zalecany |
|---|---|---|---|---|---|
| MP3 | Tak | Tak | Tak | Tak | Tak |
| WAV | Tak | Tak | Tak | Tak | Tak |
| Surowy PCM | Nie | Nie | Nie | Nie | Nie |
| mulaw/alaw | Nie | Nie | Nie | Nie | Nie |
Prosta zasada: używaj w przeglądarce MP3 lub WAV. PCM, mulaw i alaw są przeznaczone dla aplikacji serwerowych i telefonii, a nie do odtwarzania w sieci.
// Żądanie MP3 z API (poprzez Twó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"
// Nie trzeba ustawiać output_format: MP3 jest domyślny
})
});
Problem z AudioContext w Safari
Safari nakłada ograniczenie bezpieczeństwa: AudioContext można utworzyć tylko wewnątrz obsługi zdarzenia wywołanego przez użytkownika (kliknięcie, naciśnięcie klawisza, dotknięcie). Jeśli spróbujesz utworzyć AudioContext podczas ładowania strony, Safari po cichu to zablokuje.
Błędne podejście
// NIE działa w Safari
const audioContext = new AudioContext(); // Zablokowane!
async function playTTS() {
const audio = await fetchTTS("Hello");
// audioContext jest zawieszony w Safari...
}
Właściwe podejście
let audioContext = null;
// Utwórz AudioContext przy pierwszym kliknięciu użytkownika
document.getElementById("play-btn").addEventListener("click", async () => {
if (!audioContext) {
audioContext = new AudioContext();
}
// Wznów, jeśli zawieszony
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);
});
To podejście działa w każdej przeglądarce, nie tylko w Safari. Jest to dobra, uniwersalna praktyka.
Adresy URL obiektów Blob i wycieki pamięci
Gdy tworzysz adresy URL obiektów Blob do odtwarzania dźwięku, każdy URL zużywa pamięć, dopóki jej jawnie nie zwolnisz. Bez czyszczenia Twoja aplikacja będzie cierpieć na wycieki pamięci.
Problem
// Każde wywołanie tworzy URL obiektu Blob, który nigdy nie jest zwalniany
async function playTTS(text) {
const response = await fetch("/api/tts", { ... });
const blob = await response.blob();
const url = URL.createObjectURL(blob); // Wyciek pamięci!
const audio = new Audio(url);
audio.play();
}
Rozwiązanie
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);
// Zwolnij pamięć po zakończeniu odtwarzania
audio.addEventListener("ended", () => {
URL.revokeObjectURL(url);
});
// Zwolnij również w przypadku błędu
audio.addEventListener("error", () => {
URL.revokeObjectURL(url);
});
audio.play();
}
W aplikacjach generujących dużo dźwięku przechowuj listę aktywnych adresów URL i czyść ją okresowo:
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() {
// Zwolnij każdy aktywny URL
for (const url of this.activeUrls) {
URL.revokeObjectURL(url);
}
this.activeUrls.clear();
}
}
Najlepsze praktyki produkcyjne
Limitowanie częstotliwości żądań (Rate limiting) po stronie backendu
Chroń swój backend przed nadużyciami, limitując liczbę żądań na użytkownika:
const rateLimit = require("express-rate-limit");
const ttsLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minuta
max: 10, // 10 żądań na minutę na adres IP
message: { error: "Too many TTS requests" }
});
app.post("/api/tts", ttsLimiter, async (req, res) => {
// ... proxy do API xAI
});
Walidacja tekstu
Zweryfikuj i oczyść tekst przed wysłaniem go do 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)");
}
// Usuń znaki kontrolne
return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}
Buforowanie audio
Dla powtarzających się tekstów (powitania, standardowe instrukcje) buforuj wygenerowane 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;
}
Wstępne generowanie
Dla treści znanych z góry (e-learning, IVR) generuj pliki audio z wyprzedzeniem podczas budowania aplikacji, a nie w locie.
Kluczowe wnioski
- Używaj w przeglądarce MP3 lub WAV, nigdy PCM/mulaw/alaw
- W Safari twórz AudioContext wewnątrz obsługi zdarzenia wywołanego przez użytkownika
- Zawsze zwalniaj adresy URL obiektów Blob za pomocą
URL.revokeObjectURL()po użyciu - Dodaj limitowanie częstotliwości żądań do swojego proxy backendowego
- Waliduj i czyść tekst przed wysłaniem go do API
- Buforuj audio dla powtarzających się tekstów, aby oszczędzać wywołania API
- Generuj audio z wyprzedzeniem dla treści znanych z góry
Sprawdź swoją wiedzę
Synteza mowy xAI: od pierwszego wywołania po potok strumieniowania.
1. Jak działa podstawowe wywołanie TTS?
Odpowiedź: Jest to żądanie POST do /v1/tts z tekstem, wybranym głosem (który możesz列出 poprzez API) i parametrami. Odpowiedzią jest audio, rozliczane według объема zsyntetyzowanego materiału.
2. Co pozwalają robić tagi ekspresyjne?
Odpowiedź: Kontrolować mowę bezpośrednio w tekście: tagi inline i otaczające dla intonacji, pauz i akcentów, które można łączyć, aby uzyskać naturalne, ukierunkowane czytanie.
3. Kiedy należy przejść na TTS WebSocket?
Odpowiedź: W czasie rzeczywistym: tekst wychodzi jako strumień, a audio wraca ciągle. Jest to fundament potoków LLM → TTS, gdzie głos zaczyna się, zanim generowanie zostanie zakończone.
4. Jak zabezpieczyć integrację z przeglądarką?
Odpowiedź: Nigdy nie umieszczaj klucza API po stronie klienta: przeglądarka komunikuje się przez Twój serwer lub używa krótkotrwałych poświadczeń, a Ty prawidłowo obsługujesz błędy HTTP.
5. Jak wygląda kompletny potok produkcyjny?
Odpowiedź: Strumieniowy LLM → segmenty tekstu → TTS WebSocket → odtwarzanie audio. Każde ogniwo działa strumieniowo, więc postrzegane opóźnienie znika, a najlepsze praktyki z tego kursu domykają całość.
Tagi dla ekspresji, WebSocket dla czasu rzeczywistego, Twój serwer dla sekretów: Twoje aplikacje są gotowe, by przemówić.