Update api/ltx_server.py

api/ltx_server.py

@@ -19,8 +19,7 @@ logging.set_verbosity_debug()
 LTXV_DEBUG=1
 LTXV_FRAME_LOG_EVERY=8
 
-from typing import List, Dict, Tuple, Any, Optional, Literal, Union
-from dataclasses import dataclass
+
 
 # --- 1. IMPORTAÇÕES ---
 import os, subprocess, shlex, tempfile
@@ -50,10 +49,6 @@ import torch.nn.functional as F
 from managers.vae_manager import vae_manager_singleton
 from tools.video_encode_tool import video_encode_tool_singleton
 
-
-
-
-
 # --- 2. GERENCIAMENTO DE DEPENDÊNCIAS E SETUP ---
 def _query_gpu_processes_via_nvml(device_index: int) -> List[Dict]:
     try:
@@ -223,9 +218,7 @@ def add_deps_to_path():
 add_deps_to_path()
 
 # --- 3. IMPORTAÇÕES ESPECÍFICAS DO MODELO ---
-global vae_encode, latent_to_pixel_coords, randn_tensor
-from ltx_video.models.autoencoders.vae_encode import vae_encode, latent_to_pixel_coords
-     
+
 from ltx_video.pipelines.pipeline_ltx_video import ConditioningItem, LTXMultiScalePipeline
 from ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
 from ltx_video.models.autoencoders.vae_encode import un_normalize_latents, normalize_latents
@@ -249,70 +242,7 @@ def log_tensor_info(tensor, name="Tensor"):
     print("------------------------------------------\n")
 
 
