Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Integrācija pārlūkprogrammā un labākā prakse

Nodarbība 14 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. TTS izvietošana tīmekļa lietotnē
  2. Pārlūkprogrammu kodeku atbalsts
  3. Safari AudioContext problēma
  4. Blob URL un atmiņas noplūdes
  5. Labākā prakse ražošanas vidē
  6. Galvenās atziņas
  7. Pārbaudi savas zināšanas

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:

KodeksChromeFirefoxSafariEdgeIeteicams
MP3JāJāJāJāJā
WAVJāJāJāJāJā
Raw PCMNēNēNēNēNē
mulaw/alawNē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.