Rename deformes4D_engine (37).py to deformes4D_engine.py

deformes4D_engine (37).py → deformes4D_engine.py

@@ -23,6 +23,8 @@ import gc
 
 from ltx_manager_helpers import ltx_manager_singleton
 from gemini_helpers import gemini_singleton 
+from upscaler_specialist import upscaler_specialist_singleton
+from ltx_video.models.autoencoders.causal_video_autoencoder import CausalVideoAutoencoder
 from ltx_video.models.autoencoders.vae_encode import vae_encode, vae_decode
 
 logger = logging.getLogger(__name__)
@@ -128,6 +130,49 @@ class Deformes4DEngine:
             logger.error(f"Erro no FFmpeg durante a poda do último frame: {e.stderr}")
             return False
 
+    # --- PIPELINE DE PÓS-PRODUÇÃO LATENTE ---
+    def _render_and_post_process_latents(self, 
+                                     low_res_latents: torch.Tensor, 
+                                     base_name: str,
+                                     conditioning_items_for_refine: list,
+                                     motion_prompt_for_refine: str
+                                    ) -> str:
+        high_res_latents = upscaler_specialist_singleton.upscale(low_res_latents)
+        
+        _, _, _, refined_h_latent, refined_w_latent = high_res_latents.shape
+        video_h = refined_h_latent * self.ltx_manager.workers[0].pipeline.vae_scale_factor
+        video_w = refined_w_latent * self.ltx_manager.workers[0].pipeline.vae_scale_factor
+        num_latent_frames = high_res_latents.shape[2]
+        num_video_frames = num_latent_frames * self.ltx_manager.workers[0].pipeline.video_scale_factor
+        if isinstance(self.vae, CausalVideoAutoencoder):
+            num_video_frames -= 1
+        
+        refine_kwargs = {
+            'height': video_h, 'width': video_w, 'video_total_frames': num_video_frames, 'video_fps': 24,
+            'current_fragment_index': int(time.time()), 'motion_prompt': motion_prompt_for_refine,
+            'conditioning_items_data': conditioning_items_for_refine,
+            'denoise_strength': 0.4, 'refine_steps': 10
+        }
+
+        final_latents, _ = self.ltx_manager.refine_latents(high_res_latents, **refine_kwargs)
+
+        untrimmed_video_path = os.path.join(self.workspace_dir, f"{base_name}_untrimmed.mp4")
+        trimmed_video_path = os.path.join(self.workspace_dir, f"{base_name}.mp4")
+
+        pixel_tensor = self.latents_to_pixels(final_latents)
+        self.save_video_from_tensor(pixel_tensor, untrimmed_video_path, fps=24)
+        del pixel_tensor, final_latents, high_res_latents
+        gc.collect()
+        torch.cuda.empty_cache()
+
+        success = self._trim_last_frame_ffmpeg(untrimmed_video_path, trimmed_video_path)
+        
+        if os.path.exists(untrimmed_video_path):
+            os.remove(untrimmed_video_path)
+        
+        return trimmed_video_path if success else untrimmed_video_path
+        
+
     def _generate_video_from_latents(self, latent_tensor, base_name: str) -> str:
         """
         Gera um vídeo a partir de latentes, podando o último frame para garantir concatenação limpa.
@@ -295,10 +340,21 @@ class Deformes4DEngine:
                 dejavu_latent_for_next_loop = None
 
             # 3.5. Renderização e Armazenamento do Fragmento Final
+            #base_name = f"fragment_{fragment_index}_{int(time.time())}"
+            #video_path = self._generate_video_from_latents(latents_video, base_name)
+            #video_clips_paths.append(video_path)
+            #logger.info(f"--- FRAGMENTO {fragment_index} FINALIZADO E SALVO EM: {video_path} ---")
+
+            # 3.5. Renderização, Pós-Produção e Armazenamento
             base_name = f"fragment_{fragment_index}_{int(time.time())}"
-            video_path = self._generate_video_from_latents(latents_video, base_name)
+            video_path = self._render_and_post_process_latents(
+                low_res_latents=latents_video, base_name=base_name,
+                conditioning_items_for_refine=conditioning_items,
+                motion_prompt_for_refine=motion_prompt)
             video_clips_paths.append(video_path)
             logger.info(f"--- FRAGMENTO {fragment_index} FINALIZADO E SALVO EM: {video_path} ---")
+            
+            
 
             # Bloco de Diagnóstico: Gera um vídeo a partir do tensor do Eco
             if eco_latent_for_next_loop is not None: