Update api/ltx_server.py

api/ltx_server.py

@@ -438,107 +438,75 @@ class VideoService:
 
     
 
+     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 (blend frame a frame)
+        seguindo exatamente a lógica linear de Carlos.
+        """
+        import os, subprocess, shutil
     
-
-    def _gerar_lista_com_transicoes(self, pasta: str, video_paths: list[str], crossfade_frames: int = 8) -> list[str]:
-        import os, subprocess, json
-    
-        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
-    
-        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
-    
+        poda = crossfade_frames
+        total_partes = len(video_paths)
+        video_anterior_fade_fim = None
         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)")
     
-        for i, video_atual in enumerate(video_paths):
-            base_nome = os.path.splitext(os.path.basename(video_atual))[0]
-            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
+        print(f"[DEBUG] Iniciando pipeline com {total_partes} vídeos e {poda} frames de crossfade")
     
-            # 1️⃣ PRIMEIRO VÍDEO
-            if i == 0:
-                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}"'
-                )
-                if run_safe(cmd, f"Podando fim de {video_atual}"):
-                    nova_lista.append(podado_fim)
+        for i in range(total_partes):
+            base = os.path.splitext(os.path.basename(video_paths[i]))[0]
+            video_clone = os.path.join(pasta, f"{base}_clone_{i}.mp4")
+            shutil.copy(video_paths[i], video_clone)
     
-            # 2️⃣ GERAR TRANSIÇÃO COM O PRÓXIMO
-            if i < len(video_paths) - 1:
-                prox = video_paths[i + 1]
-                prox_nome = os.path.splitext(os.path.basename(prox))[0]
-                dur_prox = get_duracao_frames(prox)
+            # --- PODA ---
+            video_podado = os.path.join(pasta, f"{base}_podado_{i}.mp4")
+            trim_ini = poda if i > 0 else 0
+            trim_fim = -poda if i < total_partes - 1 else 0
+            filtro_trim = f"trim=start_frame={trim_ini}"
+            if trim_fim != 0:
+                filtro_trim += f":end_frame=nb_frames+{trim_fim}"
+            cmd_poda = f'ffmpeg -y -hide_banner -loglevel error -i "{video_clone}" -vf "{filtro_trim},setpts=PTS-STARTPTS" -an "{video_podado}"'
+            subprocess.run(cmd_poda, shell=True, check=True)
+            nova_lista.append(video_podado)
+            print(f"[DEBUG] [{i}] Podado -> {video_podado}")
     
-                # cortar fim do atual
-                fim_tmp = os.path.join(pasta, f"{base_nome}_fimtmp.mp4")
-                cmd_fim = (
-                    f'ffmpeg -y -ss {max((dur_frames - crossfade_frames) / 24, 0):.3f} -i "{video_atual}" '
-                    f'-frames:v {crossfade_frames} -an "{fim_tmp}"'
+            # --- FADE_INI ---
+            video_fade_ini = None
+            if i > 0:
+                video_fade_ini = os.path.join(pasta, f"{base}_fade_ini_{i}.mp4")
+                cmd_ini = (
+                    f'ffmpeg -y -hide_banner -loglevel error -i "{video_clone}" '
+                    f'-vf "trim=end_frame={poda},setpts=PTS-STARTPTS" -an "{video_fade_ini}"'
                 )
-                run_safe(cmd_fim, f"Extraindo fim de {base_nome}")
+                subprocess.run(cmd_ini, shell=True, check=True)
+                print(f"[DEBUG] Fade_ini ({poda} frames) -> {video_fade_ini}")
     
-                # cortar início do próximo
-                inicio_tmp = os.path.join(pasta, f"{prox_nome}_iniciotmp.mp4")
-                cmd_inicio = (
-                    f'ffmpeg -y -i "{prox}" -frames:v {crossfade_frames} -an "{inicio_tmp}"'
+            # --- TRANSIÇÃO ---
+            if video_anterior_fade_fim and video_fade_ini:
+                transicao = os.path.join(pasta, f"transicao_{i-1}_{i}.mp4")
+                cmd_blend = (
+                    f'ffmpeg -y -hide_banner -loglevel error '
+                    f'-i "{video_anterior_fade_fim}" -i "{video_fade_ini}" '
+                    f'-filter_complex "[0:v][1:v]blend=all_expr=\'A*(1-T/{poda})+B*(T/{poda})\',format=yuv420p" '
+                    f'-frames:v {poda} "{transicao}"'
                 )
-                run_safe(cmd_inicio, f"Extraindo início de {prox_nome}")
+                subprocess.run(cmd_blend, shell=True, check=True)
+                nova_lista.append(transicao)
+                print(f"[DEBUG] Transição criada -> {transicao}")
     
-                # 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 -an "{transicao}"'
+            # --- FADE_FIM ---
+            if i < total_partes - 1:
+                video_fade_fim = os.path.join(pasta, f"{base}_fade_fim_{i}.mp4")
+                cmd_fim = (
+                    f'ffmpeg -y -hide_banner -loglevel error -i "{video_clone}" '
+                    f'-vf "trim=start_frame=nb_frames-{poda},setpts=PTS-STARTPTS" -an "{video_fade_fim}"'
                 )
-                if run_safe(cmd_xfade, f"Transição {i+1}"):
-                    nova_lista.append(transicao)
-    
-                # podar início/fim do próximo
-                if i + 1 < len(video_paths) - 1:
-                    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}"'
-                    )
-                    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}"'
-                    )
-                    if run_safe(cmd_ini, f"Podando início de {prox_nome}"):
-                        nova_lista.append(podado_inicio)
+                subprocess.run(cmd_fim, shell=True, check=True)
+                video_anterior_fade_fim = video_fade_fim
+                print(f"[DEBUG] Fade_fim preparado -> {video_fade_fim}")
     
-        # 🔹 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}")
+        print(f"[DEBUG] Nova lista finalizada com {len(nova_lista)} partes.")
+        return nova_lista
     
-        return nova_list
-
     def _concat_mp4s_no_reencode(self, lista_mp4, output_path):
     
         with tempfile.NamedTemporaryFile("w", delete=False, suffix=".txt") as f: