Update app.py

app.py

@@ -5,7 +5,7 @@ FFmpeg API Service for n8n Video Automation.
 This FastAPI application provides a highly optimized, single endpoint 
 to perform all FFmpeg/FFprobe operations for video creation.
 
-Version: 6.2.0 (Final - Corrected Crossfade Syntax)
+Version: 6.2.1 (Final - Including all helper functions)
 """
 # --- Core Imports ---
 import asyncio
@@ -14,12 +14,12 @@ import os
 import shutil
 import shlex
 import uuid
-from typing import List, Dict
+from typing import Dict
 
 # --- Library Imports ---
 import aiohttp
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException, Body
-from fastapi.responses import FileResponse, JSONResponse
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.responses import FileResponse
 from starlette.background import BackgroundTask
 
 # ==============================================================================
@@ -28,7 +28,7 @@ from starlette.background import BackgroundTask
 app = FastAPI(
     title="FFmpeg as a Service for n8n",
     description="A robust API to create full videos with crossfade transitions.",
-    version="6.2.0",
+    version="6.2.1",
 )
 
 TEMP_DIR = "/tmp/ffmpeg_processing"
@@ -47,7 +47,6 @@ async def startup_event():
 def cleanup_directory(directory_path: str):
     """
     Safely removes a directory and its contents after processing.
-    This is critical for preventing disk space exhaustion.
     """
     if os.path.exists(directory_path):
         shutil.rmtree(directory_path, ignore_errors=True)
@@ -56,7 +55,7 @@ def cleanup_directory(directory_path: str):
 async def run_subprocess(command: str) -> (str, str):
     """
     Executes a shell command asynchronously, capturing its output.
