Update api/ltx_server.py

api/ltx_server.py

@@ -436,61 +436,98 @@ class VideoService:
         return chunks
 
 
-    
-    def _gerar_lista_com_transicoes(self, pasta: str, video_paths: List[str], crossfade_frames: int = 8) -> List[str]:
+
+    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 com cortes e transições de crossfade.
-        Cada transição é de 'crossfade_frames' frames.
-        
-        Args:
-            pasta: pasta de trabalho
-            video_paths: lista de caminhos de vídeos originais
-            crossfade_frames: quantidade de frames para transição
-        Returns:
-            List[str]: nova lista de caminhos de vídeos, incluindo transições
+        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
+    
         nova_lista = []
-
-        pasta
     
+        # 🔹 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.")
     
-        for i in range(len(video_paths)):
-            video_atual = video_paths[i]
-            video_proximo = video_paths[i + 1] if i + 1 < len(video_paths) else None
-            
-            # ---- 1. Video atual podado ----
+        print(f"[DEBUG] Gerando transições entre {len(video_paths)} vídeos...")
+    
+        # 🔹 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}")
+    
+            # --- PRIMEIRO VÍDEO ---
             if i == 0:
-                podado = os.path.join(pasta, f"podado_fim_{i+1}.mp4")
-                cmd_trim = f'ffmpeg -y -i "{video_atual}" -vf "trim=0:-{crossfade_frames},setpts=PTS-STARTPTS" "{podado}"'
-            elif video_proximo:
-                podado = os.path.join(pasta, f"podado_inicio_fim_{i+1}.mp4")
-                cmd_trim = f'ffmpeg -y -i "{video_atual}" -vf "trim={crossfade_frames}:-{crossfade_frames},setpts=PTS-STARTPTS" "{podado}"'
-            else:
-                podado = os.path.join(pasta, f"podado_inicio_{i+1}.mp4")
-                cmd_trim = f'ffmpeg -y -i "{video_atual}" -vf "trim={crossfade_frames}:,setpts=PTS-STARTPTS" "{podado}"'
+                # 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}"'
+                )
+                subprocess.run(cmd_trim, shell=True, check=True)
+                nova_lista.append(video_podado_fim)
+                print(f"[DEBUG] Adicionado {video_podado_fim}")
     
-            subprocess.run(cmd_trim, shell=True, check=True)
-            nova_lista.append(podado)
+            # --- INTERMEDIÁRIO ---
+            if i < len(video_paths) - 1:
+                proximo_video = video_paths[i + 1]
+                prox_nome = os.path.splitext(os.path.basename(proximo_video))[0]
     
-            # ---- 2. Gerar transição, se houver próximo vídeo ----
-            if video_proximo:
-                temp_fim = os.path.join(pasta, f"temp_fim_{i+1}.mp4")
-                cmd_fim = f'ffmpeg -y -i "{video_atual}" -vf "trim=-{crossfade_frames},setpts=PTS-STARTPTS" "{temp_fim}"'
+                # 2️⃣ Extrair últimos frames do atual
+                fim_tmp = os.path.join(pasta, f"{base_nome}_fim_{i}.mp4")
+                cmd_fim = (
+                    f'ffmpeg -y -sseof -{crossfade_frames / 24:.3f} -i "{video_atual}" '
+                    f'-vf "setpts=PTS-STARTPTS" -an "{fim_tmp}"'
+                )
                 subprocess.run(cmd_fim, shell=True, check=True)
     
-                temp_inicio = os.path.join(pasta, f"temp_inicio_{i+2}.mp4")
-                cmd_inicio = f'ffmpeg -y -i "{video_proximo}" -vf "trim=0:{crossfade_frames},setpts=PTS-STARTPTS" "{temp_inicio}"'
+                # 3️⃣ Extrair primeiros frames do próximo
+                inicio_tmp = os.path.join(pasta, f"{prox_nome}_inicio_{i+1}.mp4")
+                cmd_inicio = (
+                    f'ffmpeg -y -i "{proximo_video}" -vf "trim=0:{crossfade_frames},setpts=PTS-STARTPTS" '
+                    f'-an "{inicio_tmp}"'
+                )
                 subprocess.run(cmd_inicio, shell=True, check=True)
     
-                transicao = os.path.join(pasta, f"transicao_{i+1}_{i+2}.mp4")
-                cmd_blend = f"""
-                ffmpeg -y -i "{temp_fim}" -i "{temp_inicio}" -filter_complex "
-                [0:v][1:v]blend=all_expr='A*(1-T/{crossfade_frames})+B*(T/{crossfade_frames})'[v]
-                " -map "[v]" -c:v libx264 -pix_fmt yuv420p "{transicao}"
-                """
-                subprocess.run(cmd_blend, shell=False, check=True)
-                nova_lista.append(transicao)
+                # 4️⃣ Gerar transição (crossfade)
+                transicao_path = os.path.join(pasta, f"transicao_{i+1}.mp4")
+                cmd_crossfade = (
+                    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}"'
+                )
+                subprocess.run(cmd_crossfade, shell=True, check=True)
+    
+                nova_lista.append(transicao_path)
+                print(f"[DEBUG] Transição adicionada: {transicao_path}")
+    
+                # --- VÍDEO INTERMEDIÁRIO (remover início e fim) ---
+                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}"'
+                    )
+                    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}"'
+                    )
+                    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