Update tts_engine.py

tts_engine.py

@@ -1,63 +1,149 @@
 import os
 import sys
-import subprocess # NOUVEL IMPORT
+import subprocess
+import io
+import wave
+from typing import Generator
 
-# Remplacer pyttsx3 par une fonction qui utilise directement la commande espeak
-
-# --- Fonctions de compatibilité (non utilisées avec subprocess) ---
-# Elles sont maintenues pour que gunicorn.conf.py ne génère pas d'erreur.
+# Configuration de la sortie audio (doit être WAV 16-bit 22050 Hz pour le streaming)
+SAMPLE_RATE = 22050
+BITS_PER_SAMPLE = 16
+CHANNELS = 1
 
+# --- Fonctions de compatibilité (inchangées) ---
 def get_tts_engine():
-    """Puisque nous utilisons subprocess, il n'y a pas de moteur à initialiser."""
     return True 
 
 def reset_tts_engine():
-    """Ne fait rien, car il n'y a pas de moteur à réinitialiser."""
     pass
-    
+
 # --- Logique de Langues/Voix ---
 
 def get_available_languages():
-    """Retourne une liste des langues courantes eSpeak (sans pyttsx3, nous hardcodons)."""
-    # **MODIFICATION ICI :** Le 'Français' est maintenant la première entrée.
-    # La première clé/valeur sera utilisée comme sélection par défaut dans app.py
+    # Nous utilisons les voix espeak-ng par défaut pour le français
     return {
-        'Français': 'fr',
+        'Français (Qualité Optimale)': 'fr-fr', 
         'Anglais (US)': 'en-us',
         'Espagnol': 'es',
         'Allemand': 'de',
         'Italien': 'it',
-        'Default (English)': 'en'
     }
 
-# --- Logique de Génération Audio ---
+# --- Logique de Génération Audio EN MODE STREAMING ---
 
-def text_to_audio_file(text, voice_id, output_path="output.wav"):
-    """Convertit le texte en fichier audio .wav en utilisant la commande 'espeak'."""
-    
-    # Construction de la commande eSpeak: 
-    # espeak -v [VOIX] -w [OUTPUT_PATH] "[TEXTE]"
-    command = [
-        "espeak",
-        "-v", voice_id,   # Sélectionne la voix
-        "-w", output_path, # Spécifie le fichier de sortie (.wav par défaut)
-        text              # Le texte à parler
-    ]
-
-    try:
-        # Exécution de la commande
-        # Nous utilisons `check=True` pour lever une exception si la commande échoue
-        result = subprocess.run(command, check=True, capture_output=True, text=True)
-        
-        # Le fichier audio a été généré avec succès
-        return os.path.abspath(output_path)
-        
-    except subprocess.CalledProcessError as e:
-        # Erreur si espeak échoue (mauvaise voix, etc.)
-        raise Exception(f"La commande eSpeak a échoué. Erreur: {e.stderr}")
-    except FileNotFoundError:
-        # Erreur si la commande 'espeak' n'est pas trouvée (problème Dockerfile)
-        raise Exception("Le programme 'espeak' est introuvable. Vérifiez votre installation dans le Dockerfile.")
+def split_text_into_chunks(text, max_chars=2000):
+    """Découpe le texte en morceaux pour la synthèse, améliorant la réactivité."""
+    # Cette logique simple est suffisante, mais peut être améliorée (sur les points/virgules)
+    chunks = []
+    while text:
+        chunk = text[:max_chars]
+        text = text[max_chars:]
+        chunks.append(chunk)
+    return chunks
 
