Update api/ltx_server.py

api/ltx_server.py

@@ -436,125 +436,92 @@ class VideoService:
         return chunks
 
 
-    def _concat_crossfade_cascade(self, video_paths: List[str], crossfade_frames: int = 8, output_path: str = "/tmp/final_output.mp4"):
+    
+    def _gerar_lista_com_transicoes(self, video_paths: List[str], crossfade_frames: int = 8) -> List[str]:
         """
-        Concatena uma lista de vídeos aplicando crossfade de 'crossfade_frames' entre cada par.
+        Gera uma nova lista de vídeos com cortes e transições de crossfade.
+        Cada transição é de 'crossfade_frames' frames.
+        
         Args:
-            video_paths: lista de caminhos dos vídeos a concatenar
-            crossfade_frames: quantidade de frames para o crossfade
-            output_path: caminho do vídeo final gerado
+            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
         """
-        if not video_paths or len(video_paths) == 1:
-            # Apenas copiar se houver 1 ou nenhum vídeo
-            if video_paths:
-                subprocess.run(f"cp '{video_paths[0]}' '{output_path}'", shell=True, check=True)
-            return output_path
-    
-        # Lista temporária de vídeos intermediários
-        temp_videos = []
+        nova_lista = []
     
-        # Começamos com o primeiro vídeo
-        prev_video = video_paths[0]
+        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
     
-        for i in range(1, len(video_paths)):
-            next_video = video_paths[i]
-    
-            # Cria arquivo temporário para resultado do crossfade
-            temp_out = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-            temp_out_path = temp_out.name
-            temp_out.close()
-    
-            # Comando FFmpeg
-            cmd = f"""
-            ffmpeg -y -i "{prev_video}" -i "{next_video}" -filter_complex "
-            [0:v]trim=0:-{crossfade_frames},setpts=PTS-STARTPTS[v_prev_main];
-            [0:v]trim=-{crossfade_frames},setpts=PTS-STARTPTS[v_prev_fade];
-            [1:v]trim=0:{crossfade_frames},setpts=PTS-STARTPTS[v_next_fade];
-            [1:v]trim={crossfade_frames}:,setpts=PTS-STARTPTS[v_next_main];
-            [v_prev_fade][v_next_fade]blend=all_expr='A*(1-T/{crossfade_frames})+B*(T/{crossfade_frames})'[crossfade];
-            [v_prev_main][crossfade][v_next_main]concat=n=3:v=1:a=0[v]
-            " -map "[v]" -c:v libx264 -pix_fmt yuv420p "{temp_out_path}"
-            """
+            # ---- 1. Video atual podado ----
+            if i == 0:
+                # Primeiro vídeo: remove últimos crossfade_frames
+                podado = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+                cmd_trim = f'ffmpeg -y -i "{video_atual}" -vf "trim=0:-{crossfade_frames},setpts=PTS-STARTPTS" "{podado}"'
+            elif video_proximo:
+                # Vídeos do meio: remove primeiros e últimos crossfade_frames
+                podado = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+                cmd_trim = f'ffmpeg -y -i "{video_atual}" -vf "trim={crossfade_frames}:-{crossfade_frames},setpts=PTS-STARTPTS" "{podado}"'
+            else:
+                # Último vídeo: remove primeiros crossfade_frames
+                podado = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+                cmd_trim = f'ffmpeg -y -i "{video_atual}" -vf "trim={crossfade_frames}:,setpts=PTS-STARTPTS" "{podado}"'
     
-            # Executa FFmpeg
-            subprocess.run(cmd, shell=True, check=True)
+            subprocess.run(cmd_trim, shell=True, check=True)
+            nova_lista.append(podado)
     
-            # Atualiza prev_video para o próximo crossfade
-            prev_video = temp_out_path
-            temp_videos.append(temp_out_path)
+            # ---- 2. Gerar transição, se houver próximo vídeo ----
+            if video_proximo:
+                # Extrair últimos frames do atual
+                temp_fim = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+                cmd_fim = f'ffmpeg -y -i "{video_atual}" -vf "trim=-{crossfade_frames},setpts=PTS-STARTPTS" "{temp_fim}"'
+                subprocess.run(cmd_fim, shell=True, check=True)
     
