Date : 27 octobre 2026
Demandeur : Raphaël
Analystes : Claude Code (Sonnet 4.5)
L'architecture audio de JARVIS utilise plusieurs couches de bufferisation pour assurer la continuité vocale en conditions de réseau mobile instable et lors des reconnexions.
| Composant | Paramètre | Valeur Actuelle | Latence / Capacité |
|---|---|---|---|
| Client Android (WebView) | ScriptProcessor bufferSize | 2048 échantillons | ~128 ms par chunk |
| Serveur | recent_pcm_buffer | 192 000 octets | ~6 secondes |
| Serveur | Plafond sécurité (tous buffers) | 19 200 000 octets | ~10 minutes |
| Serveur | hybrid_veille_buffer | 96 000 octets | ~3 secondes (pré-roll) |
| Serveur | Seuil phrase minimum | 9 600 octets | ~300 ms (anti-fragment) |
Fichier : JARVIS_LIVE_VOICE/public/app.js, ligne 2695
this.processor = this.audioContext.createScriptProcessor(2048, 1, 1);
Pipeline audio complet :
1. MediaStreamSource (micro) → 2. Highpass Filter (85 Hz) → 3. Notch Filter (6200 Hz, optionnel) → 4. Compressor (seuil -34 dBFS, ratio 3.5:1) → 5. Makeup Gain (+7.5 dB) → 6. Analyser (FFT 256) → 7. ScriptProcessor (2048 samples) → 8. Destination + WebSocket
Fichier : JARVIS_LIVE_VOICE/server.py
recent_pcm_buffer (ligne 9051)recent_pcm_buffer = bytearray() # ring buffer glissant, ~6s de micro brut
recent_pcm_buffer.extend(pcm)
if len(recent_pcm_buffer) > 192000:
del recent_pcm_buffer[:len(recent_pcm_buffer) - 192000]
turn_user_pcm = bytearray() # tour micro utilisateur courant pour Audio Vault
turn_jarvis_pcm = bytearray() # tour voix Jarvis courant pour Audio Vault
robuste_audio_buffer = bytearray() # accumulation jusqu'à signal "silence_detected"
swap_pcm_buffer = bytearray() # absorption audio pendant hot-swap / live_tour
Plafond de sécurité universel : 19 200 000 octets (~10 minutes)
if len(robuste_audio_buffer) > 19200000:
del robuste_audio_buffer[:-19200000]
audio_buffer, robuste_audio_buffer, turn_user_pcm, turn_jarvis_pcm)hybrid_veille_buffer = bytearray() # pre-roll conserve pendant la veille
live_hybrid pour ne pas perdre le début de la phrasehybrid_veille_buffer.extend(pcm)
if len(hybrid_veille_buffer) > 96000: # ~3s de pre-roll max
del hybrid_veille_buffer[:-96000]
MIN_PHRASE_PCM_BYTES = 9600 # ~300ms de parole minimum avant transcription/envoi
Android Micro (WebView)
↓ [ScriptProcessor 2048 samples ~128ms]
WebSocket (PCM 16kHz 16-bit)
↓
Serveur Python (FastAPI)
↓ [recent_pcm_buffer 192000 octets ~6s]
↓ [swap_pcm_buffer si reconnexion]
Gemini Live API (streaming)
↓
Client (playback AudioBuffer)
Android Micro (WebView)
↓ [ScriptProcessor 2048 samples ~128ms]
↓ [VAD client: accumulation jusqu'à silence]
WebSocket (PCM complet)
↓
Serveur Python
↓ [robuste_audio_buffer, plafond 19.2 Mo]
↓ [Garde-fou idle: flush après 2.5s sans chunk]
Transcription (Whisper / Deepgram)
↓
Cerveau IA (texte)
↓
TTS (Edge-TTS / Coqui)
↓
Client (playback AudioBuffer)
| Capacité | Octets | Durée Équivalente | Usage |
|---|---|---|---|
| ScriptProcessor chunk | 4 096 | ~128 ms | Granularité transmission |
| recent_pcm_buffer | 192 000 | ~6 secondes | Vérif. similarité vocale |
| hybrid_veille_buffer | 96 000 | ~3 secondes | Pré-roll réveil mode hybride |
| MIN_PHRASE_PCM_BYTES | 9 600 | ~300 ms | Seuil phrase valide |
| Plafond sécurité | 19 200 000 | ~10 minutes | Monologues longs sans coupure |
Formule de conversion :
- PCM 16 kHz mono 16 bits = 32 000 octets/seconde
- 1 seconde = 32 000 octets
- 1 minute = 1 920 000 octets
- 10 minutes = 19 200 000 octets
swap_pcm_buffer absorbe l'audio pendant les coupuresrobuste_audio_buffer si le client ne renvoie jamais silence_detectednextPlayTime ajusté si dérive)Fichier : JARVIS_LIVE_VOICE/JARVIS_VOICE_CONFIG.json
Aucun paramètre de buffer explicite n'y est défini — les valeurs sont hardcodées dans le code source :
- public/app.js (client)
- server.py (serveur)
Fichier : JARVIS_LIVE_VOICE/public/app.js, ligne 2695
// Valeur actuelle : 2048 (choix optimal pour latence/qualité)
this.processor = this.audioContext.createScriptProcessor(2048, 1, 1);
// Valeurs possibles (standard Web Audio API) :
// 256, 512, 1024, 2048, 4096, 8192, 16384
// ⚠️ 256-512 = latence ultra-basse mais charge CPU élevée
// ⚠️ 8192-16384 = latence perceptible (>500ms)
Fichier : JARVIS_LIVE_VOICE/server.py, ligne 9314
# Valeur actuelle : 192 000 octets (~6s)
if len(recent_pcm_buffer) > 192000:
del recent_pcm_buffer[:len(recent_pcm_buffer) - 192000]
# Exemple pour passer à ~10 secondes :
# if len(recent_pcm_buffer) > 320000:
# del recent_pcm_buffer[:len(recent_pcm_buffer) - 320000]
Les paramètres actuels représentent un équilibre optimal entre :
- Latence perçue (~128 ms de granularité, acceptable pour interaction vocale)
- Résilience réseau (6s de buffer de vérification + 10 min de plafond sécurité)
- Charge CPU (2048 échantillons = traitement toutes les 128 ms, raisonnable)
| Scénario | Paramètre à Modifier | Nouvelle Valeur Suggérée |
|---|---|---|
| Latence trop élevée | ScriptProcessor bufferSize | 1024 (latence ~64 ms) |
| Coupures fréquentes en 4G | recent_pcm_buffer | 320 000 octets (~10s) |
| Monologues > 10 min | Plafond sécurité | 38 400 000 octets (~20 min) |
| Charge CPU élevée | ScriptProcessor bufferSize | 4096 (latence ~256 ms) |
⚠️ Attention : Toute modification nécessite :
1. Rebuild de l'APK Android (si modification client)
2. Redémarrage du serveur Python (si modification serveur)
3. Tests terrain en conditions réelles (4G + WiFi instable)
JARVIS_LIVE_VOICE/public/app.js (lignes 2695, 2541-2594)
- Initialisation AudioContext
- Pipeline DSP (filtres adaptatifs)
- ScriptProcessor configuration
JARVIS_LIVE_VOICE/server.py (lignes 9051-9083, 402, 9314)
- Déclaration des buffers globaux
- Gestion des plafonds de sécurité
- Garde-fous idle et résilience
JARVIS_LIVE_VOICE/JARVIS_VOICE_CONFIG.json
- Configuration modes vocaux (live_hybrid actif)
- Paramètres TTS et persona
L'architecture actuelle de JARVIS utilise une bufferisation multi-niveaux robuste :
- Client : 2048 échantillons (~128 ms) pour transmission réactive
- Serveur : 192 000 octets (~6s) pour vérification biométrique + plafond 10 min pour monologues longs
Ces paramètres ont été éprouvés en production et reflètent les correctifs successifs des incidents réels (hot-swap, garde-fou idle, jitter buffer). Aucune modification n'est recommandée sans contexte de bug avéré.
Rapport généré le : 2026-10-27 à 09:02 UTC-4 (Guadeloupe)
Prochain audit recommandé : Après 100 heures cumulées d'usage vocal