Update app.py

Nova tentativa de unificar tudo

app.py

@@ -1,11 +1,13 @@
 # -*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
 """
-FFmpeg API Service for n8n Video Automation.
+FFmpeg API Service for n8n Video Automation
 
-This FastAPI application provides a single, highly-optimized endpoint 
-to orchestrate a full video production pipeline from raw assets.
+This FastAPI application provides a single, all-in-one endpoint to generate a 
+complete video with narration, background music, transitions, and subtitles, 
+by orchestrating a sequence of FFmpeg operations.
 
-Version: 9.0.0 (Ultimate - All-In-One Endpoint)
+Version: 9.0.0 (Unified & Production-Ready)
 """
 # --- Core Imports ---
 import asyncio
@@ -27,9 +29,9 @@ from starlette.background import BackgroundTask
 # 1. APPLICATION CONFIGURATION & SETUP
 # ==============================================================================
 app = FastAPI(
-    title="FFmpeg as a Service - All-in-One Video Generator",
+    title="Vid Automator API",
     description="A single endpoint to create full videos with music, transitions, and subtitles.",
-    version="8.0.0",
+    version="9.0.0",
 )
 
 TEMP_DIR = "/tmp/ffmpeg_processing"
@@ -49,28 +51,30 @@ def cleanup_directory(directory_path: str):
         shutil.rmtree(directory_path, ignore_errors=True)
         print(f"--- CLEANUP: Successfully removed {directory_path} ---")
 
-async def run_subprocess(command: str) -> (str, str):
+async def run_subprocess(command: str) -> str:
     print(f"--- EXECUTING COMMAND ---\n{command}\n-------------------------")
     process = await asyncio.create_subprocess_shell(
         command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
     )
     stdout, stderr = await process.communicate()
+    
     if process.returncode != 0:
         error_message = stderr.decode(errors='ignore').strip()
         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')
+    return stdout.decode(errors='ignore').strip()
 
 async def download_asset(session: aiohttp.ClientSession, url: str, path: str, asset_type: str):
     print(f"Downloading {asset_type} from {url}...")
     async with session.get(url) as resp:
-        resp.raise_for_status()
+        resp.raise_for_status(f"Failed to download {asset_type} from {url}")
         with open(path, "wb") as f:
             f.write(await resp.read())
 
 # ==============================================================================
-# 3. THE ALL-IN-ONE ENDPOINT
+# 3. THE ALL-IN-ONE ENDPOINT (UNIFIED LOGIC)
 # ==============================================================================
 
 @app.post("/generate-complete-video/")