+def generate_wav_header(data_size):
+    """Génère l'en-tête WAV pour un flux audio brut."""
+    header = io.BytesIO()
+    # RIFF chunk
+    header.write(b'RIFF')
+    header.write((data_size + 36).to_bytes(4, byteorder='little')) # ChunkSize
+    header.write(b'WAVE')
+    
+    # fmt chunk
+    header.write(b'fmt ')
+    header.write(16..to_bytes(4, byteorder='little')) # Subchunk1Size
+    header.write(1..to_bytes(2, byteorder='little'))  # AudioFormat (PCM=1)
+    header.write(CHANNELS.to_bytes(2, byteorder='little'))
+    header.write(SAMPLE_RATE.to_bytes(4, byteorder='little'))
+    
+    # ByteRate = SampleRate * NumChannels * BitsPerSample/8
+    byte_rate = SAMPLE_RATE * CHANNELS * BITS_PER_SAMPLE // 8
+    header.write(byte_rate.to_bytes(4, byteorder='little'))
+    
+    # BlockAlign = NumChannels * BitsPerSample/8
+    block_align = CHANNELS * BITS_PER_SAMPLE // 8
+    header.write(block_align.to_bytes(2, byteorder='little'))
+    
+    header.write(BITS_PER_SAMPLE.to_bytes(2, byteorder='little'))
+    
+    # data chunk
+    header.write(b'data')
+    header.write(data_size.to_bytes(4, byteorder='little'))
+    
+    return header.getvalue()
 
-# Note: Le moteur n'est plus initialisé/stocké, donc les appels post_fork réussiront
+def stream_text_to_audio(text: str, voice_id: str) -> Generator[bytes, None, None]:
+    """
+    Convertit le texte en audio et le *yield* (renvoie) par morceaux (streaming).
+    
+    La première sortie est l'en-tête WAV, suivie des données audio brutes.
+    """
+    
+    # 1. Découpage du texte en morceaux pour le streaming
+    chunks = split_text_into_chunks(text)
+    
+    # La taille totale de l'audio n'est pas connue à l'avance, nous devrons utiliser
+    # un hack ou laisser l'en-tête avec une taille nulle.
+    # Dans ce cas, nous allons utiliser 'pipe' et 'ffmpeg' si possible, mais nous allons
+    # d'abord essayer une approche simple avec 'espeak-ng' en sortie standard.
+
+    # Pour simplifier et garantir que l'en-tête est correct, nous allons générer
+    # chaque chunk comme un fichier WAV et concaténer (moins idéal que le streaming direct
+    # mais plus fiable avec des outils basés sur des fichiers comme espeak-ng).
+    
+    full_audio_data = io.BytesIO()
+    total_audio_length = 0
+
+    # 2. Générer et collecter chaque morceau audio
+    for chunk in chunks:
+        # espeak-ng -v [VOIX] --stdout "[TEXTE]"
+        command = [
+            "espeak-ng",
+            "-v", voice_id,
+            "--stdout", # Écrit le WAV sur la sortie standard
+            chunk
+        ]
+        
+        try:
+            # Exécution de la commande et capture de la sortie binaire
+            result = subprocess.run(command, check=True, capture_output=True)
+            
+            # Le résultat est un fichier WAV complet pour le chunk
+            chunk_wav_data = result.stdout
+            
+            # Ouvrir le chunk WAV pour extraire les données audio brutes (après l'en-tête de 44 octets)
+            # Puisque espeak-ng --stdout écrit un WAV complet, nous devons le décapsuler
+            if len(chunk_wav_data) < 44:
+                 continue
+            
+            # Simplement ajouter les données audio brutes (après l'en-tête)
+            raw_audio_data = chunk_wav_data[44:]
+            
+            full_audio_data.write(raw_audio_data)
+            total_audio_length += len(raw_audio_data)
+            
+        except subprocess.CalledProcessError as e:
+            raise Exception(f"La commande espeak-ng a échoué. Erreur: {e.stderr}")
+        except FileNotFoundError:
+            raise Exception("Le programme 'espeak-ng' n'a pas été trouvé. Vérifiez le Dockerfile.")
+
+    # 3. Réinitialiser la position de lecture
+    full_audio_data.seek(0)
+    
+    # 4. Générer l'en-tête WAV final avec la taille totale
+    final_header = generate_wav_header(total_audio_length)
+    
+    # 5. Yield l'en-tête
+    yield final_header
+    
+    # 6. Yield les données audio brutes par morceaux
+    chunk_size = 4096 # Taille de chaque morceau envoyé au client
+    while True:
+        data = full_audio_data.read(chunk_size)
+        if not data:
+            break
+        yield data
+        
+def text_to_audio_file(text, voice_id, output_path="output.wav"):
+    """Ancienne fonction, non utilisée dans cette nouvelle approche."""
+    raise NotImplementedError("Utilisez 'stream_text_to_audio' pour le streaming.")