Implement parallel streaming: Orpheus audio + Wav2Lip frames

- Connect to Orpheus TTS and Wav2Lip in parallel
- Receive audio chunks from Orpheus WebSocket (high quality)
- Receive JPEG frames from Wav2Lip (lip sync with internal eSpeak)
- Discard Wav2Lip audio, use only Orpheus audio
- Mount and send chunks immediately as data arrives
- Add test_streaming.py client for testing
- Update CLAUDE.md with new architecture

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

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

interface/CLAUDE.md

@@ -1,31 +1,58 @@
 # Avatar Interface - Sistema de Streaming de Video com Lip Sync
 
-## OBJETIVOS DO PROJETO
+## ARQUITETURA PRINCIPAL
 
-### Requisitos Obrigatorios (MUST HAVE)
+```
+┌─────────────┐      ┌─────────────────────────────────┐      ┌─────────────────┐
+│  Frontend   │◄────►│      Interface Server           │◄────►│  Orpheus TTS    │
+│  (Browser)  │  WS  │        (porta 8080)             │  WS  │  (porta 8081)   │
+└─────────────┘      │                                 │      │  chunks audio   │
+                     │  1. Recebe texto do frontend    │      └─────────────────┘
+                     │  2. Conecta Orpheus + Wav2Lip   │
+                     │     EM PARALELO                 │      ┌─────────────────┐
+                     │  3. Recebe chunks conforme      │◄────►│  Wav2Lip        │
+                     │     chegam de ambos             │  WS  │  (porta 8082)   │
+                     │  4. Monta: audio Orpheus +      │      │  frames JPEG    │
+                     │     frames Wav2Lip              │      │  (NAO MODIFICAR)│
+                     │  5. Envia chunk IMEDIATAMENTE   │      └─────────────────┘
+                     └─────────────────────────────────┘
+```
 
-1. **Processamento Paralelo de Audio e Video**
-   - Wav2Lip (video) e Orpheus TTS (audio) DEVEM ser chamados em PARALELO
-   - O servidor deve iniciar ambas as conexoes WebSocket ao mesmo tempo
-   - Nao esperar um terminar para comecar o outro
-   - Isso reduz a latencia total pela metade
+## FLUXO DE STREAMING
 
-2. **Reproducao Progressiva (Streaming Real)**
-   - O frontend DEVE comecar a reproduzir ANTES de receber todos os dados
-   - Assim que tiver frames + audio suficientes, iniciar playback
-   - Continuar recebendo dados enquanto reproduz
-   - Meta: latencia < 500ms entre clique e inicio da reproducao
-   - Atualmente: ~3 segundos (espera tudo chegar antes de reproduzir)
+```
+1. Frontend envia: {"action": "generate", "text": "Hello", "voice": "tara"}
+   │
+   ▼
+2. Interface conecta EM PARALELO:
+   ├── Orpheus WS (8081) → recebe chunks de audio PCM 24kHz
+   └── Wav2Lip WS (8082) → recebe frames JPEG (lip sync com eSpeak interno)
+   │
+   ▼
+3. Conforme dados chegam, acumula em buffers:
+   - audio_buffer: chunks PCM do Orpheus
+   - frame_buffer: frames JPEG do Wav2Lip
+   │
+   ▼
+4. Quando tem 1 frame + audio correspondente (~1920 bytes = 40ms):
+   - Monta chunk binario: [audio_orpheus + frame_wav2lip]
+   - Envia IMEDIATAMENTE para frontend
+   │
+   ▼
+5. Frontend reproduz em tempo real (nao espera tudo chegar)
+```
+
+## REGRAS CRITICAS
+
+1. **NAO MODIFICAR O WAV2LIP** - Ele ja gera lip sync com eSpeak interno. So usar os frames JPEG.
 
-3. **Sincronizacao Perfeita Audio/Video**
-   - O video deve parar exatamente quando o audio termina
-   - Usar audioExpectedEndTime para controlar fim dos frames
-   - Transicao suave (crossfade 300ms) para o video idle
+2. **AUDIO VEM DO ORPHEUS** - O audio robotico do Wav2Lip e DESCARTADO. Audio final = Orpheus.
 
-4. **Continuidade do Video Idle**
-   - O video idle deve continuar do frame exato onde o Wav2Lip parou
-   - Usar end_video_time_ms para posicionar o video idle
-   - Video idle em loop infinito quando nao esta falando
+3. **CONEXOES EM PARALELO** - Orpheus e Wav2Lip devem ser chamados ao mesmo tempo.
+
+4. **STREAMING IMEDIATO** - Montar e enviar chunks conforme dados chegam, nao esperar tudo.
+
+5. **SINCRONIZACAO** - Calcular audio_por_frame = total_audio / total_frames para alinhar.
 
 ---
 
@@ -47,63 +74,66 @@
 
 ---
 
-## Visao Geral
-
-Sistema de interface web que recebe texto via WebSocket e gera video sincronizado com audio em tempo real (lip sync). O sistema conecta dois servicos:
-
-- **TTS (Orpheus)**: Gera audio a partir do texto (PCM 24kHz)
-- **Wav2Lip**: Gera frames de video com sincronizacao labial (JPEG 25fps)
-
-## Arquitetura
+## Arquitetura de Streaming Progressivo
 
 ```
 ┌─────────────────┐       ┌──────────────────────┐       ┌─────────────────┐
 │   Frontend      │◄─────►│   Interface Server   │◄─────►│   TTS (Orpheus) │
 │   (Browser)     │  WS   │   (porta 8080)       │  WS   │   (porta 8081)  │
 │                 │       │                      │       │   PCM 24kHz     │
-└─────────────────┘       │                      │       └─────────────────┘
-                          │                      │
-                          │   resample 24k→16k   │       ┌─────────────────┐
-                          │                      │◄─────►│   Wav2Lip       │
-                          │                      │  WS   │   (porta 8082)  │
+│   Renderiza     │       │   MONTA CHUNKS:      │       │   (audio final) │
+│   chunks        │       │   audio Orpheus +    │       └─────────────────┘
+│   conforme      │       │   frames Wav2Lip     │
+│   chegam        │       │                      │       ┌─────────────────┐
+└─────────────────┘       │   DESCARTA audio     │◄─────►│   Wav2Lip       │
+                          │   robotico!          │  WS   │   (porta 8082)  │
                           └──────────────────────┘       │   JPEG 25fps    │
+                                                         │   (so frames!)  │
                                                          └─────────────────┘
 ```
 
