Update api/ltx/ltx_aduc_pipeline.py

api/ltx/ltx_aduc_pipeline.py

@@ -119,7 +119,7 @@ class LtxAducPipeline:
         num_chunks = len(prompt_list)
         total_frames = self._calculate_aligned_frames(kwargs.get("duration", 4.0))
         frames_per_chunk = max(FRAMES_ALIGNMENT, (total_frames // num_chunks // FRAMES_ALIGNMENT) * FRAMES_ALIGNMENT)
-        overlap_frames = 9 if is_narrative else 0
+        overlap_frames = 8 if is_narrative else 0
         
         initial_conditions = []
         if initial_media_items:
@@ -133,6 +133,8 @@ class LtxAducPipeline:
         
         temp_latent_paths = []
         overlap_condition_item: Optional[LatentConditioningItem] = None
+
+        current_conditions = initial_conditions
         
         try:
             for i, chunk_prompt in enumerate(prompt_list):
@@ -146,8 +148,9 @@ class LtxAducPipeline:
                 if overlap_condition_item: current_conditions.append(overlap_condition_item)
 
                 chunk_latents = self._generate_single_chunk_low(
-                    prompt=chunk_prompt, num_frames=current_frames, seed=used_seed + i,
-                    conditioning_items=current_conditions, **kwargs
+                    prompt_x=chunk_prompt, num_frames_x=current_frames, seed_x=used_seed,
+                    conditioning_items_x=current_conditions, 
+                    **kwargs
                 )
                 if chunk_latents is None: raise RuntimeError(f"Failed to generate latents for scene {i+1}.")
 
@@ -158,6 +161,7 @@ class LtxAducPipeline:
                         media_frame_number=0,
                         conditioning_strength=1.0
                     )
+                    current_conditions=overlap_condition_item
                 
                 if i > 0: chunk_latents = chunk_latents[:, :, overlap_frames:, :, :]
                 
@@ -183,6 +187,7 @@ class LtxAducPipeline:
     # --- UNIDADES DE TRABALHO E HELPERS INTERNOS ---
     # ==========================================================================
 
+    @log_function_io
     def _log_conditioning_items(self, items: List[LatentConditioningItem]):
         """
         Logs detailed information about a list of ConditioningItem objects.
@@ -206,18 +211,20 @@ class LtxAducPipeline:
                             f"Strength = {item.conditioning_strength:.2f}"
                         )
                     else:
-                        tt = str(itemvalue)
                         log_str.append(f"  -> Item [{i}]: Não contém um tensor válido.")
-                        log_str.append(f" {tt[:70]}")
                         
-            log_str.append("="*40 + "\n")
+            log_str.append("="*30 + "\n")
             
             # Usa o logger de debug para imprimir a mensagem completa
             logging.info("\n".join(log_str))
 
     
     @log_function_io
-    def _generate_single_chunk_low(self, **kwargs) -> Optional[torch.Tensor]:
+    def _generate_single_chunk_low(
+        prompt_x:str, num_frames_x:int, seed_x:int,
+        conditioning_items_x:LatentConditioningItem,
+        **kwargs
+    ) -> Optional[torch.Tensor]:
         """[WORKER] Calls the pipeline to generate a single chunk of latents."""
         height_padded, width_padded = (self._align(d) for d in (kwargs['height'], kwargs['width']))
         downscale_factor = self.config.get("downscale_factor", 0.6666666)
@@ -225,26 +232,15 @@ class LtxAducPipeline:
         downscaled_height = self._align(int(height_padded * downscale_factor), vae_scale_factor)
         downscaled_width = self._align(int(width_padded * downscale_factor), vae_scale_factor)
 
-        # 1. Começa com a configuração padrão
-        first_pass_config = self.config.get("first_pass", {}).copy()
-        
-        # 2. Aplica os overrides da UI, se existirem
-        if kwargs.get("ltx_configs_override"):
-            self._apply_ui_overrides(first_pass_config, kwargs.get("ltx_configs_override"))
-
-        
-        # 3. Monta o dicionário de argumentos SEM conditioning_items primeiro
-        pipeline_kwargs = {
-            "num_inference_steps": first_pass_config.get("num_inference_steps"),
-            "skip_final_inference_steps": first_pass_config.get("skip_final_inference_steps"),
+        call_kwargs = {
             "cfg_star_rescale": "true",
-            "prompt": kwargs['prompt'],
+            "prompt": prompt_x,
             "negative_prompt": kwargs['negative_prompt'],
             "height": downscaled_height,
             "width": downscaled_width,
-            "num_frames": kwargs['num_frames'],
+            "num_frames": num_frames_x,
             "frame_rate": int(DEFAULT_FPS),
-            "generator": torch.Generator(device=self.main_device).manual_seed(kwargs['seed']),
+            "generator": torch.Generator(device=self.main_device).manual_seed(seed_x),
             "output_type": "latent",
             "media_items": None,
             "decode_timestep": self.config["decode_timestep"],
@@ -257,14 +253,17 @@ class LtxAducPipeline:
             "offload_to_cpu": False,
             "enhance_prompt": False,
         }
-                
-        # Loga os conditioning_items separadamente com a nossa função helper
-        conditioning_items_list = kwargs.get('conditioning_items')
-        self._log_conditioning_items(conditioning_items_list)
-        pipeline_kwargs['conditioning_items'] = conditioning_items_list
+        
+        call_kwargs.pop("num_inference_steps", None) 
+        call_kwargs.pop("second_pass", None)
+        first_pass_config = self.config.get("first_pass", {}).copy()
+        call_kwargs.update(first_pass_config)
+        ltx_configs_override = kwargs.get("ltx_configs_override", {}).copy()
+        call_kwargs.update(ltx_configs_override)      
+        call_kwargs['conditioning_items'] = conditioning_items_x
         
         with torch.autocast(device_type=self.main_device.type, dtype=self.runtime_autocast_dtype, enabled="cuda" in self.main_device.type):
-            latents_raw = self.pipeline(**pipeline_kwargs).images
+            latents_raw = self.pipeline(**call_kwargs).images
         
         return latents_raw.to(self.main_device)