Update api/ltx_server.py

api/ltx_server.py

@@ -435,9 +435,123 @@ class VideoService:
         print("================PODA CAUSAL=================")
         return chunks
 
+    def _concat_mp4s_no_reencode(self, mp4_list: List[str], out_path: str):
+        """
+        Concatena múltiplos MP4s sem reencode usando o demuxer do ffmpeg.
+        - Silencia logs do ffmpeg.
+        - Valida cada item e mostra metadados antes de concatenar.
+        """
+        if not mp4_list or len(mp4_list) < 2:
+            raise ValueError("Forneça pelo menos dois arquivos MP4 para concatenar.")
+
+        valid_list = []
+        for mp4 in mp4_list:
+            if not os.path.exists(mp4):
+                print(f"⚠️ Arquivo não encontrado: {mp4}")
+                continue
+            info = self._get_video_info(mp4)
+            if info:
+                valid_list.append(mp4)
+
+        if len(valid_list) < 2:
+            raise RuntimeError("Menos de dois vídeos válidos para concatenar.")
+
+        with tempfile.NamedTemporaryFile("w", delete=False, suffix=".txt") as f:
+            for mp4 in valid_list:
+                f.write(f"file '{os.path.abspath(mp4)}'\n")
+            list_path = f.name
+
+        cmd = f"ffmpeg -hide_banner -loglevel warning -y -f concat -safe 0 -i {list_path} -c copy {out_path}"
+        print(f"[DEBUG] Concat: {cmd}")
+
+        try:
+            subprocess.check_call(shlex.split(cmd))
+            print(f"✅ Concatenação concluída: {out_path}")
+            self._get_video_info(out_path)
+        finally:
+            try:
+                os.remove(list_path)
+            except Exception:
+                pass
 
 
+    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.
+        Sanitiza logs e valida cada saída antes de adicioná-la à lista final.
+        """
+        if len(video_paths) < 2:
+            print("⚠️ Lista de vídeos muito curta, nada a mesclar.")
+            return video_paths
+
+        nova_lista = []
+        for i in range(len(video_paths) - 1):
+            v1 = video_paths[i]
+            v2 = video_paths[i + 1]
+            out = os.path.join(pasta, f"transicao_{i+1}.mp4")
+
+            # Comando FFmpeg com crossfade simples (exemplo usando blend)
+            cmd = (
+                f"ffmpeg -hide_banner -loglevel error -y "
+                f"-i {shlex.quote(v1)} -i {shlex.quote(v2)} "
+                f"-filter_complex "
+                f"\"[0:v][1:v]blend=all_expr='A*(1-T/{crossfade_frames})+B*(T/{crossfade_frames})',"
+                f"format=yuv420p\" "
+                f"-an {shlex.quote(out)}"
+            )
+
+            print(f"[DEBUG] Gerando transição {i+1}: {cmd}")
+            try:
+                subprocess.run(shlex.split(cmd), check=True)
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Erro na transição {i+1}: {e}")
+                continue
+
+            # Verifica se o arquivo foi criado
+            if not os.path.exists(out) or os.path.getsize(out) == 0:
+                print(f"⚠️ Transição {i+1} falhou (arquivo vazio ou ausente).")
+                continue
+
+            # Mostra o DNA do vídeo gerado antes de adicioná-lo
+            dna = self._get_video_info(out)
+            if not dna or dna["duração"] == 0:
+                print(f"⚠️ Arquivo corrompido: {out}")
+                continue
+
+            nova_lista.append(out)
+
+        print(f"✅ Nova lista de vídeos pronta: {nova_lista}")
+        return nova_lista
+        
+    def _gerar_lista_com_transicoes1(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.
@@ -530,8 +644,7 @@ class VideoService:
         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):
+    def _concat_mp4s_no_reencode1(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.