-## Fluxo de Dados Sincronizado
+## Fluxo de Streaming Progressivo
 
 ```
 1. Frontend envia: {"action": "generate", "text": "Hello", "voice": "tara"}
    │
    ▼
-2. Interface conecta ao TTS (8081) e Wav2Lip (8082)
+2. Interface conecta ao TTS (8081) e Wav2Lip (8082) EM PARALELO
    │
-   ▼
-3. Interface envia para TTS: {"action": "synthesize", "text": "Hello", "voice": "tara", "stream": true}
+   ├──────────────────────────────────────────────────────────┐
+   │                                                          │
+   ▼                                                          ▼
+3a. Orpheus TTS gera audio                    3b. Wav2Lip gera frames
+    em chunks (~100ms cada)                       baseado em audio interno
+    │                                             (eSpeak robotico - DESCARTAR)
+    │                                             │
+    ▼                                             ▼
+4. Interface Server acumula em buffers:
+   - audio_buffer: chunks do Orpheus
+   - frame_buffer: frames JPEG do Wav2Lip
    │
    ▼
-4. TTS retorna chunks de audio (PCM 24kHz, 16-bit, mono)
+5. Quando tiver dados suficientes (~100ms):
+   a. Pegar audio do Orpheus (ex: 4800 bytes = 100ms)
+   b. Pegar frames do Wav2Lip (ex: 2-3 frames = 80-120ms)
+   c. Montar chunk: [audio_orpheus + frames]
+   d. Enviar para frontend IMEDIATAMENTE
    │
    ▼
-5. Para CADA chunk de audio:
-   a. Resample 24kHz → 16kHz
-   b. Enviar para Wav2Lip: {"action": "process_audio", "audio": "<base64>", "sample_rate": 16000}
-   c. Receber frames correspondentes: {"type": "frame", "frame": "<base64 JPEG>"}
-   d. Mesclar audio + frames em chunk sincronizado
-   e. Enviar para frontend: {"type": "chunk", "data": "<base64>", ...}
+6. Frontend recebe chunk e renderiza:
+   - Decodifica audio e adiciona ao buffer de playback
+   - Decodifica frames JPEG e adiciona a fila de exibicao
+   - Inicia playback assim que tiver ~200ms de dados
    │
    ▼
-6. Ao finalizar TTS, enviar para Wav2Lip: {"action": "end"}
-   │
-   ▼
-7. Enviar para frontend: {"type": "done", "total_frames": N, "total_duration_ms": T}
+7. Repetir ate receber "done" de ambos os servicos
 ```
 
-## Protocolos WebSocket (Real)
+## Protocolos WebSocket
 
 ### TTS Server (porta 8081) - Orpheus
 
-**Arquivo:** `/workspace/orpheus-streaming/streaming_api_server_ws.py`
+**Conexao:** `ws://localhost:8081/ws`
 
 **Requisicao:**
 ```json
@@ -136,7 +166,9 @@ Sistema de interface web que recebe texto via WebSocket e gera video sincronizad
 }
 ```
 
-**Formato do audio:** PCM 24kHz, 16-bit signed, mono, little-endian
+**Formato do audio:** PCM 24kHz, 16-bit signed little-endian, mono
+
+**Vozes:** tara, leo, leah, jess, dan, mia, zac, zoe
 
 ---
 
@@ -144,6 +176,9 @@ Sistema de interface web que recebe texto via WebSocket e gera video sincronizad
 
 **Arquivo:** `/home/marcosavatar/realtimeWav2lip/websocket_server.py`
 
+**IMPORTANTE:** O Wav2Lip usa audio interno (eSpeak) para gerar lip sync.
+Este audio robotico DEVE SER DESCARTADO - usar APENAS os frames JPEG!
+
 **Enviar audio (chunk por chunk):**
 ```json
 {
@@ -153,7 +188,7 @@ Sistema de interface web que recebe texto via WebSocket e gera video sincronizad
 }
 ```
 
-**Resposta (frames):**
+**Resposta (frames) - USAR APENAS OS FRAMES:**
 ```json
 {"type": "frame", "frame": "<base64 JPEG>", "index": 0}
 {"type": "frame", "frame": "<base64 JPEG>", "index": 1}
@@ -179,7 +214,7 @@ Sistema de interface web que recebe texto via WebSocket e gera video sincronizad
 
 ---
 
-### Interface Server (porta 8080) → Frontend
+### Interface Server (porta 8080) - Frontend
 
 **Requisicao do frontend:**
 ```json
@@ -188,9 +223,14 @@ Sistema de interface web que recebe texto via WebSocket e gera video sincronizad
 {"action": "ping"}
 ```
 
-**Respostas para o frontend:**
+**Respostas para o frontend (STREAMING PROGRESSIVO):**
+
+```json
+{"type": "status", "message": "Conectando aos servicos..."}
+```
+
 ```json
-{"type": "status", "message": "Gerando audio e video..."}
+{"type": "stream_start", "ttfb_ms": 150}
 ```
 
 ```json
@@ -200,8 +240,7 @@ Sistema de interface web que recebe texto via WebSocket e gera video sincronizad
   "audio_size": 4800,
   "audio_duration_ms": 100,
   "num_frames": 2,
-  "total_size": 65000,
-  "data": "<base64>"
+  "data": "<base64 do chunk montado>"
 }
 ```
 
@@ -210,7 +249,7 @@ Sistema de interface web que recebe texto via WebSocket e gera video sincronizad
   "type": "done",
   "total_duration_ms": 5000,
   "total_frames": 125,
-  "total_chunks": 10,
+  "total_chunks": 50,
   "elapsed_ms": 3500
 }
 ```
@@ -219,43 +258,83 @@ Sistema de interface web que recebe texto via WebSocket e gera video sincronizad
 {"type": "error", "message": "Descricao do erro"}
 ```
 
-### Formato do Chunk (binario em base64)
+### Formato do Chunk Montado (binario em base64)
 
 ```
 [audio_size: 4 bytes big-endian]
-[audio_data: PCM 24kHz, 16-bit, mono]
+[audio_data: PCM 24kHz do ORPHEUS, 16-bit, mono]
+[num_frames: 4 bytes big-endian]
 [frame_1_size: 4 bytes big-endian]
-[frame_1_data: JPEG bytes]
+[frame_1_data: JPEG bytes do WAV2LIP]
 [frame_2_size: 4 bytes big-endian]
