Update api/ltx_server.py

api/ltx_server.py

@@ -438,152 +438,120 @@ class VideoService:
 
     
 
-    def _get_video_info(self, path: str) -> dict:
-        """Retorna metadados essenciais do vídeo (DNA)."""
-        cmd = f"ffprobe -v error -select_streams v:0 -show_entries " \
-              f"stream=codec_name,width,height,avg_frame_rate,duration -of json {shlex.quote(path)}"
-        try:
-            result = subprocess.run(shlex.split(cmd), capture_output=True, text=True, check=True)
-            data = json.loads(result.stdout)
-            stream = data.get("streams", [{}])[0]
-            fps_str = stream.get("avg_frame_rate", "0/1")
-            try:
-                num, den = map(float, fps_str.split("/"))
-                fps = num / den if den != 0 else 0
-            except Exception:
-                fps = 0
-            info = {
-                "arquivo": os.path.basename(path),
-                "codec": stream.get("codec_name"),
-                "resolução": f"{stream.get('width')}x{stream.get('height')}",
-                "fps": round(fps, 2),
-                "duração": float(stream.get("duration", 0))
-            }
-            print(f"🧬 [DNA] {info}")
-            return info
-        except subprocess.CalledProcessError:
-            print(f"⚠️ Falha ao ler metadados de {path}")
-            return {}
-
+    
 
     def _gerar_lista_com_transicoes(self, pasta: str, video_paths: list[str], crossfade_frames: int = 8) -> list[str]:
-        """
-        Gera uma nova lista de vídeos aplicando transições suaves (crossfade de N frames)
-        entre cada par de vídeos da lista original.
-        Mantém todos os arquivos na mesma pasta dos vídeos originais.
-        """
+        import os, subprocess, json
     
-        import os, subprocess
-    
-        nova_lista = []
+        def get_duracao_frames(video):
+            """Retorna duração em frames (int)."""
+            cmd = f'ffprobe -v error -select_streams v:0 -show_entries stream=nb_frames -of json "{video}"'
+            try:
+                res = subprocess.check_output(cmd, shell=True)
+                info = json.loads(res)
+                return int(info["streams"][0]["nb_frames"])
+            except Exception:
+                return 0
     
-        # 🔹 Filtrar apenas vídeos MP4 válidos
-        video_paths = [v for v in video_paths if v.endswith(".mp4") and os.path.isfile(v)]
-        if not video_paths:
-            raise ValueError("[ERRO] Nenhum vídeo MP4 válido encontrado para processar.")
+        def run_safe(cmd, desc):
+            print(f"[DEBUG] {desc}: {cmd}")
+            result = subprocess.run(cmd, shell=True)
+            if result.returncode != 0:
+                print(f"[WARN] Falha ao executar: {desc}")
+            return result.returncode == 0
     
-        print(f"[DEBUG] Gerando transições entre {len(video_paths)} vídeos...")
+        nova_lista = []
+        video_paths = [v for v in video_paths if os.path.isfile(v)]
+        print(f"[DEBUG] Iniciando geração de transições ({len(video_paths)} vídeos, fade={crossfade_frames}f)")
     
-        # 🔹 Iterar pelos vídeos originais
         for i, video_atual in enumerate(video_paths):
             base_nome = os.path.splitext(os.path.basename(video_atual))[0]
-            print(f"[DEBUG] Processando vídeo {i+1}/{len(video_paths)}: {base_nome}")
+            dur_frames = get_duracao_frames(video_atual)
+            if dur_frames <= crossfade_frames * 2:
+                print(f"[WARN] {video_atual} tem poucos frames ({dur_frames}). Pulando...")
+                continue
     
-            # --- PRIMEIRO VÍDEO ---
+            # 1️⃣ PRIMEIRO VÍDEO
             if i == 0:
