Update api/ltx/ltx_aduc_pipeline.py

api/ltx/ltx_aduc_pipeline.py

@@ -222,17 +222,93 @@ class LtxAducPipeline:
     # --- UNIDADES DE TRABALHO E HELPERS INTERNOS ---
     # ==========================================================================
     
-    def _log_conditioning_items(self, items: List[Union[ConditioningItem, LatentConditioningItem]]):
-        """Logs detailed information about a list of ConditioningItem objects."""
-        if logging.getLogger().isEnabledFor(logging.DEBUG):
-            # (Lógica de logging para debug)
-            pass
+    def _log_conditioning_items(self, items: List[ConditioningItem]):
+        """
+        Logs detailed information about a list of ConditioningItem objects.
+        This is a dedicated debug helper function.
+        """
+        # Só imprime o log se o nível de logging for DEBUG
+        if logging.getLogger().isEnabledFor(logging.INFO):
+            log_str = ["\n" + "="*25 + " INFO: Conditioning Items " + "="*25]
+            if not items:
+                log_str.append("  -> Lista de conditioning_items está vazia.")
+            else:
+                for i, item in enumerate(items):
+                    if hasattr(item, 'media_item') and isinstance(item.media_item, torch.Tensor):
+                        t = item.media_item
+                        log_str.append(
+                            f"  -> Item [{i}]: "
+                            f"Tensor(shape={list(t.shape)}, "
+                            f"device='{t.device}', "
+                            f"dtype={t.dtype}), "
+                            f"Target Frame = {item.media_frame_number}, "
+                            f"Strength = {item.conditioning_strength:.2f}"
+                        )
+                    else:
+                        log_str.append(f"  -> Item [{i}]: Não contém um tensor válido.")
+            log_str.append("="*75 + "\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]:
         """[WORKER] Calls the pipeline to generate a single chunk of latents."""
-        # (A lógica desta função permanece a mesma)
-        pass # Placeholder
+        height_padded, width_padded = (self._align(d) for d in (kwargs['height'], kwargs['width']))
+        downscale_factor = self.config.get("downscale_factor", 0.6666666)
+        vae_scale_factor = self.pipeline.vae_scale_factor
+        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 = {
+            "prompt": kwargs['prompt'],
+            "negative_prompt": kwargs['negative_prompt'],
+            "height": downscaled_height,
+            "width": downscaled_width,
+            "num_frames": kwargs['num_frames'],
+            "frame_rate": int(DEFAULT_FPS),
+            "generator": torch.Generator(device=self.main_device).manual_seed(kwargs['seed']),
+            "output_type": "latent",
+            #"conditioning_items": conditioning_items if conditioning_items else None,
+            "media_items": None,
+            "decode_timestep": self.config["decode_timestep"],
+            "decode_noise_scale": self.config["decode_noise_scale"],
+            "stochastic_sampling": self.config["stochastic_sampling"],
+            "image_cond_noise_scale": 0.01,
+            "is_video": True,
+            "vae_per_channel_normalize": True,
+            "mixed_precision": (self.config["precision"] == "mixed_precision"),
+            "offload_to_cpu": False,
+            "enhance_prompt": False,
+            #"skip_layer_strategy": SkipLayerStrategy.AttentionValues,
+            **first_pass_config
+        }
+        
+        # --- Bloco de Logging para Depuração ---
+        # 4. Loga os argumentos do pipeline (sem os tensores de condição)
+        logging.info(f"\n[Info] Pipeline Arguments (BASE):\n {json.dumps(pipeline_kwargs, indent=2, default=str)}\n")
+        
+        # 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)
+        # --- Fim do Bloco de Logging ---
+
+        # 5. Adiciona os conditioning_items ao dicionário
+        pipeline_kwargs['conditioning_items'] = conditioning_items_list
+        
+        # 6. Executa o pipeline com o dicionário completo
+        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
+        
+        return latents_raw.to(self.main_device)
 
     @log_function_io
     def _finalize_generation(self, final_latents: torch.Tensor, base_filename: str, seed: int) -> Tuple[str, str]:
@@ -246,30 +322,42 @@ class LtxAducPipeline:
             final_latents, decode_timestep=float(self.config.get("decode_timestep", 0.05))
         )
         video_path = self._save_and_log_video(pixel_tensor, f"{base_filename}_{seed}")
-        return str(video_path), str(final_latents_path)
-    
+        return str(video_path), str(final_latents_path)    
+
     def _apply_ui_overrides(self, config_dict: Dict, overrides: Dict):
         """Applies advanced settings from the UI to a config dictionary."""
-        # (Lógica de overrides da UI permanece a mesma)
-        pass # Placeholder
-
+        # Override step counts
+        for key in ["num_inference_steps", "skip_initial_inference_steps", "skip_final_inference_steps"]:
+            ui_value = overrides.get(key)
+            if ui_value and ui_value > 0:
+                config_dict[key] = ui_value
+                logging.info(f"Override: '{key}' set to {ui_value} by UI.")
+        
     def _save_and_log_video(self, pixel_tensor: torch.Tensor, base_filename: str) -> Path:
-        """Saves a pixel tensor (on CPU) to an MP4 file."""
-        # (Lógica de salvar vídeo permanece a mesma)
-        pass # Placeholder
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = os.path.join(temp_dir, f"{base_filename}.mp4")
+            video_encode_tool_singleton.save_video_from_tensor(pixel_tensor, temp_path, fps=DEFAULT_FPS)
+            final_path = RESULTS_DIR / f"{base_filename}.mp4"
+            shutil.move(temp_path, final_path)
+            logging.info(f"Video saved successfully to: {final_path}")
+            return final_path
     
     def _apply_precision_policy(self):
-        # (Lógica de precisão permanece a mesma)
-        pass # Placeholder
+        precision = str(self.config.get("precision", "bfloat16")).lower()
+        if precision in ["float8_e4m3fn", "bfloat16"]: self.runtime_autocast_dtype = torch.bfloat16
+        elif precision == "mixed_precision": self.runtime_autocast_dtype = torch.float16
+        else: self.runtime_autocast_dtype = torch.float32
+        logging.info(f"Runtime precision policy set for autocast: {self.runtime_autocast_dtype}")
 
     def _align(self, dim: int, alignment: int = FRAMES_ALIGNMENT, alignment_rule: str = 'default') -> int:
-        """Aligns a dimension based on a rule."""
+        """Aligns a dimension to the nearest multiple of `alignment`."""
         if alignment_rule == 'n*8+1':
              return ((dim - 1) // alignment) * alignment + 1
         return ((dim - 1) // alignment + 1) * alignment
     
     def _calculate_aligned_frames(self, duration_s: float, min_frames: int = 1) -> int:
         num_frames = int(round(duration_s * DEFAULT_FPS))
+        # Para a duração total, sempre arredondamos para cima para o múltiplo de 8 mais próximo
         aligned_frames = self._align(num_frames, alignment=FRAMES_ALIGNMENT)
         return max(aligned_frames, min_frames)