Update deformes4D_engine.py

deformes4D_engine.py

@@ -107,15 +107,16 @@ class Deformes4DEngine:
         DEJAVU_FRAME_TARGET = frames_a_podar - 1 if frames_a_podar > 0 else 0
         DESTINATION_FRAME_TARGET = total_frames_brutos - 1
         
+        # [MELHORIA] Centralização de todos os parâmetros da pipeline
         base_ltx_params = {"guidance_scale": 2.0, "stg_scale": 0.025, "rescaling_scale": 0.15, "num_inference_steps": 20, "image_cond_noise_scale": 0.00}
+        refine_ltx_params = {"motion_prompt": "", "guidance_scale": 1.0, "denoise_strength": 0.35, "refine_steps": 12}
+        
         keyframe_paths = [item[0] if isinstance(item, tuple) else item for item in keyframes]
         story_history = ""
         target_resolution_tuple = (video_resolution, video_resolution) 
         
         eco_latent_for_next_loop = None
         dejavu_latent_for_next_loop = None
-        
-        # [CORREÇÃO 1] Inicialização correta da lista
         latent_fragments = []
         
         if len(keyframe_paths) < 2:
@@ -172,11 +173,9 @@ class Deformes4DEngine:
             
             latent_fragments.append(latents_video)
         
-    
-        logger.info("--- CONCATENANDO nem TODOS OS FRAGMENTOS LATENTES ---")
+        logger.info("--- CONCATENANDO FRAGMENTOS LATENTES ---")
         tensors_para_concatenar = []
         for idx, tensor_frag in enumerate(latent_fragments):
-            # Move cada tensor para o dispositivo de destino antes de adicioná-lo à lista.
             target_device = self.device
             tensor_on_target_device = tensor_frag.to(target_device)
             if idx < len(latent_fragments) - 1:
@@ -185,24 +184,16 @@ class Deformes4DEngine:
                 tensors_para_concatenar.append(tensor_on_target_device)
 
         processed_latents = torch.cat(tensors_para_concatenar, dim=2)
-    
-        # [CORREÇÃO 2] Referência correta da variável no log
         logger.info(f"Concatenação concluída. Shape final do tensor latente: {processed_latents.shape}")
         
         if use_refiner:
-            processed_latents = self.refine_latents(
-                processed_latents, 
-                motion_prompt="", 
-                guidance_scale=1.0
-            )
+            # [MELHORIA] A chamada para refinar agora usa o dicionário de parâmetros centralizado
+            processed_latents = self.refine_latents(processed_latents, **refine_ltx_params)
         
-        # --- [INÍCIO DA SEÇÃO CORRIGIDA PARA EXECUÇÃO] ---
         base_name = f"movie_{int(time.time())}"
-        # Define um caminho único para o vídeo que sai desta etapa, antes do HD.
         intermediate_video_path = os.path.join(self.workspace_dir, f"{base_name}_intermediate.mp4")
         
         if use_audio:
-             # A função de áudio agora salva o vídeo com áudio no caminho intermediário
              intermediate_video_path = self._generate_video_and_audio_from_latents(processed_latents, global_prompt, base_name)
         else:
             logger.info("Etapa de sonoplastia desativada. Renderizando vídeo silencioso.")
@@ -212,13 +203,11 @@ class Deformes4DEngine:
         
         del processed_latents; gc.collect(); torch.cuda.empty_cache()
         
-        # Define o caminho final
         final_video_path = os.path.join(self.workspace_dir, f"{base_name}_FINAL.mp4")
         
         if use_hd:
             progress(0.9, desc="Masterização Final (HD)...")
             try:
-                # O HD agora lê o intermediate_video_path e salva no final_video_path
                 hd_specialist_singleton.process_video(
                     input_video_path=intermediate_video_path,
                     output_video_path=final_video_path,
@@ -229,15 +218,12 @@ class Deformes4DEngine:
                 os.rename(intermediate_video_path, final_video_path)
         else:
             logger.info("Etapa de edição HD desativada.")
-            # Se o HD não for usado, o vídeo intermediário se torna o final.
             os.rename(intermediate_video_path, final_video_path)
-        # --- [FIM DA SEÇÃO CORRIGIDA] ---
         
         logger.info(f"Processo concluído! Vídeo final salvo em: {final_video_path}")
         yield {"final_path": final_video_path}
 
     def _generate_video_and_audio_from_latents(self, latent_tensor, audio_prompt, base_name):
-        # Esta função foi movida para cima, mas sua lógica interna permanece a mesma.
         silent_video_path = os.path.join(self.workspace_dir, f"{base_name}_silent_for_audio.mp4")
         pixel_tensor = self.latents_to_pixels(latent_tensor)
         self.save_video_from_tensor(pixel_tensor, silent_video_path, fps=24)
@@ -261,7 +247,9 @@ class Deformes4DEngine:
              os.remove(silent_video_path)
         return video_with_audio_path
         
-    def refine_latents(self, latents: torch.Tensor, fps: int = 24, denoise_strength: float = 0.35, refine_steps: int = 12, motion_prompt: str = "...", **kwargs) -> torch.Tensor:
+    # [MELHORIA] Função de refinamento simplificada e mais robusta
+    def refine_latents(self, latents: torch.Tensor, fps: int = 24, **kwargs) -> torch.Tensor:
+        """Invoca o LTX Pool Manager para refinar um tensor latente existente."""
         logger.info(f"Refinando tensor latente com shape {latents.shape}.")
         _, _, num_latent_frames, latent_h, latent_w = latents.shape
         video_scale_factor = getattr(self.vae.config, 'temporal_scale_factor', 8)
@@ -269,17 +257,22 @@ class Deformes4DEngine:
         
         pixel_height = latent_h * vae_scale_factor
         pixel_width = latent_w * vae_scale_factor
-        pixel_frames = (num_latent_frames - 1) * video_scale_factor
+        # O refinamento opera sobre a duração exata do tensor latente concatenado.
+        pixel_frames = num_latent_frames * video_scale_factor
         
         final_ltx_params = {
             "height": pixel_height, "width": pixel_width, "video_total_frames": pixel_frames,
-            "video_fps": fps, "motion_prompt": motion_prompt, "current_fragment_index": int(time.time()),
-            "denoise_strength": denoise_strength, "refine_steps": refine_steps,
-            "guidance_scale": kwargs.get('guidance_scale', 2.0)
+            "video_fps": fps, "current_fragment_index": int(time.time()),
+            **kwargs  # Passa todos os outros parâmetros (motion_prompt, denoise_strength, refine_steps, etc.)
         }
         
         refined_latents_tensor, _ = self.ltx_manager.refine_latents(latents, **final_ltx_params)
         
+        # [MELHORIA] Adiciona tratamento de falha de memória do refinador
+        if refined_latents_tensor is None:
+            logger.warning("O refinamento falhou (provavelmente por falta de memória). Retornando tensor original não refinado.")
+            return latents
+        
         logger.info(f"Retornando tensor latente refinado com shape: {refined_latents_tensor.shape}")
         return refined_latents_tensor