Update deformes4D_engine.py

deformes4D_engine.py

@@ -69,6 +69,14 @@ class Deformes4DEngine:
         timestep_tensor = torch.tensor([decode_timestep] * latent_tensor.shape[0], device=self.device, dtype=latent_tensor.dtype)
         return vae_decode(latent_tensor, self.vae, is_video=True, timestep=timestep_tensor, vae_per_channel_normalize=True)
 
+    def save_video_from_tensor(self, video_tensor: torch.Tensor, path: str, fps: int = 24):
+        if video_tensor is None or video_tensor.ndim != 5 or video_tensor.shape[2] == 0: return
+        video_tensor = video_tensor.squeeze(0).permute(1, 2, 3, 0)
+        video_tensor = (video_tensor.clamp(-1, 1) + 1) / 2.0
+        video_np = (video_tensor.detach().cpu().float().numpy() * 255).astype(np.uint8)
+        with imageio.get_writer(path, fps=fps, codec='libx264', quality=8, output_params=['-pix_fmt', 'yuv420p']) as writer:
+            for frame in video_np: writer.append_data(frame)
+
     def _preprocess_image_for_latent_conversion(self, image: Image.Image, target_resolution: tuple) -> Image.Image:
         if image.size != target_resolution:
             return ImageOps.fit(image, target_resolution, Image.Resampling.LANCZOS)
@@ -80,63 +88,45 @@ class Deformes4DEngine:
         tensor = (tensor * 2.0) - 1.0
         return self.pixels_to_latents(tensor)
         
-
     # --- NÚCLEO DA LÓGICA ADUC-SDR ---
-    def generate_full_movie_old(self, keyframes: list, global_prompt: str, storyboard: list, 
+    def generate_full_movie(self, keyframes: list, global_prompt: str, storyboard: list, 
                             seconds_per_fragment: float, trim_percent: int,
                             handler_strength: float, destination_convergence_strength: float, 
                             use_upscaler: bool, use_refiner: bool, use_hd: bool, use_audio: bool,
                             video_resolution: int, use_continuity_director: bool, 
                             progress: gr.Progress = gr.Progress()):
         
-        # 1. Definição dos Parâmetros da Geração com base na Tese
         FPS = 24
         FRAMES_PER_LATENT_CHUNK = 8
         ECO_LATENT_CHUNKS = 2
         
         total_frames_brutos = self._quantize_to_multiple(int(seconds_per_fragment * FPS), FRAMES_PER_LATENT_CHUNK)
-        total_latents_brutos = total_frames_brutos // FRAMES_PER_LATENT_CHUNK
-
         frames_a_podar = self._quantize_to_multiple(int(total_frames_brutos * (trim_percent / 100)), FRAMES_PER_LATENT_CHUNK)
         latents_a_podar = frames_a_podar // FRAMES_PER_LATENT_CHUNK
 
-        if total_latents_brutos <= latents_a_podar:
-            raise gr.Error(f"A porcentagem de poda ({trim_percent}%) é muito alta. Reduza-a ou aumente a duração.")
-
-        DEJAVU_FRAME_TARGET = frames_a_podar - 1
+        DEJAVU_FRAME_TARGET = frames_a_podar - 1 if frames_a_podar > 0 else 0
         DESTINATION_FRAME_TARGET = total_frames_brutos - 1
         
-        logger.info("--- CONFIGURAÇÃO DA GERAÇÃO ADUC-SDR ---")
-        logger.info(f"Total de Latents por Geração Exploratória (V_bruto): {total_latents_brutos} ({total_frames_brutos} frames)")
-        logger.info(f"Latents a serem descartados (Poda Causal): {latents_a_podar} ({frames_a_podar} frames)")
-        logger.info(f"Chunks Latentes do Eco Causal (C): {ECO_LATENT_CHUNKS}")
-        logger.info(f"Frame alvo do Déjà-Vu (D): {DEJAVU_FRAME_TARGET}")
-        logger.info(f"Frame alvo do Destino (K): {DESTINATION_FRAME_TARGET}")
-        logger.info("------------------------------------------")
-
-        # 2. Inicialização do Estado
         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}
         keyframe_paths = [item[0] if isinstance(item, tuple) else item for item in keyframes]
-        video_clips_paths, story_history = [], ""
+        story_history = ""
         target_resolution_tuple = (video_resolution, video_resolution) 
         
         eco_latent_for_next_loop = None
         dejavu_latent_for_next_loop = None
         