-[frame_2_data: JPEG bytes]
+[frame_2_data: JPEG bytes do WAV2LIP]
 ...
 ```
 
+## Algoritmo de Montagem de Chunks
+
+```python
+CHUNK_DURATION_MS = 100  # Tamanho alvo de cada chunk
+AUDIO_SAMPLE_RATE = 24000  # Orpheus
+VIDEO_FPS = 25  # Wav2Lip
+BYTES_PER_SAMPLE = 2  # 16-bit
+
+# Buffers
+audio_buffer = bytearray()  # Audio do Orpheus
+frame_buffer = []  # Frames do Wav2Lip
+
+async def process_streaming():
+    # Conectar em PARALELO
+    orpheus_task = asyncio.create_task(connect_orpheus())
+    wav2lip_task = asyncio.create_task(connect_wav2lip())
+
+    while not done:
+        # Verificar se tem dados suficientes para montar chunk
+        audio_bytes_needed = int(CHUNK_DURATION_MS * AUDIO_SAMPLE_RATE * BYTES_PER_SAMPLE / 1000)
+        frames_needed = int(CHUNK_DURATION_MS * VIDEO_FPS / 1000)
+
+        if len(audio_buffer) >= audio_bytes_needed and len(frame_buffer) >= frames_needed:
+            # Extrair dados dos buffers
+            audio_chunk = audio_buffer[:audio_bytes_needed]
+            del audio_buffer[:audio_bytes_needed]
+
+            frames_chunk = frame_buffer[:frames_needed]
+            del frame_buffer[:frames_needed]
+
+            # Montar e enviar chunk
+            chunk_data = build_chunk(audio_chunk, frames_chunk)
+            await ws.send_json({
+                "type": "chunk",
+                "chunk_index": chunk_index,
+                "audio_duration_ms": CHUNK_DURATION_MS,
+                "num_frames": len(frames_chunk),
+                "data": base64.b64encode(chunk_data).decode()
+            })
+            chunk_index += 1
+```
+
 ## Sincronizacao Audio/Video
 
 ### Calculos
 
 ```
-TTS: 24000 Hz (24000 samples/segundo)
-Wav2Lip: 16000 Hz (espera 16000 samples/segundo)
+TTS Orpheus: 24000 Hz (24000 samples/segundo)
+Wav2Lip: 16000 Hz (espera 16000 samples/segundo para lip sync)
 Video: 25 fps (1 frame a cada 40ms)
 
-Resample ratio: 16000 / 24000 = 0.666...
-
-Para cada chunk de audio:
-- Duracao (ms) = bytes / 2 / 24000 * 1000
-- Frames esperados = duracao_ms / 40
+Para chunk de 100ms:
+- Audio Orpheus: 100 * 24000 / 1000 * 2 = 4800 bytes
+- Frames Wav2Lip: 100 / 40 = 2.5 ≈ 2-3 frames
 ```
 
-### Exemplo
+### Exemplo de Chunk
 
 ```
-Chunk de audio: 4800 bytes (PCM 24kHz)
-Duracao: 4800 / 2 / 24000 * 1000 = 100ms
-Frames esperados: 100 / 40 = 2.5 ≈ 2-3 frames
+Chunk de 100ms:
+- Audio: 4800 bytes PCM 24kHz do Orpheus (voz de alta qualidade)
+- Frames: 2-3 JPEGs do Wav2Lip (lip sync)
 
-Apos resample para 16kHz:
-Novos bytes: 4800 * (16000/24000) = 3200 bytes
+Total por chunk: ~50-80 KB (depende da compressao JPEG)
 ```
 
 ## Estrutura do Projeto
@@ -263,10 +342,10 @@ Novos bytes: 4800 * (16000/24000) = 3200 bytes
 ```
 /workspace/interface/
 ├── CLAUDE.md           # Esta documentacao
-├── server.py           # Servidor WebSocket (aiohttp)
-├── index.html          # Frontend (HTML + JS)
-├── static/             # Arquivos estaticos
-└── templates/          # Templates HTML
+├── server.py           # Servidor WebSocket com montagem de chunks
+├── index.html          # Frontend com playback progressivo
+├── idle.mp4            # Video de idle loop
+└── static/             # Arquivos estaticos
 ```
 
 ## Configuracao
@@ -276,6 +355,7 @@ Novos bytes: 4800 * (16000/24000) = 3200 bytes
 TTS_WS=ws://localhost:8081/ws
 WAV2LIP_WS=ws://localhost:8082/ws
 PORT=8080
+CHUNK_DURATION_MS=100
 ```
 
 ## Como Executar
@@ -288,11 +368,12 @@ python3 server.py
 **Output esperado:**
 ```
 ==================================================
-Interface Server - WebSocket Streaming
+Interface Server - Streaming Progressivo
 ==================================================
 Porta: 8080
-TTS: ws://localhost:8081/ws (24kHz)
-Wav2Lip: ws://localhost:8082/ws (16kHz)
+TTS (Orpheus): ws://localhost:8081/ws (24kHz)
+Wav2Lip: ws://localhost:8082/ws (16kHz, apenas frames)
+Chunk duration: 100ms
 Video: 25fps (40ms/frame)
 ==================================================
 ```
@@ -309,14 +390,24 @@ Video: 25fps (40ms/frame)
 
 ## Resumo das Portas
 
-| Servico          | Porta | Audio        | Video     |
-|------------------|-------|--------------|-----------|
-| Interface Server | 8080  | -            | -         |
-| TTS (Orpheus)    | 8081  | PCM 24kHz    | -         |
-| Wav2Lip          | 8082  | PCM 16kHz    | JPEG 25fps|
+| Servico          | Porta | Audio        | Video      |
+|------------------|-------|--------------|------------|
+| Interface Server | 8080  | Monta chunks | -          |
+| TTS (Orpheus)    | 8081  | PCM 24kHz    | -          |
+| Wav2Lip          | 8082  | DESCARTAR!   | JPEG 25fps |
 
 ## Dependencias Python
 
 ```
 aiohttp>=3.9.0
 ```
