Add Orpheus TTS integration with fallback to Wav2Lip audio

- Add Orpheus TTS WebSocket client (ws://localhost:8081/ws)
- Fetch high-quality audio from Orpheus in parallel with Wav2Lip frames
- Fallback to Wav2Lip eSpeak audio when Orpheus is unavailable
- Audio is sent as binary PCM for efficient streaming

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

interface/server_optimized.py

@@ -25,8 +25,10 @@ import struct
 
 # Configuracao
 WAV2LIP_WS = os.getenv("WAV2LIP_WS", "ws://localhost:8082/ws")
+ORPHEUS_WS = os.getenv("ORPHEUS_WS", "ws://localhost:8081/ws")
 PORT = int(os.getenv("PORT", "8080"))
 VIDEO_FPS = 25
+AUDIO_SAMPLE_RATE = 24000
 
 routes = web.RouteTableDef()
 
@@ -73,8 +75,54 @@ class OptimizedSession:
         except Exception as e:
             print(f"Erro enviando audio binário: {e}")
 
+    async def fetch_audio_from_orpheus(self, session, text: str, voice: str):
+        """Busca áudio do Orpheus TTS via WebSocket."""
+        audio_chunks = []
+        try:
+            orpheus_ws = await session.ws_connect(
+                ORPHEUS_WS,
+                timeout=aiohttp.ClientWSTimeout(ws_close=60),
+                max_msg_size=10*1024*1024
+            )
+
+            # Enviar requisição para Orpheus (action: synthesize)
+            await orpheus_ws.send_json({
+                "action": "synthesize",
+                "text": text,
+                "voice": voice,
+                "stream": True
+            })
+
+            print(f"[Orpheus] Requisição enviada: '{text[:30]}...'")
+
+            # Receber chunks de áudio
+            async for msg in orpheus_ws:
+                if msg.type == aiohttp.WSMsgType.BINARY:
+                    audio_chunks.append(msg.data)
+                elif msg.type == aiohttp.WSMsgType.TEXT:
+                    data = json.loads(msg.data)
+                    if data.get("type") == "done" or data.get("done"):
+                        break
+                    elif data.get("type") == "error":
+                        print(f"[Orpheus] Erro: {data.get('message')}")
+                        break
+                elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                    break
+
+            await orpheus_ws.close()
+
+        except Exception as e:
+            print(f"[Orpheus] Erro: {e}")
+
+        # Concatenar chunks
+        if audio_chunks:
+            full_audio = b''.join(audio_chunks)
+            print(f"[Orpheus] Audio recebido: {len(full_audio)} bytes")
+            return full_audio
+        return None
+
     async def run(self, text: str, voice: str):
-        """Streaming otimizado com binário."""
+        """Streaming otimizado com binário - audio do Orpheus TTS."""
         self.is_running = True
         self.start_time = time.time()
         self.total_bytes = 0
@@ -83,6 +131,11 @@ class OptimizedSession:
 
         try:
             async with aiohttp.ClientSession() as session:
+                # Iniciar busca de áudio do Orpheus em paralelo
+                audio_task = asyncio.create_task(
+                    self.fetch_audio_from_orpheus(session, text, voice)
+                )
+
                 wav2lip_ws = await session.ws_connect(
                     WAV2LIP_WS,
                     timeout=aiohttp.ClientWSTimeout(ws_close=300),
@@ -91,7 +144,7 @@ class OptimizedSession:
 
                 await self.send_json("status", message="Gerando...")
 
-                # Enviar texto para Wav2Lip
+                # Enviar texto para Wav2Lip (ainda usa eSpeak para lip sync)
                 await wav2lip_ws.send_json({
                     "action": "speak",
                     "text": text,
@@ -102,8 +155,9 @@ class OptimizedSession:
                 print(f"[Optimized] Texto: '{text[:50]}...'")
 
                 first_frame_time = None
+                audio_sent = False
 
-                # Receber e repassar
+                # Receber frames do Wav2Lip
                 async for msg in wav2lip_ws:
                     if not self.is_running:
                         break
@@ -118,7 +172,7 @@ class OptimizedSession:
                             frame_bytes = base64.b64decode(frame_b64)
                             self.total_frames += 1
 
-                            # Enviar como binário puro (sem re-encodar para base64)
+                            # Enviar como binário puro
                             await self.send_binary_frame(frame_bytes, self.total_frames)
 
                             if first_frame_time is None:
@@ -127,20 +181,39 @@ class OptimizedSession:
                                 print(f"[Optimized] Primeiro frame: {latency_ms}ms")
                                 await self.send_json("first_frame", latency_ms=latency_ms)
 
-                        elif msg_type == "full_audio":
-                            # Decodificar e enviar como binário
-                            audio_b64 = data.get("audio", "")
-                            audio_bytes = base64.b64decode(audio_b64)
-                            sample_rate = 24000
+                            # Enviar áudio do Orpheus quando disponível (apenas uma vez)
+                            if not audio_sent and audio_task.done():
+                                audio_bytes = audio_task.result()
+                                if audio_bytes:
+                                    # Extrair PCM se for WAV
+                                    if len(audio_bytes) > 44 and audio_bytes[:4] == b'RIFF':
+                                        audio_bytes = audio_bytes[44:]
+                                    await self.send_binary_audio(audio_bytes, AUDIO_SAMPLE_RATE)
+                                    print(f"[Optimized] Audio Orpheus: {len(audio_bytes)} bytes")
+                                    audio_sent = True
 
-                            # Extrair PCM se for WAV
-                            if len(audio_bytes) > 44 and audio_bytes[:4] == b'RIFF':
-                                audio_bytes = audio_bytes[44:]
-
-                            await self.send_binary_audio(audio_bytes, sample_rate)
-                            print(f"[Optimized] Audio: {len(audio_bytes)} bytes")
+                        elif msg_type == "full_audio":
+                            # Usar áudio do Wav2Lip como fallback se Orpheus não enviou
+                            if not audio_sent:
+                                wav_audio = data.get("audio", "")
+                                if wav_audio:
+                                    audio_bytes = base64.b64decode(wav_audio)
+                                    # Extrair PCM se for WAV
+                                    if len(audio_bytes) > 44 and audio_bytes[:4] == b'RIFF':
+                                        audio_bytes = audio_bytes[44:]
+                                    await self.send_binary_audio(audio_bytes, AUDIO_SAMPLE_RATE)
+                                    print(f"[Optimized] Audio Wav2Lip fallback: {len(audio_bytes)} bytes")
+                                    audio_sent = True
 
                         elif msg_type == "done":
+                            # Garantir que audio foi enviado
+                            if not audio_sent:
+                                audio_bytes = await audio_task
+                                if audio_bytes:
+                                    if len(audio_bytes) > 44 and audio_bytes[:4] == b'RIFF':
+                                        audio_bytes = audio_bytes[44:]
+                                    await self.send_binary_audio(audio_bytes, AUDIO_SAMPLE_RATE)
+                                    print(f"[Optimized] Audio Orpheus (final): {len(audio_bytes)} bytes")
                             print(f"[Optimized] Concluído: {self.total_frames} frames")
                             break
 
@@ -159,6 +232,10 @@ class OptimizedSession:
 
                 await wav2lip_ws.close()
 
+                # Cancelar task de audio se ainda estiver rodando
+                if not audio_task.done():
+                    audio_task.cancel()
+
         except Exception as e:
             print(f"Erro: {e}")
             import traceback
@@ -168,7 +245,6 @@ class OptimizedSession:
 
         # Finalizar
         elapsed = time.time() - self.start_time
-        savings = self.total_bytes  # vs base64 seria ~33% maior
 
         print(f"Sessao: {elapsed:.2f}s, {self.total_frames} frames, {self.total_bytes/1024:.1f}KB binário")