-        latent_fragments[]
+        # [CORREÇÃO 1] Inicialização correta da lista
+        latent_fragments = []
         
         if len(keyframe_paths) < 2:
             raise gr.Error(f"A geração requer no mínimo 2 keyframes. Você forneceu {len(keyframe_paths)}.")
         
         num_transitions_to_generate = len(keyframe_paths) - 1
         
-        # 3. Loop Principal de Geração de Fragmentos
         for i in range(num_transitions_to_generate):
             fragment_index = i + 1
-            logger.info(f"--- INICIANDO FRAGMENTO {fragment_index}/{num_transitions_to_generate} ---")
-            progress(fragment_index / num_transitions_to_generate, desc=f"Produzindo Transição {fragment_index}/{num_transitions_to_generate}")
+            progress(i / num_transitions_to_generate, desc=f"Produzindo Transição {fragment_index}/{num_transitions_to_generate}")
             
-            # 3.1. Consulta ao Maestro (Γ) para obter a intenção (Pᵢ)
             past_keyframe_path = keyframe_paths[i - 1] if i > 0 else keyframe_paths[i]
             start_keyframe_path = keyframe_paths[i]
             destination_keyframe_path = keyframe_paths[i + 1]
@@ -149,32 +139,19 @@ class Deformes4DEngine:
             transition_type, motion_prompt = decision["transition_type"], decision["motion_prompt"]
             story_history += f"\n- Ato {fragment_index}: {motion_prompt}"
 
-            # 3.2. Montagem das Âncoras para a Fórmula Canônica Ψ({C, D, K}, P)
             conditioning_items = []
-            logger.info("  [Ψ.1] Montando âncoras causais...")
-            
             if eco_latent_for_next_loop is None:
-               logger.info("    - Primeiro fragmento: Usando Keyframe inicial como âncora de partida.")
                img_start = self._preprocess_image_for_latent_conversion(Image.open(start_keyframe_path).convert("RGB"), target_resolution_tuple)
                conditioning_items.append(LatentConditioningItem(self.pil_to_latent(img_start), 0, 1.0))
             else:
-               logger.info("    - Âncora 1: Eco Causal (C) - Herança do passado.")
                conditioning_items.append(LatentConditioningItem(eco_latent_for_next_loop, 0, 1.0))
-               logger.info("    - Âncora 2: Déjà-Vu (D) - Memória de um futuro idealizado.")
                conditioning_items.append(LatentConditioningItem(dejavu_latent_for_next_loop, DEJAVU_FRAME_TARGET, handler_strength))
             
-            logger.info("    - Âncora 3: Destino (K) - Âncora geométrica/narrativa.")
             img_dest = self._preprocess_image_for_latent_conversion(Image.open(destination_keyframe_path).convert("RGB"), target_resolution_tuple)
             conditioning_items.append(LatentConditioningItem(self.pil_to_latent(img_dest), DESTINATION_FRAME_TARGET, destination_convergence_strength))
 
-            # 3.3. Execução da Câmera (Ψ): Geração Exploratória para criar V_bruto
-            logger.info(f"  [Ψ.2] Câmera (Ψ) executando a geração exploratória de {total_latents_brutos} chunks latentes...")
             current_ltx_params = {**base_ltx_params, "motion_prompt": motion_prompt}
             latents_brutos = self._generate_latent_tensor_internal(conditioning_items, current_ltx_params, target_resolution_tuple, total_frames_brutos)
-            logger.info(f"    - Geração concluída. Tensor latente bruto (V_bruto) criado com shape: {latents_brutos.shape}.")
-
-            # 3.4. Execução do Destilador (Δ): Implementação do Ciclo de Poda Causal (com workaround empírico)
-            logger.info(f"  [Δ] Destilador (Δ) executando o Ciclo de Poda Causal...")
 
             last_trim = latents_brutos[:, :, -(latents_a_podar+1):, :, :].clone()
             eco_latent_for_next_loop = last_trim[:, :, :2, :, :].clone()   
@@ -183,12 +160,7 @@ class Deformes4DEngine:
             latents_video = latents_brutos[:, :, :-(latents_a_podar-1), :, :].clone()
             latents_video = latents_video[:, :, 1:, :, :]
 
-            logger.info(f"  [Δ] latents_video {latents_video.shape}")
-            logger.info(f"    - (Δ.1) Déjà-Vu (D) destilado. Shape: {dejavu_latent_for_next_loop.shape}")
-            logger.info(f"    - (Δ.2) Eco Causal (C) extraído. Shape: {eco_latent_for_next_loop.shape}")
-
             if transition_type == "cut":
-                logger.warning("  - DECISÃO DO MAESTRO: Corte ('cut'). Resetando a memória causal (Eco e Déjà-Vu).")
                 eco_latent_for_next_loop = None
                 dejavu_latent_for_next_loop = None
 
@@ -197,69 +169,62 @@ class Deformes4DEngine:
             
             latent_fragments.append(latents_video)
         
-        current_step += 1
-        progress(current_step / TOTAL_STEPS, desc="Unificação Causal (Concatenação)...")
-        
         logger.info("--- CONCATENANDO TODOS OS 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:
-                tensors_para_concatenar.append(tensor_on_target_device[:, :, :-1, :, :]) 
-            else:
-                tensors_para_concatenar.append(tensor_on_target_device)
-
+        tensors_para_concatenar = [frag.to(self.device) for frag in latent_fragments]
         processed_latents = torch.cat(tensors_para_concatenar, dim=2)
-        logger.info(f"Concatenação concluída. Shape final do tensor latente: {final_concatenated_latents.shape}")
+        # [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:
-            current_step += 1
-            progress(current_step / TOTAL_STEPS, desc="Polimento Global (Denoise)...")
             processed_latents = self.refine_latents(
                 processed_latents, 
                 motion_prompt="", 
                 guidance_scale=1.0
             )
-            logger.info(f"Polimento global aplicado. Shape: {processed_latents.shape}")
-        else:
-            logger.info("Etapa de refinamento desativada.")
-
         
+        # --- [INÍCIO DA SEÇÃO CORRIGIDA PARA EXECUÇÃO] ---
         base_name = f"movie_{int(time.time())}"
-        current_step += 1
-        progress(current_step / TOTAL_STEPS, desc="Renderização (em lotes)...")
+        # 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:
-             video_path = self._generate_video_and_audio_from_latents(processed_latents, global_prompt, base_name)
+             # 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:
-            video_path = os.path.join(self.workspace_dir, f"{base_name}_silent.mp4")
-            logger.info("Etapa de sonoplastia desativada.")
+            logger.info("Etapa de sonoplastia desativada. Renderizando vídeo silencioso.")
             pixel_tensor = self.latents_to_pixels(processed_latents)
-            self.save_video_from_tensor(pixel_tensor, video_path, fps=24)
+            self.save_video_from_tensor(pixel_tensor, intermediate_video_path, fps=24)
+            del pixel_tensor
+        
+        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:
-            current_step += 1
-            progress(current_step / TOTAL_STEPS, desc="Masterização Final (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=video_path,
-                    output_video_path=video_path,
+                    input_video_path=intermediate_video_path,
+                    output_video_path=final_video_path,
                     prompt=" "
                 )
             except Exception as e:
                 logger.error(f"Falha na masterização HD: {e}. Usando vídeo de qualidade padrão.")
+                os.rename(intermediate_video_path, final_video_path)
         else:
-            logger.info("Etapa de edicao HD desativada.")
-            
+            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: {video_path}")
-        yield {"final_path": video_path}
-
+        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):
-        silent_video_path = os.path.join(self.workspace_dir, f"{base_name}_silent.mp4")
+        # 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)
         del pixel_tensor; gc.collect()
@@ -270,7 +235,7 @@ class Deformes4DEngine:
                 capture_output=True, text=True, check=True)
             frag_duration = float(result.stdout.strip())
         except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
-             logger.warning(f"ffprobe falhou em {os.path.basename(silent_video_path)}. Calculando duração manualmente.")
+             logger.warning(f"ffprobe falhou. Calculando duração manualmente.")
              num_pixel_frames = latent_tensor.shape[2] * 8
              frag_duration = num_pixel_frames / 24.0
 
@@ -282,7 +247,6 @@ 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:
         logger.info(f"Refinando tensor latente com shape {latents.shape}.")
         _, _, num_latent_frames, latent_h, latent_w = latents.shape
@@ -319,7 +283,6 @@ class Deformes4DEngine:
         gc.collect()
         torch.cuda.empty_cache()
         return new_full_latents
-
         
     def _quantize_to_multiple(self, n, m):
         if m == 0: return n