Généré le 27/10/2026 22:25

Rapport : Paramètres de Buffer Audio - JARVIS Live Voice

Date : 27 octobre 2026
Demandeur : Raphaël
Analystes : Claude Code (Sonnet 4.5)


📊 Synthèse Exécutive

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.

Paramètres Clés Identifiés

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)

🔍 Détails Techniques par Couche

1. Côté Client Android (JavaScript dans WebView)

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


2. Côté Serveur (Python FastAPI)

Fichier : JARVIS_LIVE_VOICE/server.py

Buffer Principal : 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]

Buffers de Mode Vocal (lignes 9052-9054, 9076)

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]

Buffer Mode Hybride (ligne 9083)

hybrid_veille_buffer = bytearray()  # pre-roll conserve pendant la veille
hybrid_veille_buffer.extend(pcm)
if len(hybrid_veille_buffer) > 96000:  # ~3s de pre-roll max
    del hybrid_veille_buffer[:-96000]

Seuil Minimal de Phrase (ligne 402)

MIN_PHRASE_PCM_BYTES = 9600  # ~300ms de parole minimum avant transcription/envoi

🔄 Flux de Données Audio

Mode Live Continu

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)

Mode Robuste (Tour par Tour)

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és Calculées

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


🛡️ Mécanismes de Résilience

1. Hot Audio Engine (24/09/2026)

2. Garde-fou Idle Mode Robuste (18/10/2026)

3. Jitter Buffer Adaptatif (12/10/2026)


🔧 Paramètres Configurables

Fichier de Configuration Global

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)

Modification des Buffers

Pour Augmenter le Buffer Client (WebView)

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)

Pour Augmenter le Buffer Serveur Principal

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]

📝 Recommandations

État Actuel : ✅ Optimisé

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)

Cas d'Ajustement Potentiel

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)


📚 Fichiers Sources Analysés

  1. JARVIS_LIVE_VOICE/public/app.js (lignes 2695, 2541-2594)
    - Initialisation AudioContext
    - Pipeline DSP (filtres adaptatifs)
    - ScriptProcessor configuration

  2. 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

  3. JARVIS_LIVE_VOICE/JARVIS_VOICE_CONFIG.json
    - Configuration modes vocaux (live_hybrid actif)
    - Paramètres TTS et persona


🎯 Conclusion

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