Update deformes4D_engine.py

deformes4D_engine.py

@@ -103,9 +103,22 @@ class Deformes4DEngine:
         DESTINATION_FRAME_TARGET = total_frames_brutos - 1
         
         base_ltx_params = {"guidance_scale": 2.0, "stg_scale": 0.025, "rescaling_scale": 0.15, "num_inference_steps": 20}
-        keyframe_paths = [item if isinstance(item, str) else item.name for item in keyframes]
-        story_history = ""
         
+        # --- [INÍCIO DA CORREÇÃO] ---
+        # Lógica robusta para extrair caminhos de arquivo da lista de keyframes.
+        keyframe_paths = []
+        for item in keyframes:
+            if isinstance(item, str):
+                keyframe_paths.append(item)
+            elif isinstance(item, tuple) and len(item) > 0:
+                keyframe_paths.append(item[0]) # Assume que o caminho está no primeiro elemento da tupla
+            elif hasattr(item, 'name'):
+                keyframe_paths.append(item.name)
+            else:
+                logger.warning(f"Item na lista de keyframes com tipo inesperado e sem atributo '.name': {type(item)}")
+        # --- [FIM DA CORREÇÃO] ---
+
+        story_history = ""
         eco_latent_for_next_loop = None
         dejavu_latent_for_next_loop = None
         raw_latent_fragments = []
@@ -154,17 +167,9 @@ class Deformes4DEngine:
             if transition_type == "cut":
                 eco_latent_for_next_loop, dejavu_latent_for_next_loop = None, None
 
-            if use_upscaler:
-                logger.info(f"fragmento {i+1} original: {latents_video.shape}")
-                latents_video = self.upscale_latents(latents_video)
-                logger.info(f"fragmento {i+1} upscaler: {latents_video.shape}")
-
-            else:
-                logger.info("Etapa de upscaler desativada.")
-            
-            logger.info(f"fragmento {i+1} adinado a lista global")
             raw_latent_fragments.append(latents_video)
         
+        # --- ATO II: PÓS-PRODUÇÃO LATENTE GLOBAL (CONDICIONAL) ---
         current_step += 1
         progress(current_step / TOTAL_STEPS, desc="Unificação Causal (Concatenação)...")
         tensors_on_main_device = [frag.to(self.device) for frag in raw_latent_fragments]
@@ -183,15 +188,37 @@ class Deformes4DEngine:
         else:
             logger.info("Etapa de refinamento desativada.")
 
-        if use_audio:
-            logger.warning("Geração de áudio solicitada, mas está desativada nesta versão do código.")
-        else:
-            logger.info("Etapa de sonoplastia desativada.")
+        # --- ATO III: RENDERIZAÇÃO E FINALIZAÇÃO ---
+        base_name = f"movie_{int(time.time())}"
+        current_step += 1
+        progress(current_step / TOTAL_STEPS, desc="Renderização (em lotes)...")
+        intermediate_video_path = os.path.join(self.workspace_dir, f"{base_name}_intermediate.mp4")
+
+        with imageio.get_writer(intermediate_video_path, fps=FPS, codec='libx264', quality=8, output_params=['-pix_fmt', 'yuv420p']) as writer:
+            chunk_size = 15 if use_upscaler else 30
+            latent_chunks = torch.split(processed_latents, chunk_size, dim=2)
             
-    
+            for i, latent_chunk in enumerate(latent_chunks):
+                logger.info(f"Processando e renderizando lote {i+1}/{len(latent_chunks)}...")
+                
+                processed_chunk = self.upscale_latents(latent_chunk) if use_upscaler else latent_chunk
+                pixel_tensor_chunk = self.latents_to_pixels(processed_chunk)
+                
+                pixel_tensor_chunk = pixel_tensor_chunk.squeeze(0).permute(1, 2, 3, 0)
+                pixel_tensor_chunk = (pixel_tensor_chunk.clamp(-1, 1) + 1) / 2.0
+                video_np_chunk = (pixel_tensor_chunk.detach().cpu().float().numpy() * 255).astype(np.uint8)
+                
+                for frame in video_np_chunk:
+                    writer.append_data(frame)
+                
+                del latent_chunk, processed_chunk, pixel_tensor_chunk, video_np_chunk
+                gc.collect()
+                torch.cuda.empty_cache()
+
+        del processed_latents; gc.collect(); torch.cuda.empty_cache()
+        logger.info(f"Vídeo intermediário renderizado em: {intermediate_video_path}")
+
         final_video_path = os.path.join(self.workspace_dir, f"{base_name}_FINAL.mp4")
-        final_pixel_tensor = self.latents_to_pixels(final_concatenated_latents)
-        self.save_video_from_tensor(processed_latents, final_video_path, fps=24)
         
         if use_hd:
             current_step += 1
@@ -209,7 +236,9 @@ class Deformes4DEngine:
             logger.info("Etapa de masterização HD desativada.")
             os.rename(intermediate_video_path, final_video_path)
 
-        
+        if use_audio:
+            logger.warning("Geração de áudio solicitada, mas está desativada nesta versão do código.")
+
         logger.info(f"Processo concluído! Vídeo final salvo em: {final_video_path}")
         yield {"final_path": final_video_path}