Integrate AvatarAPI: prepare for direct Python calls replacing WebSocket

- Add AvatarAPI import from video/avatar_api.py
- Add configuration for AVATAR_VIDEO, WAV2LIP_CHECKPOINT, TTS_URL
- Add global avatar_api instance variable
- Maintain 480p resolution (854x480) and 48kHz audio from previous fixes

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

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

interface/server.py

@@ -16,6 +16,7 @@ import asyncio
 import json
 import base64
 import os
+import sys
 import time
 import uuid
 import fractions
@@ -26,15 +27,34 @@ from aiortc.contrib.media import MediaRelay
 import cv2
 import subprocess
 import tempfile
+from scipy import signal
+
+# Add path to video directory for avatar_api import
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'video'))
+
+# Import AvatarAPI
+try:
+    from avatar_api import AvatarAPI
+    AVATAR_API_AVAILABLE = True
+    print("[Import] AvatarAPI imported successfully")
+except ImportError as e:
+    AVATAR_API_AVAILABLE = False
+    print(f"[Import] WARNING: Could not import AvatarAPI: {e}")
+    print("[Import] Falling back to WebSocket mode")
 
 # Configuracao
-WAV2LIP_WS = os.getenv("WAV2LIP_WS", "ws://localhost:8082/ws")
 PORT = int(os.getenv("PORT", "8080"))
 IDLE_VIDEO = os.path.join(os.path.dirname(__file__), "idle.mp4")
+AVATAR_VIDEO = os.path.join(os.path.dirname(__file__), '..', 'video', 'avatar_parado.mp4')
+WAV2LIP_CHECKPOINT = os.path.join(os.path.dirname(__file__), '..', 'video', 'checkpoints', 'wav2lip_gan.pth')
+TTS_URL = os.getenv("TTS_URL", "http://localhost:8081")
 
 # Constantes
 VIDEO_FPS = 25
-AUDIO_SAMPLE_RATE = 24000
+VIDEO_WIDTH = 854  # 480p
+VIDEO_HEIGHT = 480
+AUDIO_SAMPLE_RATE = 48000  # 48kHz é a frequência nativa do Opus WebRTC
+ORPHEUS_SAMPLE_RATE = 24000  # Orpheus gera a 24kHz
 VIDEO_TIME_BASE = fractions.Fraction(1, VIDEO_FPS)
 AUDIO_TIME_BASE = fractions.Fraction(1, AUDIO_SAMPLE_RATE)
 
@@ -42,6 +62,7 @@ AUDIO_TIME_BASE = fractions.Fraction(1, AUDIO_SAMPLE_RATE)
 idle_frames_cache = []
 pcs = set()  # Track peer connections
 relay = MediaRelay()
+avatar_api = None  # Global AvatarAPI instance
 
 routes = web.RouteTableDef()
 
@@ -156,7 +177,7 @@ def trim_high_motion_frames(frames, threshold_multiplier=1.0, max_trim=20):
 
 
 def load_idle_frames():
-    """Carrega frames do idle.mp4 como arrays numpy."""
+    """Carrega frames do idle.mp4 como arrays numpy, redimensionados para 480p."""
     global idle_frames_cache
 
     if idle_frames_cache:
@@ -169,16 +190,29 @@ def load_idle_frames():
     print(f"[Idle] Carregando frames de {IDLE_VIDEO}...")
 
     cap = cv2.VideoCapture(IDLE_VIDEO)
+
+    # Detectar resolução original
+    original_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    original_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    print(f"[Idle] Resolucao original: {original_width}x{original_height}")
+    print(f"[Idle] Redimensionando para: {VIDEO_WIDTH}x{VIDEO_HEIGHT} (480p)")
+
     while True:
         ret, frame = cap.read()
         if not ret:
             break
         # Converter BGR para RGB
         frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+        # Redimensionar para 480p se necessario
+        if original_width != VIDEO_WIDTH or original_height != VIDEO_HEIGHT:
+            frame_rgb = cv2.resize(frame_rgb, (VIDEO_WIDTH, VIDEO_HEIGHT),
+                                  interpolation=cv2.INTER_LANCZOS4)
+
         idle_frames_cache.append(frame_rgb)
     cap.release()
 