+
+## Notas Importantes
+
+1. **NUNCA usar audio do Wav2Lip no frontend** - O Wav2Lip usa eSpeak internamente para gerar lip sync. Este audio e robotico e deve ser DESCARTADO. Usar APENAS os frames JPEG.
+
+2. **SEMPRE usar audio do Orpheus** - O audio final enviado ao frontend deve vir do Orpheus TTS, que gera voz de alta qualidade.
+
+3. **Streaming progressivo e obrigatorio** - Nao esperar todo o audio/video ficar pronto. Montar e enviar chunks de ~100ms conforme os dados chegam.
+
+4. **Frontend deve iniciar playback cedo** - Assim que receber ~200ms de dados (2 chunks), iniciar reproducao enquanto continua recebendo.

interface/server.py

@@ -1,13 +1,17 @@
 """
-Interface Server - WebSocket Streaming com Wav2Lip
+Interface Server - Streaming Paralelo
 Porta: 8080
 
-Fluxo simplificado:
-1. Frontend conecta via WebSocket e envia texto
-2. Server envia texto para Wav2Lip (action: speak)
-3. Wav2Lip usa eSpeak interno para lip sync + busca audio do Orpheus
-4. Server recebe frames + audio do Wav2Lip
-5. Server muxa em WebM e envia chunks de ~64KB para frontend
+Arquitetura (ver CLAUDE.md):
+1. Recebe texto do frontend via WebSocket
+2. Conecta ao Orpheus (8081) e Wav2Lip (8082) EM PARALELO
+3. Recebe chunks de audio do Orpheus e frames do Wav2Lip
+4. Monta chunks (audio Orpheus + frames Wav2Lip) conforme chegam
+5. Envia chunks IMEDIATAMENTE para o frontend
+
+IMPORTANTE:
+- NAO modificar Wav2Lip - ele gera lip sync com eSpeak interno
+- Audio final = Orpheus (descartar audio do Wav2Lip)
 """
 from aiohttp import web
 import aiohttp
@@ -16,163 +20,216 @@ import json
 import base64
 import os
 import time
-import subprocess
-import tempfile
 import struct
 
-# Configuracao dos servicos
+# Configuracao
+ORPHEUS_WS = os.getenv("ORPHEUS_WS", "ws://localhost:8081/ws")
 WAV2LIP_WS = os.getenv("WAV2LIP_WS", "ws://localhost:8082/ws")
 PORT = int(os.getenv("PORT", "8080"))
 
-# Configuracao de video
-VIDEO_FPS = 25
-CHUNK_TARGET_SIZE = 64 * 1024  # 64KB por chunk
+# Constantes
+AUDIO_SAMPLE_RATE = 24000  # Orpheus
+VIDEO_FPS = 25  # Wav2Lip
+BYTES_PER_SAMPLE = 2  # 16-bit
+MS_PER_FRAME = 1000 / VIDEO_FPS  # 40ms
+AUDIO_BYTES_PER_FRAME = int(MS_PER_FRAME * AUDIO_SAMPLE_RATE * BYTES_PER_SAMPLE / 1000)  # 1920 bytes
 
 routes = web.RouteTableDef()
 
 
