feat(arch): Launch the 'Staged Rocket' - Modular Deformes Engine Architecture

aduc_orchestrator.py

@@ -104,9 +104,9 @@ class AducOrchestrator:
         logger.info("Maestro: Especialista de Imagem concluiu a geração dos keyframes.")
         return final_keyframes
     
-    # --- ASSINATURA DA FUNÇÃO CORRIGIDA ---
+    # --- ASSINATURA DA FUNÇÃO ATUALIZADA ---
     def task_produce_final_movie_with_feedback(self, keyframes, global_prompt, seconds_per_fragment, 
-                           overlap_percent, echo_frames,
+                           trim_chunks: int, echo_chunks: int, # <-- PARÂMETROS ATUALIZADOS
                            handler_strength, 
                            destination_convergence_strength,
                            video_resolution, use_continuity_director, 
@@ -115,14 +115,14 @@ class AducOrchestrator:
         logger.info("AducOrchestrator: Delegando a produção do filme completo ao Deformes4DEngine.")
         storyboard = self.director.get_state("storyboard", [])
 
-        # --- CHAMADA CORRIGIDA ---
+        # --- CHAMADA DA FUNÇÃO ATUALIZADA ---
         for update in self.editor.generate_full_movie(
             keyframes=keyframes, 
             global_prompt=global_prompt, 
-            storyboard=storyboard, 
+            storyboard=storyboard,
             seconds_per_fragment=seconds_per_fragment, 
-            overlap_percent=overlap_percent, 
-            echo_frames=echo_frames, 
+            trim_chunks=trim_chunks,           # <-- PARÂMETRO NOVO
+            echo_chunks=echo_chunks,           # <-- PARÂMETRO NOVO
             handler_strength=handler_strength, 
             destination_convergence_strength=destination_convergence_strength,
             video_resolution=video_resolution, 

app.py

@@ -116,7 +116,9 @@ def run_mode_b_wrapper(prompt, num_keyframes, ref_files, progress=gr.Progress())
     
     return gr.update(value=storyboard), gr.update(value=selected_keyframes), gr.update(visible=True, open=True)
 
-def run_video_production_wrapper(keyframes, prompt, duration, overlap_percent, echo_frames, 
+# --- ASSINATURA DA FUNÇÃO WRAPPER ATUALIZADA ---
+def run_video_production_wrapper(keyframes, prompt, duration, 
+                                 trim_chunks, echo_chunks,   # <-- PARÂMETROS ATUALIZADOS
                                  handler_strength, destination_convergence_strength,
                                  video_resolution, use_cont, use_cine,
                                  progress=gr.Progress()):
@@ -130,8 +132,10 @@ def run_video_production_wrapper(keyframes, prompt, duration, overlap_percent, e
     video_fragments_so_far = []
     final_movie_path = None
     
+    # --- CHAMADA PARA O ORQUESTRADOR ATUALIZADA ---
     for update in aduc.task_produce_final_movie_with_feedback(
-        keyframes, prompt, duration, overlap_percent, echo_frames, 
+        keyframes, prompt, duration, 
+        int(trim_chunks), int(echo_chunks), # <-- Passando os novos valores (convertidos para int)
         handler_strength, destination_convergence_strength,
         resolution, use_cont, use_cine, progress
     ):
@@ -155,8 +159,15 @@ def get_log_content():
     except FileNotFoundError:
         return "Arquivo de log ainda não criado. Inicie uma geração."
 
+# --- FUNÇÃO DE TRADUÇÃO ATUALIZADA (NOVOS COMPONENTES) ---
 def update_ui_language(lang_code):
     lang_map = i18n.get(lang_code, i18n.get('en', {}))
+    # Adicionando traduções para os novos sliders (supondo que existam no i18n.json)
+    trim_chunks_label = lang_map.get('trim_chunks_label', 'Trim Chunks')
+    trim_chunks_info = lang_map.get('trim_chunks_info', 'How many chunks (8 frames each) to "trim" from the end before extracting the continuity guide (Echo).')
+    echo_chunks_label = lang_map.get('echo_chunks_label', 'Echo Chunks (Memory)')
+    echo_chunks_info = lang_map.get('echo_chunks_info', 'The size of the continuity guide (Echo) in chunks. This is the "memory" passed to the next scene.')
+    
     return {
         title_md: gr.update(value=f"# {lang_map.get('app_title')}"),
         subtitle_md: gr.update(value=lang_map.get('app_subtitle')),
@@ -175,8 +186,10 @@ def update_ui_language(lang_code):
         continuity_director_checkbox: gr.update(label=lang_map.get('continuity_director_label')),
         cinematographer_checkbox: gr.update(label=lang_map.get('cinematographer_label')),
         
-        memoria_cinetica_radio: gr.update(label=lang_map.get('memoria_cinetica_label'), info=lang_map.get('memoria_cinetica_info')),
-        sobreposicao_video_slider: gr.update(label=lang_map.get('sobreposicao_label'), info=lang_map.get('sobreposicao_info')),
+        # --- ATUALIZANDO OS NOVOS SLIDERS ---
+        trim_chunks_slider: gr.update(label=trim_chunks_label, info=trim_chunks_info),
+        echo_chunks_slider: gr.update(label=echo_chunks_label, info=echo_chunks_info),
+        
         forca_guia_slider: gr.update(label=lang_map.get('forca_guia_label'), info=lang_map.get('forca_guia_info')),
         convergencia_destino_slider: gr.update(label=lang_map.get('convergencia_final_label'), info=lang_map.get('convergencia_final_info')),
         
@@ -218,12 +231,18 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             continuity_director_checkbox = gr.Checkbox(label=default_lang.get('continuity_director_label'), value=True)
             cinematographer_checkbox = gr.Checkbox(label=default_lang.get('cinematographer_label'), value=True, visible=False)
         
-        gr.Markdown("--- \n**Controles de Continuidade e Edição (Novos):**")
+        # --- INÍCIO DA ATUALIZAÇÃO DA UI (CONTROLES DE CHUNK) ---
+        gr.Markdown("--- \n**Controles de Continuidade e Edição (Baseado em Chunks):**")
         with gr.Row():
-            memoria_cinetica_radio = gr.Radio(choices=[8, 16, 24], value=8, label=default_lang.get('memoria_cinetica_label'), info=default_lang.get('memoria_cinetica_info'))
-            sobreposicao_video_slider = gr.Slider(label=default_lang.get('sobreposicao_label'), minimum=0, maximum=50, value=15, step=1, info=default_lang.get('sobreposicao_info'))
+            trim_chunks_slider = gr.Slider(minimum=0, maximum=10, value=2, step=1, 
+                                             label="Chunks de Corte", 
+                                             info="Quantos chunks (de 8 frames) 'aparar' do final antes de extrair a guia de continuidade (Eco).")
+            echo_chunks_slider = gr.Slider(minimum=1, maximum=3, value=1, step=1, 
+                                             label="Chunks de Eco (Memória)", 
+                                             info="O tamanho da guia de continuidade (Eco) em chunks. Esta é a 'memória' que passa para a próxima cena.")
+        # --- FIM DA ATUALIZAÇÃO DA UI ---
         
-        gr.Markdown("**Controle de Influência (Novos):**")
+        gr.Markdown("**Controle de Influência:**")
         with gr.Row():
             forca_guia_slider = gr.Slider(label=default_lang.get('forca_guia_label'), minimum=0.0, maximum=1.0, value=0.5, step=0.05, info=default_lang.get('forca_guia_info'))
             convergencia_destino_slider = gr.Slider(label=default_lang.get('convergencia_final_label'), minimum=0.0, maximum=1.0, value=0.75, step=0.05, info=default_lang.get('convergencia_final_info'))
@@ -238,7 +257,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         update_log_button = gr.Button("Atualizar Log")
 
     # --- 5. CONEXÕES DA UI ---
-    all_ui_components = list(update_ui_language('pt').keys())
+    # Removendo os componentes antigos e adicionando os novos para a tradução
+    all_ui_components_dict = update_ui_language('pt')
+    # Adicionando os novos componentes manualmente ao dicionário para garantir que sejam incluídos
+    all_ui_components_dict[trim_chunks_slider] = None
+    all_ui_components_dict[echo_chunks_slider] = None
+    all_ui_components = list(all_ui_components_dict.keys())
+    
     lang_selector.change(fn=update_ui_language, inputs=lang_selector, outputs=all_ui_components)
     
     ref_image_input.upload(fn=preprocess_base_images_wrapper, inputs=ref_image_input, outputs=ref_image_input)
@@ -255,12 +280,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         outputs=[storyboard_output, keyframe_gallery, step3_accordion]
     )
     
+    # --- CHAMADA DO BOTÃO ATUALIZADA ---
     produce_button.click(
         fn=run_video_production_wrapper,
         inputs=[
             keyframe_gallery, prompt_input, duration_per_fragment_slider, 
-            sobreposicao_video_slider, 
-            memoria_cinetica_radio,
+            trim_chunks_slider,           # <-- NOVO INPUT
+            echo_chunks_slider,           # <-- NOVO INPUT
             forca_guia_slider,
             convergencia_destino_slider,
             resolution_selector, continuity_director_checkbox, cinematographer_checkbox

deformes4D_engine.py

@@ -1,7 +1,6 @@
 # deformes4D_engine.py
 # Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
 #
-#
 # MODIFICATIONS FOR ADUC-SDR:
 # Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved.
 #
@@ -23,9 +22,7 @@ import subprocess
 import random
 import gc
 
-from audio_specialist import audio_specialist_singleton
 from ltx_manager_helpers import ltx_manager_singleton
-from flux_kontext_helpers import flux_kontext_singleton
 from gemini_helpers import gemini_singleton 
 from ltx_video.models.autoencoders.vae_encode import vae_encode, vae_decode
 
@@ -52,7 +49,6 @@ class Deformes4DEngine:
         self._vae.to(self.device); self._vae.eval()
         return self._vae
 
-    # ... (métodos auxiliares como save/load/pixels_to_latents permanecem iguais) ...
     def save_latent_tensor(self, tensor: torch.Tensor, path: str):
         torch.save(tensor.cpu(), path)
         logger.info(f"Tensor latente salvo em: {path}")
@@ -74,17 +70,19 @@ class Deformes4DEngine:
         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
+        if video_tensor is None or video_tensor.ndim != 5 or video_tensor.shape[2] == 0:
+            logger.warning("Tentativa de salvar um tensor de vídeo inválido. Abortando.")
+            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) as writer:
             for frame in video_np: writer.append_data(frame)
-        logger.info(f"Vídeo salvo em: {path}")
+        logger.info(f"Vídeo salvo em: {path}")
 
     def _preprocess_image_for_latent_conversion(self, image: Image.Image, target_resolution: tuple) -> Image.Image:
         if image.size != target_resolution:
-            logger.info(f"  - AÇÃO: Redimensionando imagem de {image.size} para {target_resolution} antes da conversão para latente.")
+            logger.info(f"  - AÇÃO: Redimensionando imagem de {image.size} para {target_resolution} antes da conversão para latente.")
             return ImageOps.fit(image, target_resolution, Image.Resampling.LANCZOS)
         return image
 
@@ -94,245 +92,175 @@ class Deformes4DEngine:
         tensor = (tensor * 2.0) - 1.0
         return self.pixels_to_latents(tensor)
         
-    def _generate_video_and_audio_from_latents(self, latent_tensor, audio_prompt, base_name):
+    def _generate_video_from_latents(self, latent_tensor, 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 silent_video_path
 
     def _generate_latent_tensor_internal(self, conditioning_items, ltx_params, target_resolution, total_frames_to_generate):
-        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
-        }
+        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}
         new_full_latents, _ = self.ltx_manager.generate_latent_fragment(**final_ltx_params)
         return new_full_latents
 
     def concatenate_videos_ffmpeg(self, video_paths: list[str], output_path: str) -> str:
-        if not video_paths:
-            raise gr.Error("Nenhum fragmento de vídeo para montar.")
+        if not video_paths: raise gr.Error("Nenhum fragmento de vídeo para montar.")
         list_file_path = os.path.join(self.workspace_dir, "concat_list.txt")
         with open(list_file_path, 'w', encoding='utf-8') as f:
-            for path in video_paths:
-                f.write(f"file '{os.path.abspath(path)}'\n")
+            for path in video_paths: f.write(f"file '{os.path.abspath(path)}'\n")
         cmd_list = ['ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', list_file_path, '-c', 'copy', output_path]
-        logger.info("Executando concatenação FFmpeg...")
+        logger.info("Executando concatenação FFmpeg...")
         try:
             subprocess.run(cmd_list, check=True, capture_output=True, text=True)
         except subprocess.CalledProcessError as e:
             logger.error(f"Erro no FFmpeg: {e.stderr}")
-            raise gr.Error(f"Falha na montagem final do vídeo. Detalhes: {e.stderr}")
+            raise gr.Error(f"Falha na montagem final do vídeo. Detalhes: {e.stderr}")
         return output_path
     
-    def generate_full_movie(self, 
-                            keyframes: list, 
-                            global_prompt: str, 
-                            storyboard: list, 
-                            seconds_per_fragment: float, 
-                            overlap_percent: int, 
-                            echo_frames: int,
-                            handler_strength: float, 
-                            destination_convergence_strength: float,
-                            video_resolution: int, 
-                            use_continuity_director: bool, 
-                            progress: gr.Progress = gr.Progress()):
+    def generate_full_movie(self, keyframes: list, global_prompt: str, storyboard: list, seconds_per_fragment: float, 
+                            trim_chunks: int, echo_chunks: int,
+                            handler_strength: float, destination_convergence_strength: float, video_resolution: int, 
+                            use_continuity_director: bool, progress: gr.Progress = gr.Progress()):
         
-        base_ltx_params = {
-            "guidance_scale": 1.0, "stg_scale": 0.0,
-            "rescaling_scale": 0.15, "num_inference_steps": 7,
-        }
-
+        base_ltx_params = {"guidance_scale": 1.0, "stg_scale": 0.0, "rescaling_scale": 0.15, "num_inference_steps": 20}
         keyframe_paths = [item[0] if isinstance(item, tuple) else item for item in keyframes]
-        video_clips_paths, story_history, audio_history = [], "", "This is the beginning of the film."
+        video_clips_paths, story_history = [], ""
         target_resolution_tuple = (video_resolution, video_resolution) 
-        n_trim_latents = self._quantize_to_multiple(int(seconds_per_fragment * 24 * (overlap_percent / 100.0)), 8)
         
-        # --- NOVA LÓGICA: Variáveis para guardar os tensores de continuidade ---
-        prepared_echo_latent = None
-        prepared_handler_latent = None
+        total_frames_base = self._quantize_to_multiple(round(seconds_per_fragment * 24), 8)
+        if total_frames_base == 0: total_frames_base = 8
+        
+        logger.info("="*50)
+        logger.info("CÁLCULOS DE GERAÇÃO E GUIAS (BASEADO EM CHUNKS):")
+        logger.info(f"  - Duração Base Solicitada: {total_frames_base} frames ({total_frames_base // 8} chunks)")
+        logger.info(f"  - N_Corte para guias: {trim_chunks} chunks")
+        logger.info(f"  - N_Eco (Dejavu) para guias: {echo_chunks} chunks")
+        logger.info("="*50)
+
+        dejavu_latent, evo_latent, last_eco_chunk = None, None, None
+        
+        if len(keyframe_paths) < 3:
+            raise gr.Error(f"O modelo de geração requer no mínimo 3 keyframes (Passado, Presente, Futuro). Você forneceu {len(keyframe_paths)}.")
         
-        num_transitions_to_generate = len(keyframe_paths) - 1
+        num_transitions_to_generate = len(keyframe_paths) - 2
+        logger.info(f"Modelo 'K-2' ativado: {len(keyframe_paths)} keyframes resultarão em {num_transitions_to_generate} fragmentos de vídeo.")
         
         for i in range(num_transitions_to_generate):
-            progress((i + 1) / num_transitions_to_generate, desc=f"Produzindo Transição {i+1}/{num_transitions_to_generate}")
-
-            start_keyframe_path = keyframe_paths[i]
-            destination_keyframe_path = keyframe_paths[i+1]
-            present_scene_desc = storyboard[i]
+            start_keyframe_index = i + 1
+            
+            logger.info(f"--- INICIANDO FRAGMENTO {i+1}/{num_transitions_to_generate} (índice de loop i={i}) ---")
+            progress((i + 1) / num_transitions_to_generate, desc=f"Produzindo Transição {i+1}/{num_transitions_to_generate}")
+            
+            past_keyframe_path = keyframe_paths[start_keyframe_index - 1]
+            start_keyframe_path = keyframe_paths[start_keyframe_index]
+            destination_keyframe_path = keyframe_paths[start_keyframe_index + 1]
+            future_story_prompt = storyboard[start_keyframe_index + 1] if (start_keyframe_index + 1) < len(storyboard) else "A cena final."
 
-            is_first_fragment = (prepared_handler_latent is None)
             
-            # ... (Lógica de decisão do Gemini e do diretor de som permanece a mesma) ...
-            if is_first_fragment:
-                transition_type = "start"
-                motion_prompt = gemini_singleton.get_initial_motion_prompt(
-                    global_prompt, start_keyframe_path, destination_keyframe_path, present_scene_desc
-                )
-            else:
-                past_keyframe_path = keyframe_paths[i-1]
-                past_scene_desc = storyboard[i-1]
-                future_scene_desc = storyboard[i+1] if (i+1) < len(storyboard) else "A cena final."
-                decision = gemini_singleton.get_cinematic_decision(
-                    global_prompt=global_prompt, story_history=story_history,
-                    past_keyframe_path=past_keyframe_path, present_keyframe_path=start_keyframe_path,
-                    future_keyframe_path=destination_keyframe_path, past_scene_desc=past_scene_desc,
-                    present_scene_desc=present_scene_desc, future_scene_desc=future_scene_desc
-                )
-                transition_type, motion_prompt = decision["transition_type"], decision["motion_prompt"]
+            decision = gemini_singleton.get_cinematic_decision(
+                global_prompt,
+                story_history,
+                past_keyframe_path,
+                start_keyframe_path,
+                destination_keyframe_path,
+                storyboard[start_keyframe_index - 1], # Story para o Keyframe Passado
+                storyboard[start_keyframe_index],    # Story para o Keyframe de Início (Presente)
+                future_story_prompt
+            )
+            transition_type, motion_prompt = decision["transition_type"], decision["motion_prompt"]
             
             story_history += f"\n- Ato {i+1} ({transition_type}): {motion_prompt}"
 
-            if use_continuity_director:
-                if is_first_fragment:
-                    audio_prompt = gemini_singleton.get_sound_director_prompt(
-                        audio_history=audio_history,
-                        past_keyframe_path=start_keyframe_path, present_keyframe_path=start_keyframe_path,
-                        future_keyframe_path=destination_keyframe_path, present_scene_desc=present_scene_desc,
-                        motion_prompt=motion_prompt, future_scene_desc=storyboard[i+1] if (i+1) < len(storyboard) else "The final scene."
-                    )
-                else:
-                    audio_prompt = gemini_singleton.get_sound_director_prompt(
-                        audio_history=audio_history, past_keyframe_path=keyframe_paths[i-1],
-                        present_keyframe_path=start_keyframe_path, future_keyframe_path=destination_keyframe_path,
-                        present_scene_desc=present_scene_desc, motion_prompt=motion_prompt,
-                        future_scene_desc=storyboard[i+1] if (i+1) < len(storyboard) else "The final scene."
-                    )
-            else:
-                audio_prompt = present_scene_desc
+            total_frames_to_generate = total_frames_base
             
-            audio_history = audio_prompt
-
             conditioning_items = []
-            current_ltx_params = {**base_ltx_params, "handler_strength": handler_strength, "motion_prompt": motion_prompt}
-            total_frames_to_generate = self._quantize_to_multiple(int(seconds_per_fragment * 24), 8) + 1
-
-            
+            logger.info(f"  [0. PREPARAÇÃO] Montando itens de condicionamento para K{start_keyframe_index} -> K{start_keyframe_index+1}.")
+                        
             
-            # --- NOVA LÓGICA: Preparação das instruções de condicionamento ---
-            if is_first_fragment:
-                img_start = self._preprocess_image_for_latent_conversion(Image.open(start_keyframe_path).convert("RGB"), target_resolution_tuple)
-                start_latent = self.pil_to_latent(img_start)
-                conditioning_items.append(LatentConditioningItem(start_latent, 0, 1.0))
-                if transition_type != "cut":
-                    img_dest = self._preprocess_image_for_latent_conversion(Image.open(destination_keyframe_path).convert("RGB"), target_resolution_tuple)
-                    destination_latent = self.pil_to_latent(img_dest)
-                    conditioning_items.append(LatentConditioningItem(destination_latent, total_frames_to_generate - 1, destination_convergence_strength))
+            if last_eco_chunk is None:
+               # Nenhum eco → sempre trata como "primeiro fragmento"
+               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:
-                # Usa os tensores pré-preparados da iteração anterior
-                conditioning_items.append(LatentConditioningItem(prepared_echo_latent, 0, 1.0))
-                conditioning_items.append(LatentConditioningItem(prepared_handler_latent, echo_frames, handler_strength))
-                if transition_type == "continuous":
-                    img_dest = self._preprocess_image_for_latent_conversion(Image.open(destination_keyframe_path).convert("RGB"), target_resolution_tuple)
-                    destination_latent = self.pil_to_latent(img_dest)
-                    conditioning_items.append(LatentConditioningItem(destination_latent, total_frames_to_generate - 1, destination_convergence_strength))
+               # Usa eco + handler do fragmeto anterior 
+               conditioning_items.append(LatentConditioningItem(last_eco_chunk, 0, 1.0))
+               handler_frame = (echo_chunks + trim_chunks) * 8
+               conditioning_items.append(LatentConditioningItem(handler_Chunk, handler_frame, handler_strength))
+              
             
-            new_full_latents = self._generate_latent_tensor_internal(conditioning_items, current_ltx_params, target_resolution_tuple, total_frames_to_generate)
+            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), total_frames_base, destination_convergence_strength))
 
+            current_ltx_params = {**base_ltx_params, "motion_prompt": motion_prompt}
+            new_full_latents = self._generate_latent_tensor_internal(conditioning_items, current_ltx_params, target_resolution_tuple, total_frames_to_generate)
 
-            
-            # --- CÓDIGO ADICIONADO PARA ITERAR E CONTAR FRAMES ---
-            logger.info("Iniciando a contagem de frames para cada tensor latente individual.")
-            total_frames_from_latents = 0
-            for i in range(new_full_latents.shape[2]):
-                single_latent_tensor = new_full_latents[:, :, i:i+1, :, :]
-                temp_video_path = os.path.join(self.workspace_dir, f"temp_latent_video_{i}.mp4")
-                
-                # Gerar um vídeo temporário para o tensor latente individual
-                pixel_tensor_single = self.latents_to_pixels(single_latent_tensor)
-                self.save_video_from_tensor(pixel_tensor_single, temp_video_path, fps=24)
-                del pixel_tensor_single
-                gc.collect()
 
-                # Contar os frames do vídeo temporário com ffprobe
+            # --- [INÍCIO] Bloco de Verificação de Frames por Chunk ---
+            logger.info("--- [VERIFICAÇÃO DE CHUNKS INDIVIDUAIS] ---")
+            total_chunks_verificados = new_full_latents.shape[2]
+            for chunk_idx in range(total_chunks_verificados):
                 try:
-                    frame_count_result = subprocess.run(
-                        ["ffprobe", "-v", "error", "-select_streams", "v:0", "-count_frames", "-show_entries", "stream=nb_read_frames", "-of", "default=noprint_wrappers=1:nokey=1", temp_video_path],
-                        capture_output=True, text=True, check=True
-                    )
-                    frames = int(frame_count_result.stdout.strip())
-                    logger.info(f"Latente {i}: Vídeo temporário gerado com {frames} frames.")
-                    total_frames_from_latents += frames
-                except (subprocess.CalledProcessError, ValueError, FileNotFoundError) as e:
-                    logger.error(f"Falha ao contar frames para o latente {i} com ffprobe: {e}")
-                finally:
+                    # Isola o chunk atual
+                    single_chunk_latent = new_full_latents[:, :, chunk_idx:chunk_idx+1, :, :]
+                    
+                    # Gera um nome de arquivo temporário para o vídeo do chunk
+                    temp_video_base_name = f"debug_chunk_{chunk_idx}"
+                    
+                    # Converte o latente do chunk em um vídeo MP4
+                    temp_video_path = self._generate_video_from_latents(single_chunk_latent, temp_video_base_name)
+                    
+                    # Conta os frames no vídeo gerado
                     if os.path.exists(temp_video_path):
+                        with imageio.get_reader(temp_video_path) as reader:
+                            frame_count = reader.count_frames()
+                        logger.info(f"  - VERIFICADO: Chunk {chunk_idx} gerou um vídeo com {frame_count} frames.")
+                        # Apaga o vídeo de debug
                         os.remove(temp_video_path)
+                    else:
+                        logger.warning(f"  - FALHA: Não foi possível gerar o vídeo para o Chunk {chunk_idx}.")
+                
+                except Exception as e:
+                    logger.error(f"  - ERRO ao verificar Chunk {chunk_idx}: {e}")
+            logger.info("--- [FIM DA VERIFICAÇÃO] ---")
+            # --- [FIM] Bloco de Verificação ---
             
-            logger.info(f"Contagem total de frames a partir dos latentes individuais: {total_frames_from_latents}")
-
-            # Gerar e contar frames para o vídeo completo a partir do tensor latente inteiro
-            full_latent_video_path = os.path.join(self.workspace_dir, "temp_full_latent_video.mp4")
-            full_pixel_tensor = self.latents_to_pixels(new_full_latents)
-            self.save_video_from_tensor(full_pixel_tensor, full_latent_video_path, fps=24)
-            del full_pixel_tensor
-            gc.collect()
-
-            try:
-                full_frame_count_result = subprocess.run(
-                    ["ffprobe", "-v", "error", "-select_streams", "v:0", "-count_frames", "-show_entries", "stream=nb_read_frames", "-of", "default=noprint_wrappers=1:nokey=1", full_latent_video_path],
-                    capture_output=True, text=True, check=True
-                )
-                total_frames_full_video = int(full_frame_count_result.stdout.strip())
-                logger.info(f"Vídeo completo gerado a partir do tensor latente inteiro possui {total_frames_full_video} frames.")
-            except (subprocess.CalledProcessError, ValueError, FileNotFoundError) as e:
-                logger.error(f"Falha ao contar frames do vídeo completo com ffprobe: {e}")
-            finally:
-                if os.path.exists(full_latent_video_path):
-                    os.remove(full_latent_video_path)
-            # --- FIM DO CÓDIGO ADICIONADO ---```
-            
-
+            logger.info(f"  [1. GERAÇÃO] Tensor latente bruto gerado com shape: {new_full_latents.shape}.")
             
-            # --- NOVA LÓGICA: Preparação movida para o final do loop ---
-            is_last_fragment = (i == num_transitions_to_generate - 1)
             
-            if not is_last_fragment:
-                # ANTECIPAÇÃO: Prepara os tensores para a PRÓXIMA iteração
-                prepared_handler_latent = new_full_latents[:, :, -1:, :, :].clone()
-                prepared_echo_latent = new_full_latents[:, :, -echo_frames:, :, :].clone()
+            total_chunks = new_full_latents.shape[2]
+            logger.info(f"  [GUIAS] Extraindo guias de continuidade para a PRÓXIMA iteração (Total: {total_chunks} chunks).")
                 
-                # CORTE NO FIM: Define os latentes para o VÍDEO ATUAL, removendo a sobreposição
-                if n_trim_latents > 0 and new_full_latents.shape[2] > n_trim_latents:
-                    latents_for_video = new_full_latents[:, :, :-n_trim_latents, :, :]
-                else:
-                    latents_for_video = new_full_latents
-            else:
-                # O último fragmento não precisa preparar nada para o futuro, então renderiza-se por completo.
-                latents_for_video = new_full_latents
+            handler_Chunk = new_full_latents[:, :, -1:, :, :].clone()
+            logger.info(f"    - 'handler_Chunk' (guia de evolução) extraído do chunk final (índice {total_chunks-1}).")
+            
+            index_of_last_usable_chunk = total_chunks
+            end_chunk_index = index_of_last_usable_chunk - trim_chunks
+            start_chunk_index = end_chunk_index - echo_chunks
+            
+            logger.info(f"    - Fatia de chunks para 'Dejavu' (guia de memória) será: [{start_chunk_index}:{end_chunk_index}].")
+            last_eco_chunk = new_full_latents[:, :, start_chunk_index:end_chunk_index, :, :].clone()
+            
+            logger.info(f"  [2. EDIÇÃO] Realizando a montagem do clipe de vídeo a partir do tensor bruto.")
+            latents_for_video = new_full_latents
 
+            latents_for_video = latents_for_video[:, :, :1, :, :]
+
+            latents_for_video = latents_for_video[:, :, echo_chunks:-(trim_chunks), :, :]
+              
             base_name = f"fragment_{i}_{int(time.time())}"
-            video_with_audio_path = self._generate_video_and_audio_from_latents(latents_for_video, audio_prompt, base_name)
-            video_clips_paths.append(video_with_audio_path)
             
-            if transition_type == "cut":
-                # Se for um corte, limpa a memória para a próxima iteração começar do zero.
-                prepared_echo_latent = None
-                prepared_handler_latent = None
-                
-            yield {"fragment_path": video_with_audio_path}
-
-        final_movie_path = os.path.join(self.workspace_dir, f"final_movie_{int(time.time())}.mp4")
+            logger.info(f"  [3. DECODIFICAÇÃO] Tensor final para o clipe tem {latents_for_video.shape[2]} chunks. Enviando para gerar vídeo.")
+            video_path = self._generate_video_from_latents(latents_for_video, base_name)
+            video_clips_paths.append(video_path)
+            yield {"fragment_path": video_path}
+                 
+        final_movie_path = os.path.join(self.workspace_dir, f"final_movie_silent_{int(time.time())}.mp4")
         self.concatenate_videos_ffmpeg(video_clips_paths, final_movie_path)
         
         logger.info(f"Filme completo salvo em: {final_movie_path}")

gemini_helpers.py

@@ -47,7 +47,7 @@ class GeminiSingleton:
         if self.api_key:
             genai.configure(api_key=self.api_key)
             # Modelo mais recente e capaz para tarefas complexas de visão e raciocínio.
-            self.model = genai.GenerativeModel('gemini-2.5-flash') 
+            self.model = genai.GenerativeModel('gemini-2.0-flash') 
             logger.info("Especialista Gemini (1.5 Pro) inicializado com sucesso.")
         else:
             self.model = None

prompts/cinematic_director_prompt.txt

@@ -24,12 +24,7 @@ You will receive a complete picture of the narrative timeline.
   - Textual Future (Ato_n+1): "{future_scene_desc}"
   - Visual Future (Keyframe k_n+1): [FUTURE_IMAGE]
 
-# --- TASK 1: THE EDITING DECISION ---
-Analyze the transition from the PRESENT (`k_n`) to the FUTURE (`k_n+1`).
-- If there is a major, non-continuous jump (e.g., scene changes from day to night, character teleports, location is completely different), you MUST decide this is a "cut". This is a critical break in the action.
-- Otherwise, if the action can flow logically from the present to the future, decide it is "continuous".
-
-# --- TASK 2: THE CINEMATIC MOTION PROMPT ---
+# --- TASK : THE CINEMATIC MOTION PROMPT ---
 Based on your decision, write the `motion_prompt`. The prompt MUST describe the action that moves the story from the PRESENT visual (`k_n`) towards the FUTURE visual (`k_n+1`).
 
 **CRITICAL PROMPT DIRECTIVES:**
@@ -42,4 +37,4 @@ Based on your decision, write the `motion_prompt`. The prompt MUST describe the
     d. **Scenery/Environment:** Describe environmental details that add to the motion and mood (e.g., "wind rustling the leaves", "rain streaks down the window").
 
 # RESPONSE FORMAT:
-You MUST respond with a single, clean JSON object with two keys: "transition_type" and "motion_prompt".
+You MUST respond with a single, clean JSON object with two keys: "transition_type" = "continuous , and "motion_prompt".