-    print(f"[Idle] Carregados {len(idle_frames_cache)} frames")
+    print(f"[Idle] Carregados {len(idle_frames_cache)} frames @ {VIDEO_WIDTH}x{VIDEO_HEIGHT}")
     return idle_frames_cache
 
 
@@ -202,13 +236,11 @@ class AvatarVideoTrack(MediaStreamTrack):
         self.speaking_idx = 0
         self.best_idle_idx = None  # Frame idle para transicao suave
 
-        # Dimensoes do video
-        if self.idle_frames:
-            self.height, self.width = self.idle_frames[0].shape[:2]
-        else:
-            self.width, self.height = 640, 480
+        # Dimensoes do video (480p fixo)
+        self.width = VIDEO_WIDTH
+        self.height = VIDEO_HEIGHT
 
-        print(f"[VideoTrack] Inicializado: {self.width}x{self.height} @ {VIDEO_FPS}fps")
+        print(f"[VideoTrack] Inicializado: {self.width}x{self.height} @ {VIDEO_FPS}fps (480p fixo)")
 
     async def recv(self):
         """Retorna o proximo frame de video."""
@@ -288,7 +320,7 @@ class AvatarAudioTrack(MediaStreamTrack):
     def __init__(self):
         super().__init__()
         self.sample_rate = AUDIO_SAMPLE_RATE
-        self.samples_per_frame = 960  # 40ms @ 24kHz
+        self.samples_per_frame = 1920  # 40ms @ 48kHz (era 960 @ 24kHz)
         self.frame_count = 0
         self.start_time = None
 
@@ -296,7 +328,7 @@ class AvatarAudioTrack(MediaStreamTrack):
         self.audio_buffer = []
         self.buffer_idx = 0
 
-        print(f"[AudioTrack] Inicializado: {self.sample_rate}Hz")
+        print(f"[AudioTrack] Inicializado: {self.sample_rate}Hz, {self.samples_per_frame} samples/frame (40ms)")
 
     async def recv(self):
         """Retorna o proximo frame de audio."""
@@ -336,7 +368,17 @@ class AvatarAudioTrack(MediaStreamTrack):
         # Converter bytes para numpy array
         samples = np.frombuffer(pcm_data, dtype=np.int16)
 
-        # Dividir em frames de 40ms
+        print(f"[AudioTrack] Recebido: {len(samples)} samples @ {ORPHEUS_SAMPLE_RATE}Hz")
+
+        # RESAMPLE: Orpheus gera 24kHz, mas Opus WebRTC funciona melhor em 48kHz (nativo)
+        # Upsample 24kHz -> 48kHz (2x) usando scipy high-quality resampling
+        if ORPHEUS_SAMPLE_RATE != AUDIO_SAMPLE_RATE:
+            num_samples_48k = int(len(samples) * AUDIO_SAMPLE_RATE / ORPHEUS_SAMPLE_RATE)
+            samples_48k = signal.resample(samples, num_samples_48k).astype(np.int16)
+            print(f"[AudioTrack] Upsampled: {len(samples_48k)} samples @ {AUDIO_SAMPLE_RATE}Hz (scipy high-quality)")
+            samples = samples_48k
+
+        # Dividir em frames de 40ms (1920 samples @ 48kHz)
         self.audio_buffer = []
         for i in range(0, len(samples), self.samples_per_frame):
             chunk = samples[i:i + self.samples_per_frame]
@@ -346,7 +388,7 @@ class AvatarAudioTrack(MediaStreamTrack):
             self.audio_buffer.append(chunk)
 
         self.buffer_idx = 0
-        print(f"[AudioTrack] Audio: {len(self.audio_buffer)} frames ({len(pcm_data)} bytes)")
+        print(f"[AudioTrack] Buffer: {len(self.audio_buffer)} frames x {self.samples_per_frame} samples (40ms cada)")
 
 
 class AvatarSession: