Update tools/video_encode_tool.py

tools/video_encode_tool.py

@@ -118,85 +118,99 @@ class VideoEncodeTool:
 
 
 
-    def concatenate_videos(self, video_paths: List[str], output_path: str, workspace_dir: str, 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, star:int=0, overlap:int=1) -> str:
         """
-        Concatena múltiplos clipes de vídeo em um único arquivo,
-        removendo o último frame de cada vídeo exceto o último.
+        Concatena múltiplos vídeos MP4, removendo exatamente o último frame
+        de cada vídeo, exceto o último, usando trim por frame.
         """
         if not video_paths:
             raise VideoToolError("Nenhum fragmento de vídeo fornecido para concatenação.")
 
         if len(video_paths) == 1:
             shutil.copy(video_paths[0], output_path)
-            logger.info(f"Apenas um clipe fornecido. Copiado para '{output_path}'.")
+            logger.info(f"[Concat] Apenas um clipe fornecido. Copiado para '{output_path}'.")
             return output_path
 
-        # Pasta temporária para cortes intermediários
-        temp_dir = os.path.join(workspace_dir, "temp_cut_videos")
+        temp_dir = os.path.join(workspace_dir, "temp_trimmed_videos")
         os.makedirs(temp_dir, exist_ok=True)
-
         processed_videos = []
 
         try:
-            for i, path in enumerate(video_paths):
-                abs_path = os.path.abspath(path)
-                # Verifica o número total de frames usando ffprobe
+            for i, base in enumerate(video_paths):
+                abs_base = os.path.abspath(base)
+
+                # Obtém número total de 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_path
+                    '-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())
+                logger.debug(f"[Trim] {os.path.basename(base)} → total_frames={total_frames}")
+
+                # Define limites de corte
+                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:
-                    # Remove o último frame do vídeo
-                    cut_frames = total_frames - overlap
-                    temp_output = os.path.join(temp_dir, f"cut_{i}.mp4")
-
-                    # Cria uma versão sem o último frame (mantendo codec e fps)
-                    cut_cmd = [
-                        'ffmpeg', '-y', '-i', abs_path,
-                        '-vf', f'select=lt(n\\,{cut_frames})',  # mantém apenas n < total_frames-1
-                        '-vsync', '0', '-c:v', 'libx264', '-preset', 'fast', '-crf', '18',
-                        '-an', temp_output
-                    ]
-                    subprocess.run(cut_cmd, check=True, capture_output=True, text=True)
-                    processed_videos.append(temp_output)
-                    logger.debug(f"Removido último frame do vídeo {i} ({cut_frames}/{total_frames}).")
+                    video_podado = os.path.join(temp_dir, f"cut_{i}.mp4")
+                    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" '
+                        f'-an "{video_podado}"'
+                    )
+                    logger.debug(f"[CmdTrim] {cmd_fim}")
+                    subprocess.run(cmd_fim, shell=True, check=True)
+                    processed_videos.append(video_podado)
+                    logger.debug(f"[TrimOK] {os.path.basename(base)} → -1 frame ({end_frame}/{total_frames})")
                 else:
-                    # Último vídeo permanece intacto
-                    processed_videos.append(abs_path)
+                    processed_videos.append(abs_base)
 
-            # Cria o arquivo de concatenação
+            # 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 p in processed_videos:
-                    f.write(f"file '{os.path.abspath(p)}'\n")
-
-            # Executa concatenação final
-            cmd_list = [
-                'ffmpeg', '-y', '-f', 'concat', '-safe', '0',
-                '-i', list_file_path, '-c', 'copy', output_path
-            ]
-            logger.info(f"Concatenando {len(processed_videos)} clipes em '{output_path}'...")
-            subprocess.run(cmd_list, check=True, capture_output=True, text=True)
-            logger.info("Concatenação FFmpeg bem-sucedida.")
+                for path in processed_videos:
+                    f.write(f"file '{os.path.abspath(path)}'\n")
+
+            # Concat final
+            cmd_concat = (
+                f'ffmpeg -y -hide_banner -loglevel error -f concat -safe 0 '
+                f'-i "{list_file_path}" -c copy "{output_path}"'
+            )
+            logger.info(f"[Concat] Executando concatenação final: {cmd_concat}")
+            subprocess.run(cmd_concat, shell=True, check=True)
+            logger.info("[ConcatOK] Concatenação concluída com sucesso.")
             return output_path
 
         except subprocess.CalledProcessError as e:
-            logger.error(f"Erro ao processar vídeos: {e.stderr}")
-            raise VideoToolError("Falha durante concatenação dos vídeos.")
+            logger.error(f"[ConcatERR] Erro FFmpeg: {e}")
+            raise VideoToolError("Falha durante a concatenação de vídeos.")
         finally:
             # Limpa arquivos temporários
-            for f in os.listdir(temp_dir):
-                os.remove(os.path.join(temp_dir, f))
-            os.rmdir(temp_dir)
-
-            list_file_path = os.path.join(workspace_dir, f"concat_list_{int(time.time())}.txt")
-            if os.path.exists(list_file_path):
+            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)
-                
 
     def concatenate_videos2(self, video_paths: List[str], output_path: str, workspace_dir: str) -> str:
         """