-class WebMStreamer:
-    """Gera WebM a partir de frames JPEG e audio PCM usando ffmpeg."""
-
-    def __init__(self):
-        self.temp_dir = None
-        self.frames = []
-        self.audio_data = None
-        self.sample_rate = 24000
-
-    async def start(self):
-        self.temp_dir = tempfile.mkdtemp()
-        self.frames = []
-        self.audio_data = None
-
-    def add_frame(self, jpeg_data: bytes):
-        self.frames.append(jpeg_data)
-
-    def set_audio(self, pcm_data: bytes, sample_rate: int = 24000):
-        self.audio_data = pcm_data
-        self.sample_rate = sample_rate
-
-    async def finalize(self) -> bytes:
-        if not self.frames or not self.audio_data:
-            return b""
-
-        # Salvar frames
-        for i, frame in enumerate(self.frames):
-            frame_path = os.path.join(self.temp_dir, f"frame_{i:05d}.jpg")
-            with open(frame_path, 'wb') as f:
-                f.write(frame)
-
-        # Salvar audio como WAV
-        audio_path = os.path.join(self.temp_dir, "audio.wav")
-        with open(audio_path, 'wb') as f:
-            f.write(b'RIFF')
-            f.write(struct.pack('<I', 36 + len(self.audio_data)))
-            f.write(b'WAVE')
-            f.write(b'fmt ')
-            f.write(struct.pack('<I', 16))
-            f.write(struct.pack('<H', 1))
-            f.write(struct.pack('<H', 1))
-            f.write(struct.pack('<I', self.sample_rate))
-            f.write(struct.pack('<I', self.sample_rate * 2))
-            f.write(struct.pack('<H', 2))
-            f.write(struct.pack('<H', 16))
-            f.write(b'data')
-            f.write(struct.pack('<I', len(self.audio_data)))
-            f.write(self.audio_data)
-
-        output_path = os.path.join(self.temp_dir, "output.webm")
-
-        cmd = [
-            'ffmpeg', '-y',
-            '-framerate', str(VIDEO_FPS),
-            '-i', os.path.join(self.temp_dir, 'frame_%05d.jpg'),
-            '-i', audio_path,
-            '-c:v', 'libvpx-vp9',
-            '-b:v', '1M',
-            '-c:a', 'libopus',
-            '-b:a', '128k',
-            '-shortest',
-            output_path
-        ]
-
-        try:
-            proc = await asyncio.create_subprocess_exec(
-                *cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            stdout, stderr = await proc.communicate()
-
-            if proc.returncode != 0:
-                print(f"FFmpeg error: {stderr.decode()[-500:]}")
-                return b""
-
-            with open(output_path, 'rb') as f:
-                return f.read()
-
-        except Exception as e:
-            print(f"Error creating WebM: {e}")
-            return b""
-
-    async def cleanup(self):
-        if self.temp_dir:
-            import shutil
-            try:
-                shutil.rmtree(self.temp_dir)
-            except:
-                pass
+def build_chunk(audio_bytes: bytes, frames: list) -> bytes:
+    """Monta chunk binario: [audio_size][audio][num_frames][frame_sizes][frames]"""
+    data = bytearray()
+    data.extend(struct.pack('>I', len(audio_bytes)))
+    data.extend(audio_bytes)
+    data.extend(struct.pack('>I', len(frames)))
+    for frame in frames:
+        data.extend(struct.pack('>I', len(frame)))
+        data.extend(frame)
+    return bytes(data)
 
 
-class StreamingSession:
-    """Gerencia uma sessao de streaming."""
+class ParallelStreamingSession:
+    """Streaming paralelo: Orpheus (audio) + Wav2Lip (frames)"""
 
     def __init__(self, client_ws):
         self.client_ws = client_ws
         self.is_running = False
         self.start_time = None
+
+        # Buffers compartilhados
+        self.audio_buffer = bytearray()
+        self.frame_buffer = []
+
+        # Locks para acesso thread-safe
+        self.buffer_lock = asyncio.Lock()
+
+        # Estados
+        self.orpheus_done = False
+        self.wav2lip_done = False
+        self.first_chunk_sent = False
+        self.chunk_index = 0
+
+        # Estatisticas
+        self.total_audio_bytes = 0
         self.total_frames = 0
         self.chunks_sent = 0
 
-    async def send_to_client(self, msg_type: str, **kwargs):
+    async def send_status(self, message: str):
+        """Envia status para o cliente."""
         try:
-            await self.client_ws.send_json({"type": msg_type, **kwargs})
-        except Exception as e:
-            print(f"Erro enviando para cliente: {e}")
-
-    async def run(self, text: str, voice: str):
-        """Executa a sessao usando Wav2Lip com action: speak."""
-        self.is_running = True
-        self.start_time = time.time()
-
-        await self.send_to_client("status", message="Conectando ao Wav2Lip...")
+            if not self.client_ws.closed:
+                await self.client_ws.send_json({"type": "status", "message": message})
+        except:
+            pass
+
+    async def send_chunk(self, audio: bytes, frames: list):
+        """Monta e envia chunk para o cliente."""
+        if self.client_ws.closed or not audio or not frames:
+            return
 
-        frames = []
-        audio_data = None
-        audio_sample_rate = 24000
+        try:
+            chunk_data = build_chunk(audio, frames)
+            chunk_b64 = base64.b64encode(chunk_data).decode()
+            audio_ms = len(audio) / BYTES_PER_SAMPLE / AUDIO_SAMPLE_RATE * 1000
+
+            await self.client_ws.send_json({
+                "type": "chunk",
+                "chunk_index": self.chunk_index,
+                "audio_size": len(audio),
+                "audio_duration_ms": int(audio_ms),
+                "num_frames": len(frames),
+                "data": chunk_b64
+            })
+
+            self.chunk_index += 1
+            self.chunks_sent += 1
+
+            if not self.first_chunk_sent:
+                self.first_chunk_sent = True
+                ttfb = int((time.time() - self.start_time) * 1000)
+                print(f"[Stream] Primeiro chunk: TTFB={ttfb}ms")
+                await self.client_ws.send_json({"type": "stream_start", "ttfb_ms": ttfb})
 
+        except Exception as e:
+            print(f"[Stream] Erro enviando chunk: {e}")
+
+    async def try_send_chunks(self):
+        """Tenta montar e enviar chunks com dados disponiveis."""
+        async with self.buffer_lock:
+            # Enquanto tiver 1 frame + audio correspondente
+            while len(self.frame_buffer) > 0 and len(self.audio_buffer) >= AUDIO_BYTES_PER_FRAME:
+                # Pega 1 frame
+                frame = self.frame_buffer.pop(0)
+
+                # Pega audio correspondente (~40ms = 1920 bytes)
+                audio = bytes(self.audio_buffer[:AUDIO_BYTES_PER_FRAME])
+                del self.audio_buffer[:AUDIO_BYTES_PER_FRAME]
+
+                await self.send_chunk(audio, [frame])
+
+            # Se ambos terminaram, enviar o que sobrou
+            if self.orpheus_done and self.wav2lip_done:
+                if self.frame_buffer and self.audio_buffer:
+                    # Dividir audio restante pelos frames restantes
+                    audio_per_frame = len(self.audio_buffer) // len(self.frame_buffer) if self.frame_buffer else 0
+                    audio_per_frame = max(audio_per_frame, 2)  # Minimo 2 bytes
+                    audio_per_frame = audio_per_frame - (audio_per_frame % 2)  # Alinhamento 16-bit
+
+                    while self.frame_buffer and self.audio_buffer:
+                        frame = self.frame_buffer.pop(0)
+                        audio_size = min(audio_per_frame, len(self.audio_buffer))
+                        if not self.frame_buffer:  # Ultimo frame pega todo o resto
+                            audio_size = len(self.audio_buffer)
+                        audio = bytes(self.audio_buffer[:audio_size])
+                        del self.audio_buffer[:audio_size]
+                        await self.send_chunk(audio, [frame])
+
+                elif self.frame_buffer:
+                    # Frames sem audio - enviar com audio vazio
+                    for frame in self.frame_buffer:
+                        await self.send_chunk(b'', [frame])
+                    self.frame_buffer.clear()
+
+    async def stream_orpheus(self, text: str, voice: str):
+        """Conecta ao Orpheus e recebe chunks de audio."""
         try:
+            print(f"[Orpheus] Conectando a {ORPHEUS_WS}...")
             async with aiohttp.ClientSession() as session:
-                wav2lip_ws = await session.ws_connect(
-                    WAV2LIP_WS,
-                    timeout=aiohttp.ClientWSTimeout(ws_close=120)
-                )
-
-                await self.send_to_client("status", message="Gerando avatar...")
+                ws = await session.ws_connect(ORPHEUS_WS, timeout=aiohttp.ClientWSTimeout(ws_close=120))
 
-                # Enviar texto para Wav2Lip (action: speak usa eSpeak + Orpheus interno)
-                await wav2lip_ws.send_json({
-                    "action": "speak",
+                # Enviar requisicao
+                await ws.send_json({
+                    "action": "synthesize",
                     "text": text,
                     "voice": voice,
-                    "parallel": True
+                    "stream": True
                 })
+                print(f"[Orpheus] Requisicao enviada")
+
+                async for msg in ws:
+                    if not self.is_running:
+                        break
+
+                    if msg.type == aiohttp.WSMsgType.TEXT:
+                        data = json.loads(msg.data)
+                        msg_type = data.get("type", "")
+
+                        if msg_type == "audio_chunk":
+                            # Decodificar e adicionar ao buffer
+                            audio_b64 = data.get("audio", "")
+                            audio_bytes = base64.b64decode(audio_b64)
+
+                            async with self.buffer_lock:
+                                self.audio_buffer.extend(audio_bytes)
+                                self.total_audio_bytes += len(audio_bytes)
+
+                            # Tentar enviar chunks
+                            await self.try_send_chunks()
+
+                            chunk_idx = data.get("chunk_index", 0)
+                            if chunk_idx == 1:
+                                print(f"[Orpheus] Primeiro chunk de audio recebido")
+
+                        elif msg_type == "done":
+                            total = data.get("total_bytes", 0)
+                            print(f"[Orpheus] Concluido: {total} bytes")
+                            break
+
+                        elif msg_type == "error":
+                            print(f"[Orpheus] Erro: {data.get('message')}")
+                            break
 
-                print(f"[Wav2Lip] Enviado texto: '{text[:50]}...'")
+                    elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                        break
+
+                await ws.close()
+
+        except Exception as e:
+            print(f"[Orpheus] Erro: {e}")
+            import traceback
+            traceback.print_exc()
+
+        finally:
+            self.orpheus_done = True
+            await self.try_send_chunks()
+
+    async def stream_wav2lip(self, text: str, voice: str):
+        """Conecta ao Wav2Lip e recebe frames."""
+        try:
+            print(f"[Wav2Lip] Conectando a {WAV2LIP_WS}...")
+            async with aiohttp.ClientSession() as session:
+                ws = await session.ws_connect(WAV2LIP_WS, timeout=aiohttp.ClientWSTimeout(ws_close=120))
 
-                first_frame_time = None
+                # Enviar requisicao
+                await ws.send_json({
+                    "action": "generate",
+                    "text": text,
+                    "voice": voice
+                })
+                print(f"[Wav2Lip] Requisicao enviada")
 
-                # Receber frames e audio do Wav2Lip
-                async for msg in wav2lip_ws:
+                async for msg in ws:
                     if not self.is_running:
                         break
 
@@ -180,105 +237,92 @@ class StreamingSession:
                         data = json.loads(msg.data)
                         msg_type = data.get("type", "")
 
-                        if msg_type == "first_chunk":
-                            latency = data.get("latency_ms", 0)
-                            print(f"[Wav2Lip] First chunk: {latency}ms")
-                            await self.send_to_client("status", message="Processando frames...")
-
-                        elif msg_type == "frame":
+                        if msg_type == "frame":
+                            # Decodificar e adicionar ao buffer
                             frame_b64 = data.get("frame", "")
                             frame_bytes = base64.b64decode(frame_b64)
-                            frames.append(frame_bytes)
-                            self.total_frames += 1
 
-                            if first_frame_time is None:
-                                first_frame_time = time.time() - self.start_time
-                                print(f"[Wav2Lip] Primeiro frame em {first_frame_time*1000:.0f}ms")
-                                await self.send_to_client("first_frame", latency_ms=int(first_frame_time*1000))
+                            async with self.buffer_lock:
+                                self.frame_buffer.append(frame_bytes)
+                                self.total_frames += 1
+
+                            # Tentar enviar chunks
+                            await self.try_send_chunks()
+
+                            frame_idx = data.get("index", 0)
+                            if frame_idx == 0:
+                                print(f"[Wav2Lip] Primeiro frame recebido")
+
+                        elif msg_type == "status":
+                            print(f"[Wav2Lip] {data.get('message')}")
+
+                        elif msg_type == "first_chunk":
+                            print(f"[Wav2Lip] eSpeak latency: {data.get('latency_ms')}ms")
 
                         elif msg_type == "full_audio":
-                            audio_b64 = data.get("audio", "")
-                            audio_wav = base64.b64decode(audio_b64)
-                            # Extrair PCM do WAV (pular header de 44 bytes)
-                            if len(audio_wav) > 44 and audio_wav[:4] == b'RIFF':
-                                audio_data = audio_wav[44:]
-                            else:
-                                audio_data = audio_wav
-                            audio_sample_rate = 24000
-                            duration = data.get("duration_ms", 0)
-                            print(f"[Wav2Lip] Audio recebido: {len(audio_data)} bytes, {duration}ms")
+                            # Ignorar - usamos audio do Orpheus
+                            print(f"[Wav2Lip] Audio ignorado (usando Orpheus)")
 
                         elif msg_type == "done":
-                            print(f"[Wav2Lip] Concluido: {data.get('frames', 0)} frames")
+                            frames = data.get("frames", 0)
+                            print(f"[Wav2Lip] Concluido: {frames} frames")
                             break
 
-                        elif msg_type == "status":
-                            print(f"[Wav2Lip] Status: {data.get('message')}")
-
                         elif msg_type == "error":
-                            error_msg = data.get("message", "Erro")
-                            print(f"[Wav2Lip] Erro: {error_msg}")
-                            await self.send_to_client("error", message=error_msg)
+                            print(f"[Wav2Lip] Erro: {data.get('message')}")
+                            await self.send_status(f"Erro: {data.get('message')}")
                             break
 
                     elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
                         break
 
-                await wav2lip_ws.close()
+                await ws.close()
 
         except Exception as e:
-            print(f"Erro na sessao: {e}")
+            print(f"[Wav2Lip] Erro: {e}")
             import traceback
             traceback.print_exc()
-            await self.send_to_client("error", message=str(e))
-            return
 
-        if not frames:
-            await self.send_to_client("error", message="Nenhum frame recebido")
-            return
+        finally:
+            self.wav2lip_done = True
+            await self.try_send_chunks()
 
-        if not audio_data:
-            await self.send_to_client("error", message="Nenhum audio recebido")
-            return
+    async def run(self, text: str, voice: str):
+        """Executa streaming paralelo."""
+        self.is_running = True
+        self.start_time = time.time()
 
-        # Gerar WebM
-        await self.send_to_client("status", message="Gerando video...")
+        await self.send_status("Conectando aos servicos...")
 
-        webm = WebMStreamer()
-        await webm.start()
+        try:
+            # Conectar Orpheus e Wav2Lip EM PARALELO
+            orpheus_task = asyncio.create_task(self.stream_orpheus(text, voice))
+            wav2lip_task = asyncio.create_task(self.stream_wav2lip(text, voice))
 
-        for frame in frames:
-            webm.add_frame(frame)
-        webm.set_audio(audio_data, audio_sample_rate)
+            # Aguardar ambos terminarem
+            await asyncio.gather(orpheus_task, wav2lip_task)
 
-        webm_data = await webm.finalize()
-        await webm.cleanup()
+            # Enviar chunks restantes
+            await self.try_send_chunks()
 
-        if webm_data:
-            self.chunks_sent = 1
-            await self.send_to_client(
-                "webm_chunk",
-                chunk_index=1,
-                size=len(webm_data),
-                data=base64.b64encode(webm_data).decode()
-            )
-            print(f"[WebM] Enviado: {len(webm_data)} bytes, {len(frames)} frames")
+        except Exception as e:
+            print(f"[Stream] Erro: {e}")
+            await self.client_ws.send_json({"type": "error", "message": str(e)})
+            return
 
-        # Metricas finais
         elapsed = time.time() - self.start_time
-        audio_duration_ms = len(audio_data) / 2 / audio_sample_rate * 1000
-
-        print(f"Sessao concluida em {elapsed:.2f}s")
-        print(f"  Frames: {self.total_frames}")
-        print(f"  Audio: {audio_duration_ms:.0f}ms")
+        print(f"[Stream] Concluido: {elapsed:.2f}s, {self.chunks_sent} chunks, {self.total_frames} frames, {self.total_audio_bytes} bytes")
 
-        await self.send_to_client(
-            "done",
-            total_duration_ms=int(audio_duration_ms),
-            total_frames=self.total_frames,
-            total_chunks=self.chunks_sent,
-            elapsed_ms=int(elapsed * 1000)
-        )
+        try:
+            await self.client_ws.send_json({
+                "type": "done",
+                "total_chunks": self.chunks_sent,
+                "total_frames": self.total_frames,
+                "total_audio_bytes": self.total_audio_bytes,
+                "elapsed_ms": int(elapsed * 1000)
+            })
+        except:
+            pass
 
     def stop(self):
         self.is_running = False
@@ -289,7 +333,7 @@ async def websocket_handler(request):
     ws = web.WebSocketResponse()
     await ws.prepare(request)
 
-    print("Cliente WebSocket conectado")
+    print("Cliente conectado")
     session = None
 
     try:
@@ -304,7 +348,7 @@ async def websocket_handler(request):
                         voice = data.get("voice", "tara")
 
                         if not text:
-                            await ws.send_json({"type": "error", "message": "Text is required"})
+                            await ws.send_json({"type": "error", "message": "Text required"})
                             continue
 
                         print(f"Gerando: '{text[:50]}...' voice={voice}")
@@ -312,7 +356,7 @@ async def websocket_handler(request):
                         if session:
                             session.stop()
 
-                        session = StreamingSession(ws)
+                        session = ParallelStreamingSession(ws)
                         await session.run(text, voice)
 
                     elif action == "stop":
@@ -331,11 +375,11 @@ async def websocket_handler(request):
                 break
 
     except Exception as e:
-        print(f"Erro no WebSocket: {e}")
+        print(f"Erro: {e}")
     finally:
         if session:
             session.stop()
-        print("Cliente WebSocket desconectado")
+        print("Cliente desconectado")
 
     return ws
 
@@ -345,18 +389,23 @@ async def index(request):
     return web.FileResponse(os.path.join(os.path.dirname(__file__), "index.html"))
 
 
-@routes.get("/health")
-async def health(request):
-    status = {"server": True, "wav2lip": False}
+@routes.get("/idle.mp4")
+async def idle_video(request):
+    return web.FileResponse(os.path.join(os.path.dirname(__file__), "idle.mp4"))
+
+
+@routes.get("/{filename}")
+async def static_file(request):
+    filename = request.match_info["filename"]
+    filepath = os.path.join(os.path.dirname(__file__), filename)
+    if os.path.exists(filepath):
+        return web.FileResponse(filepath)
+    return web.Response(status=404)
 
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.ws_connect(WAV2LIP_WS, timeout=aiohttp.ClientWSTimeout(ws_close=2)) as ws:
-                status["wav2lip"] = True
-    except:
-        pass
 
-    return web.json_response(status)
+@routes.get("/health")
+async def health(request):
+    return web.json_response({"status": "ok", "mode": "parallel_streaming"})
 
 
 app = web.Application()
@@ -365,11 +414,12 @@ app.add_routes(routes)
 
 if __name__ == "__main__":
     print("=" * 50)
-    print("Interface Server - Wav2Lip Streaming")
+    print("Interface Server - Streaming Paralelo")
     print("=" * 50)
     print(f"Porta: {PORT}")
+    print(f"Orpheus: {ORPHEUS_WS}")
     print(f"Wav2Lip: {WAV2LIP_WS}")
-    print(f"Video: {VIDEO_FPS}fps")
-    print(f"Output: WebM (VP9 + Opus)")
+    print(f"Audio: {AUDIO_SAMPLE_RATE}Hz, {AUDIO_BYTES_PER_FRAME} bytes/frame")
+    print(f"Video: {VIDEO_FPS}fps, {MS_PER_FRAME}ms/frame")
     print("=" * 50)
     web.run_app(app, host="0.0.0.0", port=PORT)

interface/test_streaming.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+Test client para streaming progressivo.
+Conecta via WebSocket, recebe chunks, monta e salva vídeo.
+"""
+import asyncio
+import aiohttp
+import json
+import base64
+import struct
+import os
+import sys
+import wave
+import subprocess
+import tempfile
+import time
+
+# Configuracao
+WS_URL = os.getenv("WS_URL", "ws://localhost:8090/ws")
+TEXT = os.getenv("TEXT", "Hello! I am testing the progressive streaming avatar system.")
+VOICE = os.getenv("VOICE", "tara")
+OUTPUT_DIR = "/tmp/streaming_test"
+
+async def test_streaming():
+    print("=" * 60)
+    print("Test Streaming Client")
+    print("=" * 60)
+    print(f"WebSocket: {WS_URL}")
+    print(f"Text: {TEXT[:50]}...")
+    print(f"Voice: {VOICE}")
+    print(f"Output: {OUTPUT_DIR}")
+    print("=" * 60)
+
+    # Criar diretorio de saida
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # Buffers para acumular dados
+    all_audio = bytearray()
+    all_frames = []
+    chunks_received = 0
+    start_time = None
+    first_chunk_time = None
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            print("\nConectando ao WebSocket...")
+            ws = await session.ws_connect(WS_URL, timeout=aiohttp.ClientWSTimeout(ws_close=120))
+            print("Conectado!")
+
+            # Enviar requisicao
+            print(f"\nEnviando requisicao...")
+            await ws.send_json({
+                "action": "generate",
+                "text": TEXT,
+                "voice": VOICE
+            })
+            start_time = time.time()
+
+            # Receber mensagens
+            async for msg in ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    data = json.loads(msg.data)
+                    msg_type = data.get("type", "")
+
+                    if msg_type == "status":
+                        print(f"  Status: {data.get('message')}")
+
+                    elif msg_type == "stream_start":
+                        ttfb = data.get("ttfb_ms", 0)
+                        first_chunk_time = time.time()
+                        print(f"  Stream iniciado! TTFB: {ttfb}ms")
+
+                    elif msg_type == "chunk":
+                        chunks_received += 1
+                        chunk_index = data.get("chunk_index", 0)
+                        audio_size = data.get("audio_size", 0)
+                        num_frames = data.get("num_frames", 0)
+
+                        # Decodificar chunk
+                        chunk_data = base64.b64decode(data.get("data", ""))
+                        view = memoryview(chunk_data)
+                        offset = 0
+
+                        # Ler audio
+                        audio_len = struct.unpack(">I", view[offset:offset+4])[0]
+                        offset += 4
+                        audio_bytes = bytes(view[offset:offset+audio_len])
+                        offset += audio_len
+                        all_audio.extend(audio_bytes)
+
+                        # Ler frames
+                        frames_count = struct.unpack(">I", view[offset:offset+4])[0]
+                        offset += 4
+                        for i in range(frames_count):
+                            frame_len = struct.unpack(">I", view[offset:offset+4])[0]
+                            offset += 4
+                            frame_bytes = bytes(view[offset:offset+frame_len])
+                            offset += frame_len
+                            all_frames.append(frame_bytes)
+
+                        print(f"  Chunk {chunk_index}: {audio_size} bytes audio, {num_frames} frames (total: {len(all_frames)} frames, {len(all_audio)} bytes audio)")
+
+                    elif msg_type == "done":
+                        total_chunks = data.get("total_chunks", 0)
+                        total_frames = data.get("total_frames", 0)
+                        elapsed_ms = data.get("elapsed_ms", 0)
+                        print(f"\n  Done! {total_chunks} chunks, {total_frames} frames, {elapsed_ms}ms")
+                        break
+
+                    elif msg_type == "error":
+                        print(f"  ERRO: {data.get('message')}")
+                        break
+
+                elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                    print("  WebSocket fechado")
+                    break
+
+            await ws.close()
+
+    except Exception as e:
+        print(f"Erro: {e}")
+        import traceback
+        traceback.print_exc()
+        return
+
+    total_time = time.time() - start_time if start_time else 0
+
+    print("\n" + "=" * 60)
+    print("Resultados:")
+    print("=" * 60)
+    print(f"Chunks recebidos: {chunks_received}")
+    print(f"Frames recebidos: {len(all_frames)}")
+    print(f"Audio recebido: {len(all_audio)} bytes")
+    print(f"Tempo total: {total_time:.2f}s")
+
+    if not all_frames or not all_audio:
+        print("\nNenhum dado recebido!")
+        return
+
+    # Salvar frames como JPEGs
+    print(f"\nSalvando {len(all_frames)} frames...")
+    frames_dir = os.path.join(OUTPUT_DIR, "frames")
+    os.makedirs(frames_dir, exist_ok=True)
+    for i, frame in enumerate(all_frames):
+        frame_path = os.path.join(frames_dir, f"frame_{i:05d}.jpg")
+        with open(frame_path, "wb") as f:
+            f.write(frame)
+
+    # Salvar audio como WAV
+    print(f"Salvando audio ({len(all_audio)} bytes)...")
+    audio_path = os.path.join(OUTPUT_DIR, "audio.wav")
+
+    # Detectar sample rate pelo tamanho do audio e frames
+    # 25 fps, cada frame = 40ms
+    # audio_duration = len(all_frames) * 40ms
+    audio_duration_ms = len(all_frames) * 40
+    samples = len(all_audio) // 2  # 16-bit = 2 bytes por sample
+    if audio_duration_ms > 0:
+        estimated_sample_rate = int(samples / (audio_duration_ms / 1000))
+        # Arredondar para sample rates comuns
+        if estimated_sample_rate > 20000:
+            sample_rate = 24000
+        else:
+            sample_rate = 22050
+    else:
+        sample_rate = 24000
+
+    print(f"Sample rate estimado: {sample_rate} Hz")
+
+    with wave.open(audio_path, "wb") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)  # 16-bit
+        wf.setframerate(sample_rate)
+        wf.writeframes(all_audio)
+
+    # Criar video com ffmpeg
+    print("\nCriando video com ffmpeg...")
+    video_path = os.path.join(OUTPUT_DIR, "output.mp4")
+
+    # Calcular fps para sincronizar com audio
+    audio_duration_s = len(all_audio) / 2 / sample_rate
+    if audio_duration_s > 0:
+        video_fps = len(all_frames) / audio_duration_s
+    else:
+        video_fps = 25
+
+    print(f"Video FPS: {video_fps:.2f}")
+
+    cmd = [
+        "ffmpeg", "-y",
+        "-framerate", str(video_fps),
+        "-i", os.path.join(frames_dir, "frame_%05d.jpg"),
+        "-i", audio_path,
+        "-vf", "pad=ceil(iw/2)*2:ceil(ih/2)*2",  # Fix odd dimensions for libx264
+        "-c:v", "libx264",
+        "-preset", "fast",
+        "-crf", "23",
+        "-c:a", "aac",
+        "-b:a", "128k",
+        "-pix_fmt", "yuv420p",
+        "-shortest",
+        video_path
+    ]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"FFmpeg erro: {result.stderr[-500:]}")
+    else:
+        print(f"\nVideo salvo em: {video_path}")
+        # Mostrar info do video
+        probe = subprocess.run(
+            ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", video_path],
+            capture_output=True, text=True
+        )
+        if probe.returncode == 0:
+            import json as json_mod
+            info = json_mod.loads(probe.stdout)
+            duration = float(info.get("format", {}).get("duration", 0))
+            size = int(info.get("format", {}).get("size", 0))
+            print(f"Duracao: {duration:.2f}s")
+            print(f"Tamanho: {size / 1024:.1f} KB")
+
+    print("\n" + "=" * 60)
+    print("Arquivos gerados:")
+    print("=" * 60)
+    print(f"  Frames: {frames_dir}/")
+    print(f"  Audio:  {audio_path}")
+    print(f"  Video:  {video_path}")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_streaming())