Créer un visualiseur audio avec Web Audio API

Transformez l'audio en visualisations dynamiques et interactives avec la Web Audio API et Canvas. Du spectre de fréquences à la forme d'onde, créez des expériences visuelles immersives.

Introduction

La Web Audio API est l'une des APIs les plus puissantes du navigateur. Elle permet d'analyser, de traiter et de générer de l'audio en temps réel. Combinée avec Canvas, elle ouvre la porte à des visualisations audio spectaculaires directement dans le navigateur.

Dans ce tutoriel, nous allons construire 3 types de visualisations différentes : un spectre de fréquences en barres, une forme d'onde oscilloscope et un cercle radial réactif. Chaque exemple est accompagné du code complet et d'une demo interactive.

💡
Bon à savoir

La Web Audio API nécessite une interaction utilisateur (clic) avant de pouvoir démarrer, conformément aux politiques de lecture automatique des navigateurs modernes.

1. Configuration de base

Avant de créer nos visualisations, nous devons configurer le contexte audio et l'analyseur. L'AnalyserNode est le coeur de toute visualisation audio : il extrait les données de fréquence et de forme d'onde en temps réel.

audio-setup.js
// Creer le contexte audio
const audioContext = new AudioContext();
const analyser = audioContext.createAnalyser();

// fftSize determine la precision de l'analyse
// Plus la valeur est grande, plus l'analyse est fine
analyser.fftSize = 256;

// Connecter le microphone
navigator.mediaDevices.getUserMedia({ audio: true })
    .then(stream => {
        const source = audioContext.createMediaStreamSource(stream);
        source.connect(analyser);
        visualize();
    });

Les paramètres clés de l'AnalyserNode

  • fftSize : Taille de la FFT (Fast Fourier Transform). Valeurs possibles : 32 à 32768. Détermine le nombre de barres de fréquence (fftSize / 2)
  • frequencyBinCount : Nombre de points de données disponibles (= fftSize / 2)
  • smoothingTimeConstant : Lissage temporel entre 0 et 1. Plus la valeur est haute, plus la transition est douce
  • minDecibels / maxDecibels : Plage de décibels pour la visualisation

2. Barres de fréquence

Le spectre de fréquences est la visualisation audio la plus classique. Chaque barre représente l'amplitude d'une bande de fréquence spécifique, des basses (à gauche) aux aigus (à droite).

frequency-bars.js
function drawBars(analyser, canvas) {
    const ctx = canvas.getContext('2d');
    const bufferLength = analyser.frequencyBinCount;
    const dataArray = new Uint8Array(bufferLength);

    function draw() {
        // Recuperer les donnees de frequence
        analyser.getByteFrequencyData(dataArray);

        // Effacer le canvas
        ctx.fillStyle = '#0a0a0f';
        ctx.fillRect(0, 0, canvas.width, canvas.height);

        const barWidth = canvas.width / bufferLength;

        dataArray.forEach((value, i) => {
            const barHeight = value / 1.5;
            // Degrade de couleur base sur la frequence
            const hue = (i / bufferLength) * 270 + 240;
            ctx.fillStyle = `hsl(${hue}, 70%, 50%)`;
            ctx.fillRect(
                i * barWidth,
                canvas.height - barHeight,
                barWidth - 1,
                barHeight
            );
        });

        requestAnimationFrame(draw);
    }
    draw();
}

Comment ça fonctionne

La méthode getByteFrequencyData() remplit un tableau avec les amplitudes de chaque bande de fréquence, sur une échelle de 0 à 255. Voici le détail :

  • requestAnimationFrame : Synchronise le rendu avec le rafraîchissement de l'écran (~60fps)
  • barWidth : Chaque barre occupe une fraction égale de la largeur du canvas
  • Couleur HSL : Le hue varie selon la position pour créer un dégradé de couleurs naturel

3. Forme d'onde (Oscilloscope)

La visualisation en forme d'onde affiche le signal audio brut, comme un oscilloscope. C'est idéal pour voir la structure temporelle du son.

waveform.js
function drawWaveform(analyser, canvas) {
    const ctx = canvas.getContext('2d');
    const bufferLength = analyser.frequencyBinCount;
    const dataArray = new Uint8Array(bufferLength);

    function draw() {
        // Donnees de forme d'onde (pas de frequence)
        analyser.getByteTimeDomainData(dataArray);

        ctx.fillStyle = '#0a0a0f';
        ctx.fillRect(0, 0, canvas.width, canvas.height);

        // Dessiner la courbe
        ctx.lineWidth = 2;
        ctx.strokeStyle = '#6366f1';
        ctx.beginPath();

        const sliceWidth = canvas.width / bufferLength;

        dataArray.forEach((value, i) => {
            const x = i * sliceWidth;
            const y = (value / 128) * (canvas.height / 2);
            i === 0
                ? ctx.moveTo(x, y)
                : ctx.lineTo(x, y);
        });

        ctx.stroke();
        requestAnimationFrame(draw);
    }
    draw();
}
📊
Différence entre les deux méthodes

