Update deformes4D_engine.py

deformes4D_engine.py

@@ -27,6 +27,7 @@ from upscaler_specialist import upscaler_specialist_singleton
 from hd_specialist import hd_specialist_singleton
 from ltx_video.models.autoencoders.causal_video_autoencoder import CausalVideoAutoencoder
 from ltx_video.models.autoencoders.vae_encode import vae_encode, vae_decode
+from audio_specialist import audio_specialist_singleton
 
 logger = logging.getLogger(__name__)
 
@@ -78,104 +79,141 @@ class Deformes4DEngine:
         tensor = torch.from_numpy(image_np).permute(2, 0, 1).unsqueeze(0).unsqueeze(2)
         tensor = (tensor * 2.0) - 1.0
         return self.pixels_to_latents(tensor)
-    
+        
+
     # --- NÚCLEO DA LÓGICA ADUC-SDR ---
-    def generate_full_movie(self, keyframes: list, global_prompt: str, storyboard: list, 
+    def generate_full_movie_old(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()):
         
-        num_transitions_to_generate = len(keyframes) - 1
-        TOTAL_STEPS = num_transitions_to_generate + 4
-        current_step = 0
-        
+        # 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
 
-        DEJAVU_FRAME_TARGET = frames_a_podar - 1 if frames_a_podar > 0 else 0
+        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
         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}
-        
-        # --- [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] ---
+        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("------------------------------------------")
 
-        story_history = ""
+        # 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 = [], ""
+        target_resolution_tuple = (video_resolution, video_resolution) 
+        
         eco_latent_for_next_loop = None
         dejavu_latent_for_next_loop = None
-        raw_latent_fragments = []
-
-        # --- ATO I: GERAÇÃO CAUSAL PURA (LOOP DE FRAGMENTOS) ---
+        
+        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
-            current_step += 1
-            progress(current_step / TOTAL_STEPS, desc=f"Gerando Fragmento Causal {fragment_index}/{num_transitions_to_generate}")
+            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}")
             
+            # 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]
             future_story_prompt = storyboard[i + 1] if (i + 1) < len(storyboard) else "A cena final."
+            
             decision = gemini_singleton.get_cinematic_decision(
                 global_prompt, story_history, past_keyframe_path, start_keyframe_path, destination_keyframe_path,
-                storyboard[i - 1] if i > 0 else "O início.", storyboard[i], future_story_prompt)
+                storyboard[i - 1] if i > 0 else "O início.", storyboard[i], future_story_prompt
+            )
             transition_type, motion_prompt = decision["transition_type"], decision["motion_prompt"]
             story_history += f"\n- Ato {fragment_index}: {motion_prompt}"
 
-            expected_height, expected_width = video_resolution, video_resolution
-            downscale_factor = 2 / 3
-            downscaled_height = self._quantize_to_multiple(int(expected_height * downscale_factor), 8)
-            downscaled_width = self._quantize_to_multiple(int(expected_width * downscale_factor), 8)
-            target_resolution_tuple = (downscaled_height, downscaled_width)
-            
+            # 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)
-            
+            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[:, :, :ECO_LATENT_CHUNKS, :, :].clone()   
+            eco_latent_for_next_loop = last_trim[:, :, :2, :, :].clone()   
             dejavu_latent_for_next_loop = last_trim[:, :, -1:, :, :].clone()
+            
             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":
-                eco_latent_for_next_loop, dejavu_latent_for_next_loop = None, None
+                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
 
-            raw_latent_fragments.append(latents_video)
+            if use_upscaler:
+                latents_video = self.upscale_latents(latents_video)
+            
+            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]
-        processed_latents = torch.cat(tensors_on_main_device, dim=2)
-        del raw_latent_fragments, tensors_on_main_device; gc.collect(); torch.cuda.empty_cache()
+        
+        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)
 
+        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}")
+        
         if use_refiner:
             current_step += 1
             progress(current_step / TOTAL_STEPS, desc="Polimento Global (Denoise)...")
@@ -188,60 +226,63 @@ class Deformes4DEngine:
         else:
             logger.info("Etapa de refinamento 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")
+        
+        if use_audio:
+             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.")
+            pixel_tensor = self.latents_to_pixels(processed_latents)
+            self.save_video_from_tensor(pixel_tensor, video_path, fps=24)
         
         if use_hd:
             current_step += 1
             progress(current_step / TOTAL_STEPS, desc="Masterização Final (HD)...")
             try:
                 hd_specialist_singleton.process_video(
-                    input_video_path=intermediate_video_path,
-                    output_video_path=final_video_path,
-                    prompt=global_prompt
+                    input_video_path=video_path,
+                    output_video_path=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 masterização HD desativada.")
-            os.rename(intermediate_video_path, final_video_path)
+            logger.info("Etapa de edicao HD desativada.")
+            
+        
+        logger.info(f"Processo concluído! Vídeo final salvo em: {video_path}")
+        yield {"final_path": 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}
+    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")
+        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()
+        
+        try:
+            result = subprocess.run(
+                ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", silent_video_path],
+                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.")
+             num_pixel_frames = latent_tensor.shape[2] * 8
+             frag_duration = num_pixel_frames / 24.0
 
+        video_with_audio_path = audio_specialist_singleton.generate_audio_for_video(
+            video_path=silent_video_path, prompt=audio_prompt,
+            duration_seconds=frag_duration)
+        
+        if os.path.exists(silent_video_path):
+             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
@@ -269,13 +310,17 @@ class Deformes4DEngine:
         return upscaler_specialist_singleton.upscale(latents)
         
     def _generate_latent_tensor_internal(self, conditioning_items, ltx_params, target_resolution, total_frames_to_generate):
-        kwargs = {
-            **ltx_params, 'width': target_resolution[1], 'height': target_resolution[0],
+        final_ltx_params = {
+            **ltx_params, 'width': target_resolution[0], 'height': target_resolution[1],
             'video_total_frames': total_frames_to_generate, 'video_fps': 24,
             'current_fragment_index': int(time.time()), 'conditioning_items_data': conditioning_items
         }
-        return self.ltx_manager.generate_latent_fragment(**kwargs)
+        new_full_latents, _ = self.ltx_manager.generate_latent_fragment(**final_ltx_params)
+        gc.collect()
+        torch.cuda.empty_cache()
+        return new_full_latents
 
+        
     def _quantize_to_multiple(self, n, m):
         if m == 0: return n
         quantized = int(round(n / m) * m)