Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

AudioContext: analizzare e riprodurre l’audio di un elemento multimediale

Invia il suono di un elemento audio o video all’uscita passando per un analizzatore e gestisci il grafo separatamente dalla riproduzione.

Versione: ECMAScript 2024 and the current web platform; runtime support varies

Sintassi

const ctx = new AudioContext();
const analyser = ctx.createAnalyser();
const source = ctx.createMediaElementSource(mediaElement); // HTMLMediaElement
source.connect(analyser);
analyser.connect(ctx.destination);
// In an async handler for a user action:
await Promise.all([ctx.resume(), mediaElement.play()]);
const state = ctx.state;

Invoca i metodi su un’istanza di AudioContext, non sul costruttore. L’istanza eredita createAnalyser(), state e destination da BaseAudioContext. Senza argomenti, createAnalyser() restituisce un AnalyserNode che offre la forma d’onda e lo spettro senza modificare il segnale in transito. Per i campioni della forma d’onda usa un Uint8Array di lunghezza fftSize; frequencyBinCount è il numero di intervalli dello spettro, pari alla metà di fftSize.

createMediaElementSource(element) accetta un HTMLMediaElement esistente (audio o video), non un URL. Restituisce un MediaElementAudioSourceNode e reindirizza l’audio dell’elemento nel grafo. Collega la sorgente all’analizzatore e questo a ctx.destination: la proprietà di sola lettura restituisce l’AudioDestinationNode, l’uscita finale del contesto in tempo reale. L’analizzatore può misurare il segnale anche senza un collegamento in uscita, ma quel percorso non sarà udibile. Riutilizza il nodo sorgente: associare di nuovo lo stesso elemento genera InvalidStateError, e scollegare il nodo non annulla l’associazione.

resume() non riceve argomenti e riattiva l’orologio e l’elaborazione del grafo, non la riproduzione dell’elemento. Restituisce una Promise che si risolve quando il contesto riprende e viene rifiutata se è chiuso. OfflineAudioContext.resume() è un metodo distinto per riprendere il rendering offline. Nel gestore di un clic reale, chiama resume() e element.play() prima del primo await; gestisci i rifiuti come NotAllowedError di play(). Usa element.pause() per mettere in pausa il contenuto multimediale.

La proprietà state, di sola lettura, descrive il contesto: running indica che il grafo è in elaborazione, suspended che è in pausa (anche per le regole di riproduzione automatica), closed è definitivo e interrupted segnala un’interruzione esterna, gestita in modo diverso dai browser. Osserva statechange: running non garantisce un suono udibile. Il nodo sorgente emette silenzio per contenuti caricati da un’altra origine senza autorizzazione CORS. Per un file pubblico di un’altra origine, imposta element.crossOrigin = 'anonymous' prima di src e configura le intestazioni CORS del server. Sono API della piattaforma web, non funzionalità di ECMAScript 2024; il supporto varia secondo l’ambiente. Quando il contesto non serve più, close() rilascia le risorse audio di sistema.

Esempi

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Play and analyse</title>
</head>
<body>
  <button id="play" type="button">Play and analyse</button>
  <script>
    (() => {
      function makeTone() {
        const rate = 8000;
        const wav = new Uint8Array(44 + rate);
        const view = new DataView(wav.buffer);
        const text = (offset, value) => wav.set(new TextEncoder().encode(value), offset);

        // One second of mono, unsigned 8-bit PCM in a WAV container.
        text(0, 'RIFF');
        view.setUint32(4, 36 + rate, true);
        text(8, 'WAVEfmt ');
        view.setUint32(16, 16, true);
        view.setUint16(20, 1, true);
        view.setUint16(22, 1, true);
        view.setUint32(24, rate, true);
        view.setUint32(28, rate, true);
        view.setUint16(32, 1, true);
        view.setUint16(34, 8, true);
        text(36, 'data');
        view.setUint32(40, rate, true);
        for (let i = 0; i < rate; i++) {
          wav[44 + i] = 128 + Math.round(12 * Math.sin(2 * Math.PI * 440 * i / rate));
        }
        return new Blob([wav], { type: 'audio/wav' });
      }

      const button = document.getElementById('play');
      button.addEventListener('click', async () => {
        button.disabled = true;
        const media = new Audio();
        let ctx;
        let url;
        try {
          ctx = new AudioContext();
          const analyser = ctx.createAnalyser();
          analyser.fftSize = 1024;
          const source = ctx.createMediaElementSource(media);
          source.connect(analyser);
          analyser.connect(ctx.destination);

          const finished = new Promise((resolve) => {
            media.onended = () => resolve(true);
            media.onerror = () => resolve(false);
          });
          url = URL.createObjectURL(makeTone());
          media.src = url;
          await Promise.all([ctx.resume(), media.play()]);

          const samples = new Uint8Array(analyser.fftSize);
          analyser.getByteTimeDomainData(samples);
          console.log(`state=${ctx.state}; samples=${samples.length}`);
          if (!(await finished)) throw new Error('Media failed during playback');
        } catch (error) {
          console.error(error);
        } finally {
          media.pause();
          media.removeAttribute('src');
          media.load();
          if (url !== undefined) URL.revokeObjectURL(url);
          if (ctx && ctx.state !== 'closed') {
            await ctx.close().catch((error) => console.error(error));
          }
        }
      }, { once: true });
    })();
  </script>
</body>
</html>

Risultato

state=running; samples=1024

Salva l’esempio come `index.html` e aprilo nel browser tramite un server HTTP locale. Apri la console di sviluppo e fai clic su `Play and analyse` nella pagina. Se Web Audio e WAV PCM sono supportati, la riproduzione è consentita e non ci sono interruzioni, il risultato atteso è un breve tono e `state=running; samples=1024`. Il WAV viene generato localmente. Il numero indica la lunghezza dell’array, non quanti campioni sono diversi da zero. Ricarica la pagina per ripetere.

Lezioni correlate

  • JavaScript · Lezione 34 · Avanzato · Versione: 4

Fonti