getByteFrequencyData() renvoie le spectre de fréquences (domaine fréquentiel), tandis que getByteTimeDomainData() renvoie la forme d'onde brute (domaine temporel). Les deux utilisent le même AnalyserNode.

4. Cercle radial

Le cercle radial est une visualisation plus artistique ou les barres de fréquence sont disposées en cercle. C'est un effet très populaire dans les lecteurs de musique et les expériences interactives.

radial-visualizer.js
function drawRadial(analyser, canvas) {
    const ctx = canvas.getContext('2d');
    const bufferLength = analyser.frequencyBinCount;
    const dataArray = new Uint8Array(bufferLength);
    const centerX = canvas.width / 2;
    const centerY = canvas.height / 2;
    const radius = 60;

    function draw() {
        analyser.getByteFrequencyData(dataArray);

        ctx.fillStyle = 'rgba(10, 10, 15, 0.2)';
        ctx.fillRect(0, 0, canvas.width, canvas.height);

        for (let i = 0; i < bufferLength; i++) {
            const angle = (i / bufferLength) * Math.PI * 2;
            const barHeight = dataArray[i] / 3;
            const hue = (i / bufferLength) * 360;

            const x1 = centerX + Math.cos(angle) * radius;
            const y1 = centerY + Math.sin(angle) * radius;
            const x2 = centerX + Math.cos(angle) * (radius + barHeight);
            const y2 = centerY + Math.sin(angle) * (radius + barHeight);

            ctx.strokeStyle = `hsl(${hue}, 70%, 60%)`;
            ctx.lineWidth = 2;
            ctx.beginPath();
            ctx.moveTo(x1, y1);
            ctx.lineTo(x2, y2);
            ctx.stroke();
        }
        requestAnimationFrame(draw);
    }
    draw();
}
⚠️
Performance

La visualisation radiale est plus coûteuse en rendu. Sur mobile, réduisez le fftSize à 128 et limitez le nombre de barres dessinées pour maintenir un framerate fluide.

5. Utiliser un fichier audio

Plutôt que le microphone, vous pouvez aussi visualiser un fichier audio ou un élément <audio>. C'est souvent plus pratiqué pour les sites avec un lecteur musical intégré.

audio-file.js
// Utiliser un element <audio> existant
const audio = document.querySelector('audio');
const audioContext = new AudioContext();
const analyser = audioContext.createAnalyser();

// Creer la source a partir de l'element audio
const source = audioContext.createMediaElementSource(audio);
source.connect(analyser);

// Important : connecter aussi a la destination pour entendre l'audio
analyser.connect(audioContext.destination);

// Lancer la visualisation quand l'audio joue
audio.addEventListener('play', () => {
    audioContext.resume();
    drawBars(analyser, canvas);
});
💡
Astuce importante

Quand vous utilisez createMediaElementSource(), n'oubliez pas de connecter l'analyseur à audioContext.destination, sinon l'audio sera muet ! Avec le microphone, cette connexion n'est pas nécessaire car on ne veut pas de retour audio.

Bonnes pratiques

Voici les recommandations essentielles pour créer des visualiseurs audio performants et accessibles :

Performance

  • Réduisez le fftSize sur mobile : 128 ou 64 suffisent pour un rendu fluide
  • Utilisez requestAnimationFrame plutôt que setInterval pour synchroniser avec l'écran
  • Évitez les allocations dans la boucle : créez vos tableaux en dehors de la fonction draw
  • Nettoyez les ressources : fermez l'AudioContext et arrêtez le stream micro quand la page est quittée

Accessibilité et UX

  • Demandez la permission : l'accès au micro doit être déclenché par un clic utilisateur
  • Gérez les erreurs : prévoyez le cas où l'utilisateur refuse l'accès au micro
  • Respectez prefers-reduced-motion : proposez une version statique pour les utilisateurs sensibles

Nettoyage des ressources

cleanup.js
// Arreter proprement le visualiseur
function stopVisualizer(stream, audioContext, animationId) {
    // Arreter le micro
    stream.getTracks().forEach(track => track.stop());

    // Fermer le contexte audio
    audioContext.close();

    // Arreter l'animation
    cancelAnimationFrame(animationId);
}

Conclusion

La Web Audio API ouvre un monde de possibilités créatives. En combinant l'analyse de fréquences avec Canvas, vous pouvez créer des visualisations uniques qui réagissent au son en temps réel.

Les trois types de visualisation que nous avons vus (barres, forme d'onde, cercle radial) ne sont que le début. Vous pouvez les combiner, ajouter des effets de particules, ou même utiliser WebGL pour des rendus 3D.

🎨
Allez plus loin

Découvrez nos effets interactifs bases sur l'audio dans notre bibliothèque d'effets, avec code copiable en un clic.

50+ effets Particules & FX prêts à copier

Aperçu live, customizer, code vanilla — zéro dépendance.

Voir les effets Particules

Les effets de cet article dans le catalogue

Les mêmes techniques, prêtes à copier : aperçu en direct, réglages et code complet sur la page de leur catégorie.

À lire aussi

Trois articles proches pour aller plus loin.