Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Browserintegration og bedste praksis

Lektion 14 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Implementér TTS i en webapp
  2. Browser-understøttelse af codecs
  3. Safari AudioContext-problemet
  4. Blob-URL’er og hukommelseslækager
  5. Bedste praksis til produktion
  6. Vigtige pointer
  7. Tjek din forståelse

Opdateret 3. november 2026 baseret på xAI-siden Text to Speech: Validering på serversiden bruger den aktuelle grænse på 60.000 tegn pr. anmodning. Kilde: Text to Speech.

Implementér TTS i en webapp

Integrering af TTS i en browser indebærer specifikke udfordringer: codec-understøttelse, hukommelseshåndtering, Safari-egenskaber og ydeevne. Denne sidste lektion giver dig det, du skal bruge til en robust produktionsintegration.

Browser-understøttelse af codecs

Ikke alle browsere understøtter alle audio-formater. Vælg den rigtige codec til dit publikum:

CodecChromeFirefoxSafariEdgeAnbefalet
MP3JaJaJaJaJa
WAVJaJaJaJaJa
Raw PCMNejNejNejNejNej
mulaw/alawNejNejNejNejNej

Den enkle regel: Brug MP3 eller WAV i browseren. PCM, mulaw og alaw er beregnet til serverapplikationer og telefoni, ikke til afspilning på webbet.

// Anmod om MP3 fra API'et (gennem din 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"
    // Ingen grund til at sætte output_format: MP3 er standard
  })
});

Safari AudioContext-problemet

Safari pålægger en sikkerhedsbegrænsning: En AudioContext kan kun oprettes inde i en brugerhændelseshandler (klik, tastetryk, tap). Hvis du forsøger at oprette en AudioContext, når siden indlæses, blokerer Safari det stille.

Den forkerte tilgang

// Virker IKKE i Safari
const audioContext = new AudioContext(); // Blokeret!

async function playTTS() {
  const audio = await fetchTTS("Hello");
  // audioContext er suspenderet i Safari...
}

Den rigtige tilgang

let audioContext = null;

// Opret AudioContext ved brugerens første klik
document.getElementById("play-btn").addEventListener("click", async () => {
  if (!audioContext) {
    audioContext = new AudioContext();
  }

  // Genoptag hvis suspenderet
  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);
});

Denne tilgang virker i alle browsere, ikke kun Safari. Det er en god universel praksis.

Blob-URL’er og hukommelseslækager

Når du opretter Blob-URL’er for at afspille lyd, bruger hver URL hukommelse, indtil du eksplicit frigiver den. Uden oprydning vil din app lække hukommelse.

Problemet

// Hvert kald opretter en Blob-URL, der aldrig frigives
async function playTTS(text) {
  const response = await fetch("/api/tts", { ... });
  const blob = await response.blob();
  const url = URL.createObjectURL(blob); // Hukommelseslækage!
  const audio = new Audio(url);
  audio.play();
}

Løsningen

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

  // Frigiv hukommelsen, når afspilningen slutter
  audio.addEventListener("ended", () => {
    URL.revokeObjectURL(url);
  });

  // Frigiv også ved fejl
  audio.addEventListener("error", () => {
    URL.revokeObjectURL(url);
  });

  audio.play();
}

For apps, der genererer meget lyd, skal du holde en liste over aktive URL’er og rydde dem op med jævne mellemrum:

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() {
    // Frigiv hver aktiv URL
    for (const url of this.activeUrls) {
      URL.revokeObjectURL(url);
    }
    this.activeUrls.clear();
  }
}

Bedste praksis til produktion

Rate-begrænsning i backend

Beskyt din backend mod misbrug ved at begrænse antallet af anmodninger pr. bruger:

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

const ttsLimiter = rateLimit({
  windowMs: 60 * 1000, // 1 minut
  max: 10, // 10 anmodninger pr. minut pr. IP
  message: { error: "Too many TTS requests" }
});

app.post("/api/tts", ttsLimiter, async (req, res) => {
  // ... proxy til xAI API'et
});

Tekstvalidering

Valider og sanitér teksten, før du sender den til API’et:

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)");
  }
  // Fjern kontroltegn
  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}

Audio-caching

For gentagne tekster (hilsener, standardinstruktioner) skal du cache det genererede lyd:

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

Forudgenerering

For indhold, du kender på forhånd (f.eks. e-læring, IVR), skal du forudgenerere lydfilerne på byggetidspunktet i stedet for løbende.

Vigtige pointer

  • Brug MP3 eller WAV i browseren, aldrig PCM/mulaw/alaw
  • Opret AudioContext inde i en brugerhændelseshandler i Safari
  • Frigiv altid Blob-URL’er med URL.revokeObjectURL() efter brug
  • Tilføj rate-begrænsning til din backend-proxy
  • Valider og sanitér tekst, før du sender den til API’et
  • Cache lyden for gentagne tekster for at spare API-kald
  • Forudgenerér lyd for indhold, du kender på forhånd

Tjek din forståelse

xAI talesyntese: fra det første kald til streaming-pipelinen.

1. Hvordan fungerer det grundlæggende TTS-kald?

Svar: En POST til /v1/tts med teksten, den valgte stemme (som du kan liste via API’et) og parametrene. Svaret er lyden, der faktureres efter det syntetiserede volumen.

2. Hvad giver udtryksfulde tags dig mulighed for at gøre?

Svar: Styr tale fra inden i teksten: inline- og wrapping-tags for intonation, pauser og betoning, som du kan kombinere til naturlig, styret oplæsning.

3. Hvornår skal du skifte til TTS WebSocket?

Svar: Til realtid: teksten sendes ud som en stream, og lyden kommer tilbage løbende. Det er fundamentet for LLM → TTS-pipeliner, hvor stemmen starter, før genereringen er afsluttet.

4. Hvordan sikrer du en browserintegration?

Svar: Sæt aldrig API-nøglen i klienten: browseren går gennem din server eller bruger kortlivede legitimationer, og du håndterer HTTP-fejl korrekt.

5. Hvordan ser den komplette produktionspipeline ud?

Svar: En streaming LLM → tekstsegmenter → TTS WebSocket → lydafspilning. Hvert led streamer, så den oplevede ventetid kollapser, og bedste praksis fra dette kursus lukker sløjfen.

Tags til udtryksfuldhed, WebSocket til realtid, din server til hemmeligheder: dine apps er klar til at tale.