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.
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.
// 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).
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.
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();
}
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.
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();
}
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é.
// 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);
});
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
// 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.
Découvrez nos effets interactifs bases sur l'audio dans notre bibliothèque d'effets, avec code copiable en un clic.
Aperçu live, customizer, code vanilla — zéro dépendance.