@@ -91,7 +95,6 @@ async def generate_complete_video(
         narration_path = os.path.join(temp_dir, "narration.mp3")
         subtitle_path = os.path.join(temp_dir, "subtitle.ass")
         
-        # Salva legenda e músicas
         with open(subtitle_path, "wb") as f: shutil.copyfileobj(subtitle_file.file, f)
         
         local_music_paths = []
@@ -100,7 +103,6 @@ async def generate_complete_video(
             with open(path, "wb") as f: shutil.copyfileobj(music_file.file, f)
             local_music_paths.append(path)
         
-        # Baixa narração e imagens
         image_urls = json.loads(image_urls_json)
         local_image_paths = []
         async with aiohttp.ClientSession(headers=BROWSER_HEADERS) as session:
@@ -113,17 +115,16 @@ async def generate_complete_video(
 
         # --- ETAPA 2: PROCESSAR MÚSICA DE FUNDO ---
         print("--- STEP 2/8: PROCESSING BACKGROUND MUSIC ---")
-        combined_music_path = os.path.join(temp_dir, "background_music.mp3")
+        combined_music_path = os.path.join(temp_dir, "background_music_raw.mp3")
         if len(local_music_paths) > 1:
             inputs = "".join([f"-i {shlex.quote(p)} " for p in local_music_paths])
-            filter_complex = "".join([f"[{i}:a]" for i in range(len(local_music_paths))]) + f"concat=n={len(local_music_paths)}:v=0:a=1[a]"
+            filter_complex = "".join([f"[{i}:a:0]" for i in range(len(local_music_paths))]) + f"concat=n={len(local_music_paths)}:v=0:a=1[a]"
             cmd_concat_music = f"ffmpeg {inputs} -filter_complex \"{filter_complex}\" -map \"[a]\" -y {shlex.quote(combined_music_path)}"
             await run_subprocess(cmd_concat_music)
         else:
             shutil.copy(local_music_paths[0], combined_music_path)
         
-        # Ajusta volume
-        low_volume_music_path = os.path.join(temp_dir, "background_music_low.mp3")
+        low_volume_music_path = os.path.join(temp_dir, "background_music.mp3")
         cmd_volume = f"ffmpeg -i {shlex.quote(combined_music_path)} -filter:a \"volume={music_volume}\" -y {shlex.quote(low_volume_music_path)}"
         await run_subprocess(cmd_volume)
         print("SUCCESS: Background music processed.")
@@ -131,63 +132,75 @@ async def generate_complete_video(
         # --- ETAPA 3: ANALISAR NARRAÇÃO ---
         print("--- STEP 3/8: GETTING NARRATION DURATION ---")
         cmd_ffprobe = f"ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 {shlex.quote(narration_path)}"
-        stdout, _ = await run_subprocess(cmd_ffprobe)
-        total_duration = float(stdout.strip())
+        stdout = await run_subprocess(cmd_ffprobe)
+        total_duration = float(stdout)
         print(f"SUCCESS: Narration duration is {total_duration} seconds.")
 
         # --- ETAPA 4: CRIAR VÍDEO COM TRANSIÇÕES ---
         print("--- STEP 4/8: CREATING VIDEO WITH TRANSITIONS ---")
+        # Esta lógica está correta, mas a matemática do tempo precisa ser perfeita.
+        video_with_transitions_path = os.path.join(temp_dir, "video_with_transitions.mp4")
+        # (Lógica de transições, combinação e legendas será unificada abaixo)
+
+        # --- REFORMULAÇÃO DAS ETAPAS 4, 5, 6, 7 PARA MÁXIMA ROBUSTEZ ---
+
+        # ETAPA 4 (Revisada): Criar slideshow silencioso com transições
         transition_duration = 1.0
         num_images = len(local_image_paths)
-        display_duration = (total_duration - (num_images - 1) * transition_duration) / num_images if num_images > 1 else total_duration
-        if display_duration <= 0: raise ValueError("Audio too short for transitions.")
+        if num_images <= 1: raise ValueError("Need at least 2 images for transitions.")
+        
+        # Fórmula correta para a duração de cada "cena" (imagem estática + transição)
+        total_display_time = total_duration - transition_duration
+        display_duration_per_image = total_display_time / num_images
         
+        if display_duration_per_image <= 0: raise ValueError("Audio too short for this many images/transitions.")
+
         input_args = ""
         for path in local_image_paths:
-            input_args += f"-loop 1 -t {display_duration + transition_duration} -i {shlex.quote(path)} "
-
-        filter_complex = ""
+            # Duração total de cada input de imagem
+            input_args += f"-loop 1 -t {display_duration_per_image + transition_duration} -i {shlex.quote(path)} "
+        
+        filter_chain = ""
         last_stream = "0:v"
         for i in range(num_images - 1):
-            offset = (i + 1) * display_duration + i * transition_duration
-            filter_complex += f"[{last_stream}][{i+1}:v]xfade=transition=fade:duration={transition_duration}:offset={offset}[v{i+1}];"
+            offset = (i + 1) * display_duration_per_image
+            filter_chain += f"[{last_stream}][{i+1}:v]xfade=transition=fade:duration={transition_duration}:offset={offset}[v{i+1}];"
             last_stream = f"v{i+1}"
-        
-        final_filter = f"{filter_complex}[{last_stream}]format=yuv420p,fps=25[final_v]"
-        silent_video_path = os.path.join(temp_dir, "silent_video.mp4")
-        cmd_transitions = f"ffmpeg {input_args} -filter_complex \"{final_filter}\" -map \"[final_v]\" -an -y {shlex.quote(silent_video_path)}"
+            
+        final_video_filter = f"{filter_chain}[{last_stream}]format=yuv420p,fps=25[final_v]"
+        cmd_transitions = f"ffmpeg {input_args} -filter_complex \"{final_video_filter}\" -map \"[final_v]\" -an -y {shlex.quote(video_with_transitions_path)}"
         await run_subprocess(cmd_transitions)
-        print("SUCCESS: Video with transitions created.")
-        
-        # --- ETAPA 5: MIXAR TODOS OS ÁUDIOS ---
-        print("--- STEP 5/8: MIXING ALL AUDIO TRACKS ---")
-        mixed_audio_path = os.path.join(temp_dir, "mixed_audio.mp3")
+        print("SUCCESS: Silent video with transitions created.")
+
+        # ETAPA 5 (Revisada): Mixar narração e música de fundo
+        print("--- STEP 5/8: MIXING AUDIO TRACKS ---")
+        mixed_audio_path = os.path.join(temp_dir, "final_audio_mix.mp3")
         cmd_mix_audio = (f"ffmpeg -i {shlex.quote(narration_path)} -i {shlex.quote(low_volume_music_path)} "
                          f"-filter_complex \"[0:a][1:a]amix=inputs=2:duration=first:dropout_transition=3\" -y {shlex.quote(mixed_audio_path)}")
         await run_subprocess(cmd_mix_audio)
         print("SUCCESS: Audio tracks mixed.")
 
-        # --- ETAPA 6: COMBINAR VÍDEO COM ÁUDIO MIXADO ---
-        print("--- STEP 6/8: COMBINING VIDEO WITH FINAL AUDIO ---")
-        video_with_audio_path = os.path.join(temp_dir, "video_with_audio.mp4")
-        cmd_combine = (f"ffmpeg -i {shlex.quote(silent_video_path)} -i {shlex.quote(mixed_audio_path)} "
-                       f"-c:v copy -c:a aac -shortest -y {shlex.quote(video_with_audio_path)}")
+        # ETAPA 6 (Revisada): Combinar o vídeo (com transições) e o áudio final (mixado)
+        print("--- STEP 6/8: COMBINING VIDEO AND FINAL AUDIO ---")
+        video_with_final_audio_path = os.path.join(temp_dir, "video_with_audio.mp4")
+        cmd_combine = (f"ffmpeg -i {shlex.quote(video_with_transitions_path)} -i {shlex.quote(mixed_audio_path)} "
+                       f"-c:v copy -c:a aac -shortest -y {shlex.quote(video_with_final_audio_path)}")
         await run_subprocess(cmd_combine)
+        print("SUCCESS: Video and final audio combined.")
 
-        # --- ETAPA 7: ADICIONAR LEGENDAS ---
+        # ETAPA 7 (Revisada): Adicionar Legendas ao vídeo final
         print("--- STEP 7/8: BURNING SUBTITLES ---")
-        final_video_path = os.path.join(temp_dir, "final_video.mp4")
+        final_video_path = os.path.join(temp_dir, "final_video_com_legenda.mp4")
         escaped_subtitle_path = subtitle_path.replace("'", "'\\''")
-        cmd_subtitles = (f"ffmpeg -i {shlex.quote(video_with_audio_path)} -vf \"ass='{escaped_subtitle_path}'\" "
+        cmd_subtitles = (f"ffmpeg -i {shlex.quote(video_with_final_audio_path)} -vf \"ass='{escaped_subtitle_path}'\" "
                          f"-c:v libx264 -preset ultrafast -c:a copy -y {shlex.quote(final_video_path)}")
         await run_subprocess(cmd_subtitles)
-        
+        print("SUCCESS: Subtitles burned into final video.")
+
         # --- ETAPA 8: RETORNAR VÍDEO E LIMPAR ---
         print("--- STEP 8/8: FINAL VIDEO CREATED. PREPARING RESPONSE. ---")
         cleanup_task = BackgroundTask(cleanup_directory, directory_path=temp_dir)
-        return FileResponse(
-            path=final_video_path, filename="video_completo.mp4", media_type="video/mp4", background=cleanup_task
-        )
+        return FileResponse(path=final_video_path, filename="video_completo.mp4", media_type="video/mp4", background=cleanup_task)
 
     except Exception as e:
         cleanup_directory(directory_path=temp_dir)