Update tools/video_encode_tool.py

tools/video_encode_tool.py

@@ -116,44 +116,71 @@ class VideoEncodeTool:
             raise VideoToolError(f"Falha ao criar vídeo de transição: {e.stderr}")
         return output_path
 
-    def concatenate_videos(self, video_paths: List[str], output_path: str, workspace_dir: str, start:int=0, overlap:int=1) -> str:
+    import os
+import subprocess
+import shutil
+import time
+from typing import List
+import logging
+
+logger = logging.getLogger(__name__)
+
+class VideoToolError(Exception):
+    pass
+
+class VideoEditor:
+    def concatenate_videos(self, video_paths: List[str], output_path: str, workspace_dir: str, start:int= 0, overlap:int=3) -> str:
         """
         Concatena múltiplos vídeos MP4, removendo exatamente o último frame
-        de cada vídeo, exceto o último, usando trim por frame.
+        de cada vídeo (exceto o último), salvando os cortes e recriando a lista a cada execução.
         """
         if not video_paths:
             raise VideoToolError("Nenhum fragmento de vídeo fornecido para concatenação.")
 
+        # Se houver apenas um clipe, apenas copia
         if len(video_paths) == 1:
             shutil.copy(video_paths[0], output_path)
             print(f"[Concat] Apenas um clipe fornecido. Copiado para '{output_path}'.")
             return output_path
 
-        temp_dir = os.path.join(workspace_dir, "temp_trimmed_videos")
-        os.makedirs(temp_dir, exist_ok=True)
+        # Diretório fixo para guardar os recortes
+        trimmed_dir = os.path.join(workspace_dir, "trimmed_parts")
+        os.makedirs(trimmed_dir, exist_ok=True)
+
+        # Remove possíveis restos de execuções anteriores
+        for old in os.listdir(trimmed_dir):
+            try:
+                os.remove(os.path.join(trimmed_dir, old))
+            except Exception:
+                pass
+
         processed_videos = []
 
         try:
             for i, base in enumerate(video_paths):
                 abs_base = os.path.abspath(base)
+                base_name = os.path.basename(abs_base)
+                video_podado = os.path.join(trimmed_dir, f"cut_{i}_{base_name}")
 
-                # Obtém número total de frames via ffprobe
+                # Conta frames via ffprobe
                 probe_cmd = [
-                    'ffprobe', '-v', 'error', '-select_streams', 'v:0',
-                    '-count_frames', '-show_entries', 'stream=nb_read_frames',
-                    '-of', 'default=nokey=1:noprint_wrappers=1', abs_base
+                    "ffprobe", "-v", "error",
+                    "-select_streams", "v:0",
+                    "-count_frames",
+                    "-show_entries", "stream=nb_read_frames",
+                    "-of", "default=nokey=1:noprint_wrappers=1",
+                    abs_base
                 ]
                 result = subprocess.run(probe_cmd, capture_output=True, text=True, check=True)
                 total_frames = int(result.stdout.strip())
-                print(f"[Trim] {os.path.basename(base)} → total_frames={total_frames}")
+                print(f"[Trim] {base_name} → total_frames={total_frames}")
 
-                # Define limites de corte
+                # Calcula range do trim
                 start_frame = start
                 end_frame = total_frames if i == len(video_paths) - 1 else total_frames - overlap
 
-                # Se for o último vídeo, não corta o frame final
                 if i < len(video_paths) - 1:
-                    video_podado = os.path.join(temp_dir, f"cut_{i}.mp4")
+                    # Corta com trim frame-a-frame
                     cmd_fim = (
                         f'ffmpeg -y -hide_banner -loglevel error -i "{abs_base}" '
                         f'-vf "trim=start_frame={start_frame}:end_frame={end_frame},setpts=PTS-STARTPTS" '
@@ -161,41 +188,33 @@ class VideoEncodeTool:
                     )
                     print(f"[CmdTrim] {cmd_fim}")
                     subprocess.run(cmd_fim, shell=True, check=True)
+                    print(f"[TrimOK] {base_name}: corte {end_frame}/{total_frames} frames → {os.path.basename(video_podado)}")
                     processed_videos.append(video_podado)
-                    print(f"[TrimOK] {os.path.basename(base)} → -1 frame ({end_frame}/{total_frames})")
                 else:
                     processed_videos.append(abs_base)
+                    print(f"[Keep] Último vídeo sem corte: {base_name}")
 
-            # Cria lista para concatenação
-            list_file_path = os.path.join(workspace_dir, f"concat_list_{int(time.time())}.txt")
-            with open(list_file_path, 'w', encoding='utf-8') as f:
-                for path in processed_videos:
-                    f.write(f"file '{os.path.abspath(path)}'\n")
+            # Gera lista de concatenação do zero
+            list_file_path = os.path.join(workspace_dir, "concat_list.txt")
+            if os.path.exists(list_file_path):
+                os.remove(list_file_path)
+            with open(list_file_path, "w", encoding="utf-8") as f:
+                for p in processed_videos:
+                    f.write(f"file '{os.path.abspath(p)}'\n")
 
-            # Concat final
+            # Executa concatenação final
             cmd_concat = (
                 f'ffmpeg -y -hide_banner -loglevel error -f concat -safe 0 '
                 f'-i "{list_file_path}" -c copy "{output_path}"'
             )
-            print(f"[Concat] Executando concatenação final: {cmd_concat}")
+            print(f"[Concat] Executando concatenação final:\n{cmd_concat}")
             subprocess.run(cmd_concat, shell=True, check=True)
-            logger.info("[ConcatOK] Concatenação concluída com sucesso.")
+            print("[ConcatOK] Concatenação concluída com sucesso.")
             return output_path
 
         except subprocess.CalledProcessError as e:
             logger.error(f"[ConcatERR] Erro FFmpeg: {e}")
-            raise VideoToolError("Falha durante a concatenação de vídeos.")
-        finally:
-            # Limpa arquivos temporários
-            if os.path.exists(temp_dir):
-                for f in os.listdir(temp_dir):
-                    try:
-                        os.remove(os.path.join(temp_dir, f))
-                    except Exception:
-                        pass
-                os.rmdir(temp_dir)
-            if 'list_file_path' in locals() and os.path.exists(list_file_path):
-                os.remove(list_file_path)
+            raise VideoToolError("Falha durante concatenação de vídeos.")
 
     def concatenate_videos2(self, video_paths: List[str], output_path: str, workspace_dir: str) -> str:
         """