Update api/ltx_server.py

api/ltx_server.py

@@ -821,7 +821,9 @@ class VideoService:
                 if improve_texture:
                     if not self.latent_upsampler:
                         raise ValueError("Upscaler espacial não carregado, mas 'improve_texture' está ativo.")
-                    
+
+                    first_pass_kwargs = call_kwargs.copy()
+    
                     # --- ETAPA 1: GERAÇÃO BASE (FIRST PASS) ---
                     print("\n--- INICIANDO ETAPA 1: GERAÇÃO BASE (FIRST PASS) ---")
                     t_pass1 = time.perf_counter()
@@ -830,23 +832,21 @@ class VideoService:
                     downscale_factor = self.config.get("downscale_factor", 0.6666666)
                     vae_scale_factor = self.pipeline.vae_scale_factor # Geralmente 8
                     
-                    # --- <INÍCIO DA LÓGICA DE CÁLCULO EXATA> ---
-                    # Replica a fórmula da LTXMultiScalePipeline
                     x_width = int(width_padded * downscale_factor)
                     downscaled_width = x_width - (x_width % vae_scale_factor)
                     x_height = int(height_padded * downscale_factor)
                     downscaled_height = x_height - (x_height % vae_scale_factor)
                     print(f"[DEBUG] First Pass Dims: Original Pad ({width_padded}x{height_padded}) -> Downscaled ({downscaled_width}x{downscaled_height})")
-                    # --- <FIM DA LÓGICA DE CÁLCULO EXATA> ---
 
-                    first_pass_kwargs = call_kwargs.copy()
-    
+                    first_pass_kwargs.update({
+                        **first_pass_config
+                    })
+                    
                     first_pass_kwargs.update({
                         "output_type": "latent",
                         "width": downscaled_width,
                         "height": downscaled_height,
                         "guidance_scale": float(guidance_scale),
-                        **first_pass_config
                     })
                     
                     print(f"[DEBUG] First Pass: Gerando em {downscaled_width}x{downscaled_height}...")
@@ -879,29 +879,29 @@ class VideoService:
                     cc = 1
                     for latents in latents_parts_up:
 
+                        t_pass2 = time.perf_counter()
                         print("\n\n#########################################")
                         # # --- ETAPA 3: REFINAMENTO DE TEXTURA (SECOND PASS) ---
                         print(f"\n--- INICIANDO ETAPA 3/{cc} ")
-                
+
+                        second_pass_kwargs = first_pass_config.copy()
                         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
+
                         second_pass_width = downscaled_width * 2
                         second_pass_height = downscaled_height * 2
                         print(f"[DEBUG] Second Pass Dims: Target ({second_pass_width}x{second_pass_height})")
-                        # --- <FIM DA LÓGICA DE CÁLCULO EXATA> --- 
-                        t_pass2 = time.perf_counter()
-
+                        
                         num_latent_frames_part = latents.shape[2]
-
                         log_tensor_info(latents, "Latentes input (Pre-Pós-Second Pass)")
                     
-
                         vae_temporal_scale = self.pipeline.video_scale_factor # Geralmente 4 ou 8
                         num_pixel_frames_part = ((num_latent_frames_part - 1) * vae_temporal_scale) + 1
                         print(f"[DEBUG] Parte: {num_latent_frames_part - 1} latentes -> {num_pixel_frames_part} frames de pixel (alvo)")
-                       
-                        second_pass_kwargs = call_kwargs.copy()
+
+                        second_pass_kwargs.update({
+                           **second_pass_config
+                        })
+                        
                         second_pass_kwargs.update({
                            "output_type": "latent",
                            "width": second_pass_width,
@@ -909,7 +909,6 @@ class VideoService:
                            "num_frames": num_pixel_frames_part,
                            "latents": latents, # O tensor upscaled
                            "guidance_scale": float(guidance_scale),
-                           **second_pass_config
                         })
                     
                         print(f"[DEBUG] Second Pass: Refinando em {width_padded}x{height_padded}...")
@@ -926,23 +925,18 @@ class VideoService:
                 else: # Geração de etapa única
                     print("\n--- INICIANDO GERAÇÃO DE ETAPA ÚNICA ---")
                     t_single = time.perf_counter()
-                    
-                    single_pass_call_kwargs = call_kwargs.copy()
-                    single_pass_call_kwargs_config = self.config.get("first_pass", {})
-
-                    single_pass_call_kwargs["output_type"] = "latent"
-                    single_pass_call_kwargs["timesteps"] = single_pass_call_kwargs_config.get("timesteps")
-                    single_pass_call_kwargs["guidance_scale"] = float(guidance_scale)
-                    single_pass_call_kwargs["stg_scale"] = single_pass_call_kwargs_config.get("stg_scale")
-                    single_pass_call_kwargs["rescaling_scale"] = single_pass_call_kwargs_config.get("rescaling_scale")
+                    single_pass_kwargs = call_kwargs.copy()
+                    single_pass_kwargs.update(self.config.get("first_pass", {}))
+                    single_pass_kwargs["guidance_scale"] = float(guidance_scale)
+                    single_pass_kwargs["output_type"] = "latent"
                     
                     # Remove keys that might conflict or are not used in single pass / handled by above
-                    single_pass_call_kwargs.pop("num_inference_steps", None) 
-                    single_pass_call_kwargs.pop("first_pass", None) 
-                    single_pass_call_kwargs.pop("second_pass", None)
-                    single_pass_call_kwargs.pop("downscale_factor", None)
+                    single_pass_kwargs.pop("num_inference_steps", None) 
+                    single_pass_kwargs.pop("first_pass", None) 
+                    single_pass_kwargs.pop("second_pass", None)
+                    single_pass_kwargs.pop("downscale_factor", None)
                     
-                    latents = self.pipeline(**single_pass_call_kwargs).images
+                    latents = self.pipeline(**single_pass_kwargs).images
                     log_tensor_info(latents, "Latentes Finais (Etapa Única)")
                     print(f"[DEBUG] Etapa única concluída em {time.perf_counter() - t_single:.2f}s")
 
@@ -967,7 +961,7 @@ class VideoService:
                 except Exception:
                     pass
                     
-                latents_parts_vae = self._dividir_latentes_por_tamanho(latents_cpu_vae,4,0)
+                latents_parts_vae = self._dividir_latentes_por_tamanho(latents_cpu_vae,4,1)
                 
                 for latents in latents_parts_vae:
                     print(f"[DEBUG] Partição {par}: {tuple(latents.shape)}")