Update deformes4D_engine.py

deformes4D_engine.py

@@ -21,8 +21,7 @@ import gradio as gr
 import subprocess
 import gc
 
-
-from audio_specialist import audio_specialist_singleton
+# Importações de especialistas, com o de áudio removido
 from ltx_manager_helpers import ltx_manager_singleton
 from gemini_helpers import gemini_singleton 
 from upscaler_specialist import upscaler_specialist_singleton
@@ -60,26 +59,10 @@ class Deformes4DEngine:
 
     # --- MÉTODOS AUXILIARES ---
 
-    def _extract_audio_ffmpeg(self, video_path: str, output_audio_path: str) -> str | None:
-        """Extrai a trilha sonora de um vídeo para uso posterior."""
-        if not os.path.exists(video_path): return None
-        cmd = ['ffmpeg', '-y', '-i', video_path, '-vn', '-acodec', 'copy', output_audio_path]
-        try:
-            subprocess.run(cmd, check=True, capture_output=True, text=True, encoding='utf-8')
-            logger.info(f"Áudio extraído com sucesso para {output_audio_path}")
-            return output_audio_path
-        except subprocess.CalledProcessError:
-            logger.warning(f"Não foi possível extrair o áudio de {os.path.basename(video_path)}. O vídeo pode ser silencioso.")
-            return None
-
-    def _combine_video_and_audio_ffmpeg(self, video_path: str, audio_path: str, output_path: str):
-        """Combina um vídeo (sem som) com um arquivo de áudio."""
-        cmd = ['ffmpeg', '-y', '-i', video_path, '-i', audio_path, '-c:v', 'copy', '-c:a', 'aac', '-shortest', output_path]
-        try:
-            subprocess.run(cmd, check=True, capture_output=True, text=True, encoding='utf-8')
-            logger.info(f"Áudio e vídeo combinados com sucesso em {output_path}")
-        except subprocess.CalledProcessError as e:
-            raise gr.Error(f"Falha ao combinar áudio e vídeo: {e.stderr}")
+    @torch.no_grad()
+    def pixels_to_latents(self, tensor: torch.Tensor) -> torch.Tensor:
+        tensor = tensor.to(self.device, dtype=self.vae.dtype)
+        return vae_encode(tensor, self.vae, vae_per_channel_normalize=True)
 
     @torch.no_grad()
     def latents_to_pixels(self, latent_tensor: torch.Tensor, decode_timestep: float = 0.05) -> torch.Tensor:
@@ -98,11 +81,6 @@ class Deformes4DEngine:
         tensor = (tensor * 2.0) - 1.0
         return self.pixels_to_latents(tensor)
     
-    @torch.no_grad()
-    def pixels_to_latents(self, tensor: torch.Tensor) -> torch.Tensor:
-        tensor = tensor.to(self.device, dtype=self.vae.dtype)
-        return vae_encode(tensor, self.vae, vae_per_channel_normalize=True)
-
     # --- NÚCLEO DA LÓGICA ADUC-SDR ---
     def generate_full_movie(self, keyframes: list, global_prompt: str, storyboard: list, 
                             seconds_per_fragment: float, trim_percent: int,
@@ -111,7 +89,7 @@ class Deformes4DEngine:
                             progress: gr.Progress = gr.Progress()):
         
         num_transitions_to_generate = len(keyframes) - 1
-        TOTAL_STEPS = num_transitions_to_generate + 4 # Fragmentos + etapas de pós-produção
+        TOTAL_STEPS = num_transitions_to_generate + 3 # Fragmentos + Renderização + HD
         current_step = 0
         
         FPS = 24
@@ -211,10 +189,11 @@ class Deformes4DEngine:
         gc.collect()
         torch.cuda.empty_cache()
 
-        # --- ATO II:  FINAL (HD) ---
-        
+        # --- ATO III: MASTERIZAÇÃO FINAL (APENAS HD) ---
+        current_step += 1
         progress(current_step / TOTAL_STEPS, desc="Aprimoramento final (HD)...")
         hq_silent_video_path = os.path.join(self.workspace_dir, f"{base_name}_hq_silent.mp4")
+        
         try:
             hd_specialist_singleton.process_video(
                 input_video_path=refined_silent_video_path,
@@ -226,12 +205,12 @@ class Deformes4DEngine:
             os.rename(refined_silent_video_path, hq_silent_video_path)
 
         current_step += 1
-        progress(current_step / TOTAL_STEPS, desc="Finalizando montagem...")
+        progress(current_step / TOTAL_STEPS, desc="Finalizando...")
         final_video_path = os.path.join(self.workspace_dir, f"{base_name}_FINAL.mp4")
-        
-        
-        logger.info(f"Processo concluído! Vídeo final salvo em: {hq_silent_video_path}")
-        yield {"final_path": hq_silent_video_path}
+        os.rename(hq_silent_video_path, final_video_path)
+
+        logger.info(f"Processo concluído! Vídeo final (silencioso) salvo em: {final_video_path}")
+        yield {"final_path": final_video_path}
 
     def refine_latents(self, latents: torch.Tensor,
                        fps: int = 24,
@@ -240,7 +219,6 @@ class Deformes4DEngine:
                        motion_prompt: str = "refining video, improving details, cinematic quality") -> torch.Tensor:
         """
         Aplica um passe de refinamento (denoise) em um tensor latente.
-        [CORRIGIDO] Calcula os frames de pixel de forma a alinhar com a lógica do VAE causal.
         """
         logger.info(f"Refinando tensor latente com shape {latents.shape} para refinamento.")
         
@@ -251,8 +229,6 @@ class Deformes4DEngine:
         
         pixel_height = latent_h * vae_scale_factor
         pixel_width = latent_w * vae_scale_factor
-        
-        # A fórmula inversa para o VAE causal: (N_latente - 1) * FatorDeEscala
         pixel_frames = (num_latent_frames - 1) * video_scale_factor
         
         refined_latents_tensor, _ = self.ltx_manager.refine_latents(