-                # 1️⃣ Podar o final (remover últimos frames)
-                video_podado_fim = os.path.join(pasta, f"{base_nome}_podado_fim.mp4")
-                cmd_trim = (
-                    f'ffmpeg -y -i "{video_atual}" -vf "trim=0:-{crossfade_frames},setpts=PTS-STARTPTS" '
-                    f'"{video_podado_fim}"'
+                podado_fim = os.path.join(pasta, f"{base_nome}_fim.mp4")
+                cmd = (
+                    f'ffmpeg -y -i "{video_atual}" -filter:v "trim=0:{dur_frames - crossfade_frames},setpts=PTS-STARTPTS" '
+                    f'-an "{podado_fim}"'
                 )
-                subprocess.run(cmd_trim, shell=True, check=True)
-                nova_lista.append(video_podado_fim)
-                print(f"[DEBUG] Adicionado {video_podado_fim}")
+                if run_safe(cmd, f"Podando fim de {video_atual}"):
+                    nova_lista.append(podado_fim)
     
-            # --- INTERMEDIÁRIO ---
+            # 2️⃣ GERAR TRANSIÇÃO COM O PRÓXIMO
             if i < len(video_paths) - 1:
-                proximo_video = video_paths[i + 1]
-                prox_nome = os.path.splitext(os.path.basename(proximo_video))[0]
+                prox = video_paths[i + 1]
+                prox_nome = os.path.splitext(os.path.basename(prox))[0]
+                dur_prox = get_duracao_frames(prox)
     
-                # 2️⃣ Extrair últimos frames do atual
-                fim_tmp = os.path.join(pasta, f"{base_nome}_fim_{i}.mp4")
+                # cortar fim do atual
+                fim_tmp = os.path.join(pasta, f"{base_nome}_fimtmp.mp4")
                 cmd_fim = (
-                    f'ffmpeg -y -sseof -{crossfade_frames / 24:.3f} -i "{video_atual}" '
-                    f'-vf "setpts=PTS-STARTPTS" -an "{fim_tmp}"'
+                    f'ffmpeg -y -ss {max((dur_frames - crossfade_frames) / 24, 0):.3f} -i "{video_atual}" '
+                    f'-frames:v {crossfade_frames} -an "{fim_tmp}"'
                 )
-                subprocess.run(cmd_fim, shell=True, check=True)
+                run_safe(cmd_fim, f"Extraindo fim de {base_nome}")
     
-                # 3️⃣ Extrair primeiros frames do próximo
-                inicio_tmp = os.path.join(pasta, f"{prox_nome}_inicio_{i+1}.mp4")
+                # cortar início do próximo
+                inicio_tmp = os.path.join(pasta, f"{prox_nome}_iniciotmp.mp4")
                 cmd_inicio = (
-                    f'ffmpeg -y -i "{proximo_video}" -vf "trim=0:{crossfade_frames},setpts=PTS-STARTPTS" '
-                    f'-an "{inicio_tmp}"'
+                    f'ffmpeg -y -i "{prox}" -frames:v {crossfade_frames} -an "{inicio_tmp}"'
                 )
-                subprocess.run(cmd_inicio, shell=True, check=True)
+                run_safe(cmd_inicio, f"Extraindo início de {prox_nome}")
     
-                # 4️⃣ Gerar transição (crossfade)
-                transicao_path = os.path.join(pasta, f"transicao_{i+1}.mp4")
-                cmd_crossfade = (
+                # crossfade (vídeo sem áudio)
+                transicao = os.path.join(pasta, f"transicao_{i+1}.mp4")
+                cmd_xfade = (
                     f'ffmpeg -y -i "{fim_tmp}" -i "{inicio_tmp}" '
                     f'-filter_complex "xfade=transition=fade:duration={crossfade_frames/24:.3f}:offset=0" '
-                    f'-c:v libx264 -pix_fmt yuv420p "{transicao_path}"'
+                    f'-c:v libx264 -pix_fmt yuv420p -an "{transicao}"'
                 )
-                subprocess.run(cmd_crossfade, shell=True, check=True)
+                if run_safe(cmd_xfade, f"Transição {i+1}"):
+                    nova_lista.append(transicao)
     
-                nova_lista.append(transicao_path)
-                print(f"[DEBUG] Transição adicionada: {transicao_path}")
-    
-                # --- VÍDEO INTERMEDIÁRIO (remover início e fim) ---
+                # podar início/fim do próximo
                 if i + 1 < len(video_paths) - 1:
-                    video_podado_inicio_fim = os.path.join(pasta, f"{prox_nome}_podado_if.mp4")
-                    cmd_trim_if = (
-                        f'ffmpeg -y -i "{proximo_video}" -vf "trim={crossfade_frames}:-{crossfade_frames},setpts=PTS-STARTPTS" '
-                        f'"{video_podado_inicio_fim}"'
+                    podado_if = os.path.join(pasta, f"{prox_nome}_if.mp4")
+                    cmd_if = (
+                        f'ffmpeg -y -i "{prox}" '
+                        f'-filter:v "trim={crossfade_frames}:{dur_prox - crossfade_frames},setpts=PTS-STARTPTS" '
+                        f'-an "{podado_if}"'
                     )
-                    subprocess.run(cmd_trim_if, shell=True, check=True)
-                    nova_lista.append(video_podado_inicio_fim)
-                    print(f"[DEBUG] Adicionado vídeo intermediário podado: {video_podado_inicio_fim}")
-    
-                # --- ÚLTIMO VÍDEO ---
-                elif i + 1 == len(video_paths) - 1:
-                    video_podado_inicio = os.path.join(pasta, f"{prox_nome}_podado_inicio.mp4")
-                    cmd_trim_inicio = (
-                        f'ffmpeg -y -i "{proximo_video}" -vf "trim={crossfade_frames},setpts=PTS-STARTPTS" '
-                        f'"{video_podado_inicio}"'
+                    if run_safe(cmd_if, f"Podando início/fim de {prox_nome}"):
+                        nova_lista.append(podado_if)
+                else:
+                    podado_inicio = os.path.join(pasta, f"{prox_nome}_inicio.mp4")
+                    cmd_ini = (
+                        f'ffmpeg -y -i "{prox}" '
+                        f'-filter:v "trim={crossfade_frames}:{dur_prox},setpts=PTS-STARTPTS" -an "{podado_inicio}"'
                     )
-                    subprocess.run(cmd_trim_inicio, shell=True, check=True)
-                    nova_lista.append(video_podado_inicio)
-                    print(f"[DEBUG] Adicionado último vídeo podado: {video_podado_inicio}")
-    
-        print(f"[DEBUG] Nova lista final de {len(nova_lista)} arquivos criada.")
-        return nova_lista
-    
-    def _concat_mp4s_no_reencode(self, mp4_list: List[str], out_path: str):
-        """
-        Concatena múltiplos MP4s sem reencode usando o demuxer do ffmpeg.
-        ATENÇÃO: todos os arquivos precisam ter mesmo codec, fps, resolução etc.
-        """
-        if not mp4_list or len(mp4_list) < 2:
-            raise ValueError("Forneça pelo menos dois arquivos MP4 para concatenar.")
+                    if run_safe(cmd_ini, f"Podando início de {prox_nome}"):
+                        nova_lista.append(podado_inicio)
     
-        # Cria lista temporária para o ffmpeg
-        with tempfile.NamedTemporaryFile("w", delete=False, suffix=".txt") as f:
-            for mp4 in mp4_list:
-                f.write(f"file '{os.path.abspath(mp4)}'\n")
-            list_path = f.name
+        # 🔹 Remover vídeos vazios
+        nova_lista = [v for v in nova_lista if os.path.isfile(v) and get_duracao_frames(v) > 0]
+        print(f"[DEBUG] Lista final para concatenação: {len(nova_lista)} vídeos válidos")
+        for v in nova_lista:
+            print(f"  - {v}")
     
-        cmd = f"ffmpeg -y -f concat -safe 0 -i {list_path} -c copy {out_path}"
-        print(f"[DEBUG] Concat: {cmd}")
+        return nova_list
+
+    def _concat_mp4s_no_reencode(self, lista_mp4, output_path):
+    import tempfile, subprocess
+    with tempfile.NamedTemporaryFile("w", delete=False, suffix=".txt") as f:
+        for mp4 in lista_mp4:
+            f.write(f"file '{os.path.abspath(mp4)}'\n")
+        lista_path = f.name
+
+    print(f"[DEBUG] Concatenando {len(lista_mp4)} partes em {output_path}")
+    cmd = f'ffmpeg -y -f concat -safe 0 -i "{lista_path}" -c copy "{output_path}"'
+    subprocess.run(cmd, shell=True, check=True)
     
-        try:
-            subprocess.check_call(shlex.split(cmd))
-        finally:
-            try:
-                os.remove(list_path)
-            except Exception:
-                pass  
 
+    
     def generate(
         self,
         prompt,
@@ -807,7 +775,7 @@ class VideoService:
                     print(f"[DEBUG] Falha no move; usando tmp como final: {e}")
 
             final_concat = os.path.join(results_dir, f"concat_fim_{used_seed}.mp4")
-            partes_mp4_fade = self._gerar_lista_com_transicoes(pasta=results_dir, video_paths=partes_mp4, crossfade_frames=8)
+            partes_mp4_fade = self._gerar_lista_com_transicoes(pasta=results_dir, video_paths=partes_mp4, crossfade_frames=9)
             self._concat_mp4s_no_reencode(partes_mp4_fade, final_concat)