-        # Move o último vídeo processado para o destino final
-        os.rename(prev_video, output_path)
+                # Extrair primeiros frames do próximo
+                temp_inicio = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+                cmd_inicio = f'ffmpeg -y -i "{video_proximo}" -vf "trim=0:{crossfade_frames},setpts=PTS-STARTPTS" "{temp_inicio}"'
+                subprocess.run(cmd_inicio, shell=True, check=True)
     
-        # Remove vídeos temporários antigos
-        for tmp in temp_videos[:-1]:
-            if os.path.exists(tmp):
-                os.remove(tmp)
+                # Criar vídeo de transição
+                transicao = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+                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=True, check=True)
+                nova_lista.append(transicao)
     
-        return output_path
+        return nova_lista
 
-    
-    def _concat_crossfade_cascade1(self, video_paths: List[str], output_path: str, crossfade_frames: int = 8):
+    def _concat_mp4s_no_reencode(self, mp4_list: List[str], out_path: str):
         """
-        Concatena vídeos em cascata com crossfade, usando FFmpeg.
-        
-        Args:
-            video_paths (List[str]): Lista de caminhos dos vídeos a serem concatenados.
-            output_path (str): Caminho do arquivo final de saída.
-            crossfade_frames (int): Número de frames para o crossfade.
+        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 len(video_paths) < 2:
-            raise ValueError("É necessário pelo menos 2 vídeos para concatenação com crossfade.")
-        
-        # Cria uma lista de temporários
-        tmp_videos = []
-        for i in range(len(video_paths) - 1):
-            # Nome do arquivo temporário
-            tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-            tmp_videos.append(tmp_file)
-            
-            # Define vídeos para crossfade
-            if i == 0:
-                vid1 = video_paths[0]
-            else:
-                vid1 = tmp_videos[i-1]
-            vid2 = video_paths[i+1]
-            
-            # Filter complex FFmpeg
-            filter_complex = f"""
-            [0:v]trim=0:-{crossfade_frames},setpts=PTS-STARTPTS[v0pre];
-            [0:v]trim=-{crossfade_frames},setpts=PTS-STARTPTS[v0fade];
-            [1:v]trim=0:{crossfade_frames},setpts=PTS-STARTPTS[v1fade];
-            [v0fade][v1fade]blend=all_expr='A*(1-T/{crossfade_frames})+B*(T/{crossfade_frames})'[xf];
-            [1:v]trim={crossfade_frames}:,setpts=PTS-STARTPTS[v1post];
-            [v0pre][xf][v1post]concat=n=3:v=1:a=0[v]
-            """
-            
-            cmd = [
-                "ffmpeg", "-y",
-                "-i", vid1,
-                "-i", vid2,
-                "-filter_complex", filter_complex,
-                "-map", "[v]",
-                "-c:v", "libx264",
-                "-pix_fmt", "yuv420p",
-                tmp_file
-            ]
-            
-            print(f"[DEBUG] Executando: {' '.join(cmd)}")
-            subprocess.run(cmd, check=True)
-        
-        # Último temporário é o arquivo final
-        final_tmp = tmp_videos[-1]
-        os.rename(final_tmp, output_path)
-        
-        # Limpa os temporários intermediários
-        for tmp in tmp_videos[:-1]:
-            if os.path.exists(tmp):
-                os.remove(tmp)
-        
-        print(f"[INFO] Vídeo final gerado: {output_path}")
+        if not mp4_list or len(mp4_list) < 2:
+            raise ValueError("Forneça pelo menos dois arquivos MP4 para concatenar.")
+    
+        # 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
+    
+        cmd = f"ffmpeg -y -f concat -safe 0 -i {list_path} -c copy {out_path}"
+        print(f"[DEBUG] Concat: {cmd}")
+    
+        try:
+            subprocess.check_call(shlex.split(cmd))
+        finally:
+            try:
+                os.remove(list_path)
+            except Exception:
+                pass  
         
+    
+    
 
     def generate(
         self,
@@ -784,12 +751,9 @@ 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")
-            #self._concat_mp4s_no_reencode(partes_mp4, final_concat)
-            self._concat_crossfade_cascade(
-                video_paths=partes_mp4, 
-                crossfade_frames=8,
-                output_path=final_concat,
-            )
+            final_concat_new = self._gerar_lista_com_transicoes(video_paths=final_concat, crossfade_frames=8)
+            self._concat_mp4s_no_reencode(partes_mp4, final_concat_new)
+            
             
             
             self._log_gpu_memory("Fim da Geração")