Update app.py

app.py

@@ -15,6 +15,7 @@ import tempfile
 import os
 import shutil
 import json
+import random
 
 # ======================= DATACLASSES =======================
 
@@ -42,29 +43,23 @@ class FaceBox:
 # ======================= UTILS =======================
 
 def resolve_video_path(v: Union[str, dict, None]) -> Optional[str]:
-    """Gradio às vezes entrega str (caminho) ou dict {'name':..., 'data':...}. Normaliza para caminho."""
+    """Gradio pode entregar str (caminho) ou dict. Normaliza para caminho local."""
     if v is None:
         return None
     if isinstance(v, str):
         return v
     if isinstance(v, dict):
-        # Prioriza caminho local temporário
-        if "name" in v and isinstance(v["name"], str) and len(v["name"]) > 0 and os.path.exists(v["name"]):
+        if "name" in v and isinstance(v["name"], str) and os.path.exists(v["name"]):
             return v["name"]
-        # Algumas versões usam 'path'
         if "path" in v and isinstance(v["path"], str) and os.path.exists(v["path"]):
             return v["path"]
-        # Fallback: alguns frontends mandam apenas nome base; não há como resolver sem arquivo
         return v.get("name") or v.get("path")
     return None
 
 def probe_duration(path: str) -> Optional[float]:
-    """Retorna a duração (segundos) via ffprobe, ou None se falhar."""
+    """Retorna a duração (s) via ffprobe."""
     try:
-        cmd = [
-            "ffprobe", "-v", "error", "-show_entries", "format=duration",
-            "-of", "json", path
-        ]
+        cmd = ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "json", path]
         out = subprocess.run(cmd, check=True, capture_output=True)
         data = json.loads(out.stdout.decode("utf-8", errors="ignore"))
         dur = float(data.get("format", {}).get("duration", 0.0))
@@ -73,6 +68,21 @@ def probe_duration(path: str) -> Optional[float]:
         print(f"[ffprobe] falhou: {e}")
         return None
 
+def remux_video(src: str) -> str:
+    """Gera um MP4 remuxado (ajusta PTS/timebase e faststart)."""
+    fd, tmp_path = tempfile.mkstemp(suffix=".mp4")
+    os.close(fd)
+    cmd = [
+        "ffmpeg", "-y",
+        "-fflags", "+genpts",
+        "-i", src,
+        "-c", "copy",
+        "-movflags", "+faststart",
+        tmp_path
+    ]
+    subprocess.run(cmd, check=True, capture_output=True)
+    return tmp_path
+
 # ======================= FACE TRACKING =======================
 
 class FaceTracker:
@@ -176,42 +186,82 @@ class FaceTracker:
         
         return (crop_x, crop_y, crop_w, crop_h)
 
-# ======================= TRANSCRIÇÃO =======================
+# ======================= TRANSCRIÇÃO (ROBUSTA) =======================
+
+def extract_audio_wav_strong(input_video: str, sr: int = 16000) -> str:
+    """
+    Extração de áudio à prova de VFR/PTS ruins.
+    1) Remuxa o vídeo (ajusta timebase)
+    2) Extrai WAV mono 16k
+    3) Se o WAV vier curto, faz fallback re-decodificando o original
+    """
+    vid_dur = probe_duration(input_video)
+    print(f"[probe] video: {vid_dur:.2f}s" if vid_dur else "[probe] video: ?")
+
+    remux = remux_video(input_video)
+    print(f"[remux] -> {remux}")
 
-def extract_audio_wav(input_video: str, sr: int = 16000) -> str:
-    """Extrai o áudio para WAV mono 16kHz para robustez da transcrição."""
-    fd, tmp_path = tempfile.mkstemp(suffix=".wav")
+    fd, wav_path = tempfile.mkstemp(suffix=".wav")
     os.close(fd)