-@dataclass
-class LatentConditioningItem:
-    """Item de dados para condicionamento da pipeline LTX."""
-    latent_tensor: torch.Tensor
-    media_frame_number: int
-    conditioning_strength: float
-
-
-
-def _aduc_prepare_conditioning_patch(
-        self: "LTXVideoPipeline",
-        conditioning_items: Optional[List[Union["ConditioningItem", "LatentConditioningItem"]]],
-        init_latents: torch.Tensor,
-        num_frames: int,
-        height: int,
-        width: int,
-        vae_per_channel_normalize: bool = True,
-        generator=None,
-    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, int]:
-        if not conditioning_items:
-            init_latents, init_latent_coords = self.patchifier.patchify(latents=init_latents)
-            init_pixel_coords = latent_to_pixel_coords(init_latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
-            return init_latents, init_pixel_coords, None, 0
-        
-        init_conditioning_mask = torch.zeros_like(init_latents[:, 0, ...], dtype=torch.float32, device=init_latents.device)
-        extra_conditioning_latents, extra_conditioning_pixel_coords, extra_conditioning_mask = [], [], []
-        extra_conditioning_num_latents = 0
-        
-        for item in conditioning_items:
-            if not isinstance(item, LatentConditioningItem):
-                print("Patch ADUC: Item de condicionamento não é um LatentConditioningItem e será ignorado.")
-                continue
-            
-            media_item_latents = item.latent_tensor.to(dtype=init_latents.dtype, device=init_latents.device)
-            media_frame_number, strength = item.media_frame_number, item.conditioning_strength
-            
-            if media_frame_number == 0:
-                f_l, h_l, w_l = media_item_latents.shape[-3:]
-                init_latents[..., :f_l, :h_l, :w_l] = torch.lerp(init_latents[..., :f_l, :h_l, :w_l], media_item_latents, strength)
-                init_conditioning_mask[..., :f_l, :h_l, :w_l] = strength
-            else:
-                noise = randn_tensor(media_item_latents.shape, generator=generator, device=media_item_latents.device, dtype=media_item_latents.dtype)
-                media_item_latents = torch.lerp(noise, media_item_latents, strength)
-                patched_latents, latent_coords = self.patchifier.patchify(latents=media_item_latents)
-                pixel_coords = latent_to_pixel_coords(latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
-                pixel_coords[:, 0] += media_frame_number
-                extra_conditioning_num_latents += patched_latents.shape[1]
-                new_mask = torch.full(patched_latents.shape[:2], strength, dtype=torch.float32, device=init_latents.device)
-                extra_conditioning_latents.append(patched_latents)
-                extra_conditioning_pixel_coords.append(pixel_coords)
-                extra_conditioning_mask.append(new_mask)
-    
-        init_latents, init_latent_coords = self.patchifier.patchify(latents=init_latents)
-        init_pixel_coords = latent_to_pixel_coords(init_latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
-        init_conditioning_mask, _ = self.patchifier.patchify(latents=init_conditioning_mask.unsqueeze(1))
-        init_conditioning_mask = init_conditioning_mask.squeeze(-1)
-        
-        if extra_conditioning_latents:
-            init_latents = torch.cat([*extra_conditioning_latents, init_latents], dim=1)
-            init_pixel_coords = torch.cat([*extra_conditioning_pixel_coords, init_pixel_coords], dim=2)
-            init_conditioning_mask = torch.cat([*extra_conditioning_mask, init_conditioning_mask], dim=1)
-        
-        return init_latents, init_pixel_coords, init_conditioning_mask, extra_conditioning_num_latents
-    
+
 
 
 # --- 5. CLASSE PRINCIPAL DO SERVIÇO ---
@@ -329,12 +259,9 @@ class VideoService:
         self.last_memory_reserved_mb = 0.0
         self._tmp_dirs = set(); self._tmp_files = set(); self._last_outputs = []
 
-        
         self.pipeline, self.latent_upsampler = self._load_models()
         print(f"[DEBUG] Pipeline e Upsampler carregados. Upsampler ativo? {bool(self.latent_upsampler)}")
 
-        #self._apply_ltx_pipeline_patches()
-        
         print(f"[DEBUG] Movendo modelos para {self.device}...")
         self.pipeline.to(self.device)
         if self.latent_upsampler:
@@ -357,26 +284,6 @@ class VideoService:
 
         print(f"[DEBUG] VideoService pronto. boot_time={time.perf_counter()-t0:.3f}s")
 
-
-        
-        
-    # Em ltx_server.py
-    def _apply_ltx_pipeline_patches(self):
-        """Aplica patches em tempo de execução na pipeline LTX para compatibilidade com ADUC-SDR."""
-        # Lógica de importação tardia para o tipo, caso não esteja no escopo global
-        from ltx_video.pipelines.pipeline_ltx_video import LTXVideoPipeline
-    
-        print("LTX POOL MANAGER: Aplicando patches ADUC-SDR na pipeline LTX...")
-    
-        # APLICA O PATCH DIRETAMENTE NA ÚNICA INSTÂNCIA DO PIPELINE
-        self.pipeline.prepare_conditioning = _aduc_prepare_conditioning_patch.__get__(
-            self.pipeline, LTXVideoPipeline
-        )
-    
-    print("LTX POOL MANAGER: A instância da pipeline foi corrigida com sucesso.")
-     
-    
-    
     def _log_gpu_memory(self, stage_name: str):
         if self.device != "cuda":
             return
@@ -636,10 +543,10 @@ class VideoService:
                 start = (num_latente_por_chunk*i)
                 end = (start+num_latente_por_chunk+overlap)
                 if i+1 < n_chunks:
-                    chunk = latents_brutos[:, :, start:end, :, :]
+                    chunk = latents_brutos[:, :, start:end, :, :].clone().detach()
                     print(f"[DEBUG] chunk{i+1}[:, :, {start}:{end}, :, :] = {chunk.shape[2]}")
                 else:
-                    chunk = latents_brutos[:, :, start:, :, :]
+                    chunk = latents_brutos[:, :, start:, :, :].clone().detach()
                     print(f"[DEBUG] chunk{i+1}[:, :, {start}:, :, :] = {chunk.shape[2]}")
                 chunks.append(chunk)
                 i+=1
@@ -671,7 +578,7 @@ class VideoService:
         #if total % 2 == 1:  # ÍMPAR
             # Ex: 11 → primeira 0..5, segunda 5..10
         cut = total // 2
-        primeira = latents_brutos[:, :, :cut, :, :].clone()
+        primeira = latents_brutos[:, :, :cut+1, :, :].clone()
         segunda  = latents_brutos[:, :, cut:, :, :].clone()
         
         
@@ -876,7 +783,7 @@ class VideoService:
             "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.001,
+            "image_cond_noise_scale": 0.05,
             "is_video": True,
             "vae_per_channel_normalize": True,
             "mixed_precision": (self.config["precision"] == "mixed_precision"),
@@ -941,7 +848,7 @@ class VideoService:
                     del base_latents; gc.collect(); torch.cuda.empty_cache()
 
                     par = 0
-                    latents_cpu_up = upsampled_latents.to("cpu", non_blocking=True)
+                    latents_cpu_up = upsampled_latents.detach().to("cpu", non_blocking=True)
                     torch.cuda.empty_cache()
                     try:
                          torch.cuda.ipc_collect()
@@ -959,13 +866,12 @@ class VideoService:
 
                     #latents_parts_up = [latents_cpu_up]
 
-                    par = 1
+                    
                     for latents in latents_parts_up:
                
                         # # --- ETAPA 3: REFINAMENTO DE TEXTURA (SECOND PASS) ---
                         print("\n--- INICIANDO ETAPA 3: REFINAMENTO DE TEXTURA (SECOND PASS) ---")
-                        print(f"[DEBUG] Partição {par}: {tuple(lat_bup.shape)}")
-                        par+=1
+                
                         second_pass_config = self.config.get("second_pass", {}).copy()
                         # --- <INÍCIO DA LÓGICA DE CÁLCULO EXATA PARA SECOND PASS> ---
                         # Usa as dimensões da primeira passagem dobradas, como na pipeline original
@@ -984,7 +890,6 @@ class VideoService:
                        
                         second_pass_kwargs = call_kwargs.copy()
                         second_pass_kwargs.update({
-                           "conditioning_items": None,
                            "output_type": "latent",
                            "width": second_pass_width,
                            "height": second_pass_height,
@@ -1025,7 +930,7 @@ class VideoService:
 
             for latents_vae in latents_list:
             
-                latents_cpu_vae = latents_vae.to("cpu", non_blocking=True)
+                latents_cpu_vae = latents_vae.detach().to("cpu", non_blocking=True)
                 torch.cuda.empty_cache()
                 try:
                     torch.cuda.ipc_collect()
@@ -1036,14 +941,14 @@ class VideoService:
 
 
                 lat_a, lat_b = self._dividir_latentes(latents_cpu_vae)
-                #print(f"[DEBUG] Partição A: {tuple(lat_a.shape)}")
-                #print(f"[DEBUG] Partição B: {tuple(lat_b.shape)}")
+                print(f"[DEBUG] Partição A: {tuple(lat_a.shape)}")
+                print(f"[DEBUG] Partição B: {tuple(lat_b.shape)}")
             
                 latents_parts_vae = [lat_a, lat_b]
 
                 
                 for latents in latents_parts_vae:
-                    print(f"[DEBUG] Partição {par}: {tuple(latents.shape)}")
+                    #print(f"[DEBUG] Partição {par}: {tuple(latents.shape)}")
            
                     par = par + 1
                     output_video_path = os.path.join(temp_dir, f"output_{used_seed}_{par}.mp4")
@@ -1077,10 +982,10 @@ class VideoService:
     
             total_partes = len(partes_mp4)
             if (total_partes>1):
-                final_vid = os.path.join(results_dir, f"concat.mp4")
+                final_vid = os.path.join(results_dir, f"concat_fim_{used_seed}.mp4")
                 #partes_mp4_fade = self._gerar_lista_com_transicoes(pasta=results_dir, video_paths=partes_mp4, crossfade_frames=8)
-                final_vid = video_encode_tool_singleton.concatenate_videos(video_paths=partes_mp4, output_path="concate.mp4", workspace_dir=results_dir, start=4, overlap=4)
-                #self._concat_mp4s_no_reencode(partes_mp4, final_vid)
+                final_vid = video_encode_tool_singleton.concatenate_videos(video_paths=partes_mp4, output_path="concate_fim.mp4", workspace_dir=results_dir)
+                self._concat_mp4s_no_reencode(partes_mp4, final_vid)
             else:
                 final_vid = partes_mp4[0]