Update api/ltx_server_refactored.py

api/ltx_server_refactored.py

@@ -37,8 +37,6 @@ from safetensors import safe_open
 from managers.vae_manager import vae_manager_singleton
 from tools.video_encode_tool import video_encode_tool_singleton
 
-from api.aduc_ltx_latent_patch import LTXLatentConditioningPatch, PatchedConditioningItem
-
 # --- Constantes Globais ---
 LTXV_DEBUG = True  # Mude para False para desativar logs de debug
 LTXV_FRAME_LOG_EVERY = 8
@@ -305,7 +303,7 @@ class VideoService:
 
 
     
-    def generate_low_resolution1(self, prompt: str, negative_prompt: str, height: int, width: int, duration_secs: float, guidance_scale: float, seed: Optional[int] = None, conditioning_items: Optional[List[PatchedConditioningItem]] = None) -> Tuple[str, str, int]:
+    def generate_low_resolution1(self, prompt: str, negative_prompt: str, height: int, width: int, duration_secs: float, guidance_scale: float, seed: Optional[int] = None, conditioning_items: Optional[List[ConditioningItem]] = None) -> Tuple[str, str, int]:
         """
         Gera um vídeo de baixa resolução e retorna os caminhos para o vídeo e os latentes.
         """
@@ -356,28 +354,13 @@ class VideoService:
         finally:
             self._finalize()
 
-    
-    def _prepare_condition_items(self, items_list: List[Tuple], height: int, width: int) -> List[PatchedConditioningItem]:
-        """Prepara os tensores de condicionamento a partir de imagens ou tensores."""
-        if not items_list:
-            return []
-            
-        height_padded = ((height - 1) // 8 + 1) * 8
-        width_padded = ((width - 1) // 8 + 1) * 8
-        padding_values = calculate_padding(height, width, height_padded, width_padded)
-        
-        conditioning_items = []
-        for media, frame_idx, weight in items_list:
-            if isinstance(media, str):
-                tensor = self._prepare_conditioning_tensor_from_path(media, height, width, padding_values)
-            else: # Assume que é um tensor
-                tensor = media.to(self.device, dtype=self.runtime_autocast_dtype)
-            
-            # Garante que o frame de condicionamento esteja dentro dos limites do vídeo
-            safe_frame_idx = int(frame_idx)
-            conditioning_items.append(PatchedConditioningItem(tensor, safe_frame_idx, float(weight)))
-            
-        return PatchedConditioningItem
+    def _prepare_conditioning_tensor(self, filepath, height, width, padding_values):
+        print(f"[DEBUG] Carregando condicionamento: {filepath}")
+        tensor = load_image_to_tensor_with_resize_and_crop(filepath, height, width)
+        tensor = torch.nn.functional.pad(tensor, padding_values)
+        out = tensor.to(self.device, dtype=self.runtime_autocast_dtype) if self.device == "cuda" else tensor.to(self.device)
+        print(f"[DEBUG] Cond shape={tuple(out.shape)} dtype={out.dtype} device={out.device}")
+        return out
 
     
     def generate_upscale_denoise(self, latents_path: str, prompt: str, negative_prompt: str, guidance_scale: float, seed: Optional[int] = None) -> Tuple[str, str]:
@@ -444,7 +427,7 @@ class VideoService:
         duration_secs: float,
         guidance_scale: float,
         seed: Optional[int] = None,
-        conditioning_items: Optional[List[PatchedConditioningItem]] = None
+        image_filepaths: Optional[List[str]] = None
     ) -> Tuple[str, str, int]:
         """
         ETAPA 1: Gera um vídeo e latentes em resolução base a partir de um prompt e
@@ -468,6 +451,16 @@ class VideoService:
         downscaled_width = width
         #self._calculate_downscaled_dims(height, width)
 
+
+        height_padded = ((downscaled_height - 1) // 32 + 1) * 32
+        width_padded = ((downscaled_width - 1) // 32 + 1) * 32
+        padding_values = calculate_padding(downscaled_height, downscaled_width, height_padded, width_padded)
+
+        conditioning_items = []
+        for filepath in image_filepaths:
+            cond_tensor = self._prepare_conditioning_tensor(filepath, downscaled_height, downscaled_width, padding_values)
+            conditioning_items.append(ConditioningItem(cond_tensor, 0, 1.0))
+
                     
         print(f"  - Frames: {actual_num_frames}, Duração: {duration_secs}s")
         print(f"  - Dimensões de Saída: {downscaled_height}x{downscaled_width}")
@@ -525,7 +518,7 @@ class VideoService:
         negative_prompt: str,
         guidance_scale: float,
         seed: Optional[int] = None,
-        conditioning_items: Optional[List[PatchedConditioningItem]] = None
+        conditioning_items: Optional[List[ConditioningItem]] = None
     ) -> Tuple[str, str]:
         """
         ETAPA 2: Refina a textura dos latentes existentes SEM alterar sua resolução