-    print(f"[ffmpeg] extraindo WAV -> {tmp_path}")
-    cmd = [
-        "ffmpeg", "-y", "-i", input_video,
-        "-vn", "-ac", "1", "-ar", str(sr), "-f", "wav", tmp_path
+
+    # Tentativa 1 — do remux, convertendo para PCM
+    cmd1 = [
+        "ffmpeg", "-y",
+        "-i", remux,
+        "-vn",
+        "-map", "0:a:0?",
+        "-ac", "1", "-ar", str(sr),
+        "-c:a", "pcm_s16le",
+        wav_path
     ]
-    subprocess.run(cmd, check=True, capture_output=True)
-    return tmp_path
+    subprocess.run(cmd1, check=True, capture_output=True)
+    wav_dur = probe_duration(wav_path)
+    print(f"[probe] wav #1: {wav_dur:.2f}s" if wav_dur else "[probe] wav #1: ?")
+
+    # Fallback — redecodifica direto do original
+    if vid_dur and (not wav_dur or wav_dur + 2 < vid_dur):
+        print("[fallback] re-decodificando o arquivo original…")
+        fd2, wav2 = tempfile.mkstemp(suffix=".wav")
+        os.close(fd2)
+        cmd2 = [
+            "ffmpeg", "-y",
+            "-fflags", "+genpts",
+            "-i", input_video,
+            "-vn",
+            "-ac", "1", "-ar", str(sr),
+            "-c:a", "pcm_s16le",
+            wav2
+        ]
+        subprocess.run(cmd2, check=True, capture_output=True)
+        wav2_dur = probe_duration(wav2)
+        print(f"[probe] wav #2: {wav2_dur:.2f}s" if wav2_dur else "[probe] wav #2: ?")
+        if wav2_dur and (not wav_dur or wav2_dur > wav_dur):
+            try:
+                Path(wav_path).unlink(missing_ok=True)
+                Path(remux).unlink(missing_ok=True)
+            except Exception:
+                pass
+            return wav2
 
-def transcribe(video_file: str, model_size: str = "small") -> List[Segment]:
-    true_path = resolve_video_path(video_file)
-    if not true_path or not os.path.exists(true_path):
-        print(f"[transcribe] caminho inválido: {video_file}")
-        return []
+    try:
+        Path(remux).unlink(missing_ok=True)
+    except Exception:
+        pass
+    return wav_path
 
-    # Durações para diagnóstico
-    vid_dur = probe_duration(true_path)
-    print(f"[probe] duração do vídeo: {vid_dur:.2f}s" if vid_dur else "[probe] duração do vídeo: desconhecida")
+def transcribe(video_file: str, model_size: str = "small") -> List[Segment]:
+    print(f"[whisper] modelo: {model_size}")
+    model = whisper.load_model(model_size)
 
-    print(f"[whisper] carregando modelo: {model_size}")
-    model = whisper.load_model(model_size)  # device auto
-    print(f"[whisper] extraindo áudio WAV…")
-    audio_wav = extract_audio_wav(true_path, sr=16000)
+    print("[audio] extraindo WAV robusto…")
+    audio_wav = extract_audio_wav_strong(video_file, sr=16000)
 
+    vid_dur = probe_duration(video_file)
     wav_dur = probe_duration(audio_wav)
-    print(f"[probe] duração do WAV: {wav_dur:.2f}s" if wav_dur else "[probe] duração do WAV: desconhecida")
-    if vid_dur and wav_dur and wav_dur + 1 < vid_dur:
-        print("[aviso] WAV menor que o vídeo — verifique codecs/ffmpeg. Mesmo assim vou transcrever o que foi extraído.")
+    if vid_dur:  print(f"[dur] vídeo: {vid_dur:.2f}s")
+    if wav_dur:  print(f"[dur] wav:   {wav_dur:.2f}s")
 
     print("[whisper] transcrevendo…")
-    # Configs mais robustas para CPU/Spaces
     result = model.transcribe(
         audio_wav,
         language="pt",
@@ -224,8 +274,8 @@ def transcribe(video_file: str, model_size: str = "small") -> List[Segment]:
 
     segments = [Segment(start=s["start"], end=s["end"], text=s["text"].strip())
                 for s in result.get("segments", [])]
-
     print(f"[whisper] segmentos: {len(segments)}")
+
     try:
         Path(audio_wav).unlink(missing_ok=True)
     except Exception:
@@ -256,7 +306,7 @@ def extract_video_segment(input_video: str, output_video: str, start_time: float
 
 def apply_smart_crop_to_video(input_path: str, output_path: str, target_width: int, 
                               target_height: int, sample_frames: int = 10) -> bool:
-    """Calcula o melhor crop com rastreamento facial e aplica o crop com FFmpeg preservando o áudio."""
+    """Calcula o melhor crop com rastreamento facial e aplica com FFmpeg preservando áudio."""
     tracker = FaceTracker()
     cap = cv2.VideoCapture(input_path)
     if not cap.isOpened():
@@ -434,7 +484,6 @@ def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir:
     Path(output_dir).mkdir(parents=True, exist_ok=True)
     outputs = []
     
-    import random
     for i in range(int(k)):
         num_blocks = random.randint(min_blocks, min(max_blocks, len(segments)))
         step = max(1, len(segments) // num_blocks)
@@ -563,7 +612,7 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
                     maxb = gr.Number(value=8, label="Blocos max")
                 with gr.Row():
                     k2 = gr.Number(value=2, label="Quantidade")
-                    gap2 = gr.Number(value=0.60, label="Gap")
+                    gap2 = gr.Number(value=0.60", label="Gap")
                     pad2 = gr.Number(value=0.08, label="Pad")
                 ar_mode2 = gr.Dropdown(["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
                                       value="Original", label="Formato")
@@ -581,5 +630,5 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
                      outputs=[out_creative, status_creative])
 
 if __name__ == "__main__":
+    # Fila para tarefas longas (compatível com Gradio 4)
     demo.queue(max_size=20).launch()
-