Update api/ltx_server.py

api/ltx_server.py

@@ -671,7 +671,7 @@ class VideoService:
         multi_scale_pipeline = None
 
         try:
-            if True: #improve_texture:
+            if improve_texture:
                 if not self.latent_upsampler:
                     raise ValueError("Upscaler espacial não carregado.")
                 print("[DEBUG] Multi-escala: construindo pipeline...")
@@ -686,7 +686,7 @@ class VideoService:
                     {
                         "downscale_factor": self.config["downscale_factor"],
                         "first_pass": first_pass_args,
-                        "second_pass": first_pass_args,
+                        "second_pass": second_pass_args,
                     }
                 )
                 print("[DEBUG] Chamando multi_scale_pipeline...")
@@ -703,84 +703,20 @@ class VideoService:
                 else:
                     latents = result
                 print(f"[DEBUG] Latentes (multi-escala): shape={tuple(latents.shape)}")
-            
-            #if true:
+            else:
                 single_pass_kwargs = call_kwargs.copy()
-                first_pass_config = self.config.get("first_pass", {}).copy()
-                
+                first_pass_config = self.config.get("first_pass", {})
                 single_pass_kwargs.update(
                     {
-                        "skip_final_inference_steps": first_pass_config.get("skip_final_inference_steps"),
-                        "stg_scale": first_pass_config.get("stg_scale"),
+                        "guidance_scale": float(guidance_scale),
                         "stg_scale": first_pass_config.get("stg_scale"),
                         "rescaling_scale": first_pass_config.get("rescaling_scale"),
-                        "guidance_timesteps": first_pass_config.get("guidance_timesteps"),
                         "skip_block_list": first_pass_config.get("skip_block_list"),
-                        "num_inference_steps": first_pass_config.get("num_inference_steps"),
-                        "skip_final_inference_steps": first_pass_config.get("skip_final_inference_steps"),
-                        "cfg_star_rescale": first_pass_config.get("cfg_star_rescale"),
-                        "downscale_factor": self.config["downscale_factor"],
-                        
-                        #"guidance_scale": float(guidance_scale),
-                        #"stg_scale": first_pass_config.get("stg_scale"),
-                        #"rescaling_scale": first_pass_config.get("rescaling_scale"),
-                        #"skip_block_list": first_pass_config.get("skip_block_list"),
-                    }
-                )
-                #schedule = 
-                #first_pass_config.get("timesteps") or 
-                #first_pass_config.get("guidance_timesteps")
-                #if mode == "video-to-video":
-                #    schedule = [0.7]; print("[INFO] Modo video-to-video (etapa única): timesteps=[0.7]")
-                #if isinstance(schedule, (list, tuple)) and len(schedule) > 0:
-                #    single_pass_kwargs["timesteps"] = schedule
-                #    single_pass_kwargs["guidance_timesteps"] = schedule
-                #print(f"[DEBUG] Single-pass: timesteps_len={len(schedule) if schedule else 0}")
-
-                #print("\n[INFO] Executando pipeline de etapa única...")
-                #t_sp = time.perf_counter()
-                #ctx = torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype) if self.device == "cuda" else contextlib.nullcontext()
-                #with ctx:
-                #    result = self.pipeline(**single_pass_kwargs)
-                #print(f"[DEBUG] single-pass tempo={time.perf_counter()-t_sp:.3f}s")
-
-                #if hasattr(result, "latents"):
-                #    latents = result.latents
-                #elif hasattr(result, "images") and isinstance(result.images, torch.Tensor):
-                #    latents = result.images
-                #else:
-                #    latents = result
-                #print(f"[DEBUG] Latentes (single-pass) first : shape={tuple(latents.shape)}")
-
-                single_pass_kwargs = call_kwargs.copy()
-                first_pass_config = self.config.get("first_pass", {}).copy()
-                second_pass_args = self.config.get("second_pass", {}).copy()
-                second_pass = self.config.get("second_pass", {}).copy()
-                
-                single_pass_kwargs.update(
-                    {
-                        "latents" : latents,
-                        "skip_final_inference_steps": second_pass.get("skip_final_inference_steps"),
-                        "stg_scale": second_pass.get("stg_scale"),
-                        "stg_scale": second_pass.get("stg_scale"),
-                        "rescaling_scale": second_pass.get("rescaling_scale"),
-                        "guidance_timesteps": second_pass.get("guidance_timesteps"),
-                        "skip_block_list": second_pass.get("skip_block_list"),
-                        "num_inference_steps": second_pass.get("num_inference_steps"),
-                        "skip_final_inference_steps": 0, #first_pass_config.get("skip_final_inference_steps"),
-                        "skip_initial_inference_steps": 17,# second_pass.get("skip_initial_inference_steps"),
-                        "cfg_star_rescale": second_pass.get("cfg_star_rescale"),
-                        "downscale_factor": self.config["downscale_factor"],
-                        "second_pass": second_pass_args,
-                        #"guidance_scale": float(guidance_scale),
-                        #"stg_scale": first_pass_config.get("stg_scale"),
-                        #"rescaling_scale": first_pass_config.get("rescaling_scale"),
-                        #"skip_block_list": first_pass_config.get("skip_block_list"),
                     }
                 )
-                schedule = second_pass.get("guidance_timesteps")
-                #if mode == "video-to-video":
-                #    schedule = [0.7]; print("[INFO] Modo video-to-video (etapa única): timesteps=[0.7]")
+                schedule = first_pass_config.get("timesteps") or first_pass_config.get("guidance_timesteps")
+                if mode == "video-to-video":
+                    schedule = [0.7]; print("[INFO] Modo video-to-video (etapa única): timesteps=[0.7]")
                 if isinstance(schedule, (list, tuple)) and len(schedule) > 0:
                     single_pass_kwargs["timesteps"] = schedule
                     single_pass_kwargs["guidance_timesteps"] = schedule
@@ -799,10 +735,8 @@ class VideoService:
                     latents = result.images
                 else:
                     latents = result
-                print(f"[DEBUG] Latentes (single-pass) segunda: shape={tuple(latents.shape)}")
-                
+                print(f"[DEBUG] Latentes (single-pass): shape={tuple(latents.shape)}")
 
-            
             # Staging e escrita MP4 (simples: VAE → pixels → MP4)
             
             latents_cpu = latents.detach().to("cpu", non_blocking=True)
@@ -898,4 +832,4 @@ class VideoService:
                 print(f"[DEBUG] finalize() no finally falhou: {e}")
 
 print("Criando instância do VideoService. O carregamento do modelo começará agora...")
-video_generation_service = VideoService()
+video_generation_service = VideoService()