-    Raises RuntimeError on failure, providing clear error feedback.
+    Raises RuntimeError on failure.
     """
     print(f"--- EXECUTING COMMAND ---\n{command}\n-------------------------")
     process = await asyncio.create_subprocess_shell(
@@ -68,19 +67,21 @@ async def run_subprocess(command: str) -> (str, str):
     
     if process.returncode != 0:
         error_message = stderr.decode(errors='ignore').strip()
-        print(f"ERROR: Command failed with exit code {process.returncode}.\nStderr: {error_message}")
+        print(f"ERROR: Command failed.\nStderr: {error_message}")
         raise RuntimeError(f"FFmpeg command failed: {error_message}")
     
     print("SUCCESS: Command executed.")
     return stdout.decode(errors='ignore'), stderr.decode(errors='ignore')
 
-# Função auxiliar para download de imagens
-async def download_asset(session: aiohttp.ClientSession, url: str, path: str):
-    """Downloads a single asset (image or audio) from a URL to a local path."""
+# >>>>> FUNÇÃO AUXILIAR QUE ESTAVA FALTANDO <<<<<
+async def download_asset(session: aiohttp.ClientSession, url: str, path: str, asset_type: str = "image"):
+    """
+    Downloads a single asset from a URL to a local path.
+    """
+    print(f"Downloading {asset_type} from {url}...")
     async with session.get(url) as resp:
         if not resp.ok:
-            # Levanta um erro que será capturado pelo try/except principal
-            raise IOError(f"Failed to download asset from {url}, status: {resp.status}")
+            raise IOError(f"Failed to download {asset_type} from {url}, status: {resp.status}")
         with open(path, "wb") as f:
             f.write(await resp.read())
 
@@ -95,9 +96,6 @@ async def create_full_video_with_subtitles_v2(
     subtitle_file: UploadFile = File(...),
     output_filename: str = Form("final_video.mp4")
 ):
-    """
-    Orchestrates the entire video creation process with professional crossfade transitions.
-    """
     unique_id = str(uuid.uuid4())
     temp_processing_dir = os.path.join(TEMP_DIR, unique_id)
     os.makedirs(temp_processing_dir)
@@ -110,21 +108,18 @@ async def create_full_video_with_subtitles_v2(
         print("--- STEP 1/6: ACQUIRING ASSETS ---")
         with open(subtitle_path, "wb") as buffer:
             shutil.copyfileobj(subtitle_file.file, buffer)
+        print("SUCCESS: Subtitle file saved.")
         
         image_urls = json.loads(image_urls_json)
         local_image_paths = []
         
         async with aiohttp.ClientSession(headers=BROWSER_HEADERS) as session:
-            # Baixa áudio
-            await download_asset(session, audio_url, audio_path)
-            print("SUCCESS: Audio downloaded.")
-
-            # Baixa imagens
+            await download_asset(session, audio_url, audio_path, "audio")
             for i, url in enumerate(image_urls):
                 local_path = os.path.join(temp_processing_dir, f"image_{i:02d}.jpg")
                 await download_asset(session, url, local_path)
                 local_image_paths.append(local_path)
-            print(f"SUCCESS: {len(local_image_paths)} images downloaded.")
+        print(f"SUCCESS: All assets acquired.")
 
         # ETAPA 2: Obter Duração do Áudio
         print("--- STEP 2/6: GETTING AUDIO DURATION ---")
@@ -145,33 +140,43 @@ async def create_full_video_with_subtitles_v2(
 
         input_args = ""
         for path in local_image_paths:
+            # -t agora define a duração de cada input de imagem, que é a duração por imagem
             input_args += f"-loop 1 -t {image_duration} -i {shlex.quote(path)} "
 
         filter_complex_chain = ""
         last_stream = "0:v"
-        offset = image_duration - transition_duration
-
+        
+        # >>>>> CORREÇÃO PRINCIPAL AQUI <<<<<
+        # O offset agora é CUMULATIVO.
         for i in range(num_images - 1):
             next_stream_idx = i + 1
             output_stream_name = f"v{next_stream_idx}"
+            
+            # O offset aumenta a cada iteração
+            # Offset da transição 1: (1 * image_duration) - transition_duration
+            # Offset da transição 2: (2 * image_duration) - (2 * transition_duration) ... etc
+            # Uma forma mais simples é calcular o offset com base no tempo de início da imagem
+            offset = i * (image_duration - transition_duration) + (image_duration - transition_duration)
+
             filter_part = f"[{last_stream}][{next_stream_idx}:v]xfade=transition=fade:duration={transition_duration}:offset={offset}[{output_stream_name}];"
             filter_complex_chain += filter_part
             last_stream = output_stream_name
 
         silent_video_path = os.path.join(temp_processing_dir, "silent_video_with_transitions.mp4")
         
-        # Correção final e crucial da sintaxe do filter_complex
+        # A sintaxe do filtro final permanece a mesma, agora alimentada pela cadeia correta
         final_filter_chain = f"{filter_complex_chain}[{last_stream}]format=yuv420p,fps=25[final_v]"
 
         cmd_video_transitions = (
             f"ffmpeg {input_args} "
             f"-filter_complex \"{final_filter_chain}\" "
-            f"-map \"[final_v]\" -y {shlex.quote(silent_video_path)}"
+            f"-map \"[final_v]\" -an -y {shlex.quote(silent_video_path)}" # -an para garantir que não há áudio
         )
         
         await run_subprocess(cmd_video_transitions)
         print("SUCCESS: Video with transitions created.")
         
+        # O resto do fluxo continua como antes...
         # ETAPA 4: Combinar com áudio
         print("--- STEP 4/6: COMBINING WITH AUDIO ---")
         video_with_audio_path = os.path.join(temp_processing_dir, "video_with_audio.mp4")
@@ -193,7 +198,6 @@ async def create_full_video_with_subtitles_v2(
         await run_subprocess(cmd_subtitles)
         print("--- STEP 6/6: FINAL VIDEO CREATED SUCCESSFULLY ---")
 
-        # ETAPA FINAL: Retorno e Limpeza
         cleanup_task = BackgroundTask(cleanup_directory, directory_path=temp_processing_dir)
         return FileResponse(
             path=final_output_path,