Update api/ltx_server_refactored.py

api/ltx_server_refactored.py

@@ -219,11 +219,14 @@ class VideoService:
 
     @torch.no_grad()
     def _upsample_latents_internal(self, latents: torch.Tensor) -> torch.Tensor:
-        if not self.latent_upsampler:
-            raise ValueError("Latent Upsampler não está carregado.")
-        latents_unnormalized = un_normalize_latents(latents, self.pipeline.vae, vae_per_channel_normalize=True)
-        upsampled_latents = self.latent_upsampler(latents_unnormalized)
-        return normalize_latents(upsampled_latents, self.pipeline.vae, vae_per_channel_normalize=True)
+        try:
+            if not self.latent_upsampler:
+                raise ValueError("Latent Upsampler não está carregado.")
+            latents_unnormalized = un_normalize_latents(latents, self.pipeline.vae, vae_per_channel_normalize=True)
+            upsampled_latents = self.latent_upsampler(latents_unnormalized)
+            return normalize_latents(upsampled_latents, self.pipeline.vae, vae_per_channel_normalize=True)
+        except Exception as e:
+            pass
         finally:
             torch.cuda.empty_cache()
             torch.cuda.ipc_collect()
@@ -234,20 +237,7 @@ class VideoService:
         tensor = torch.nn.functional.pad(tensor, padding_values)
         return tensor.to(self.device, dtype=self.runtime_autocast_dtype)
 
-    def _concat_mp4s_no_reencode(self, mp4_list: List[str], out_path: str):
-        if len(mp4_list) == 1:
-            shutil.move(mp4_list[0], out_path)
-            return
-        with tempfile.NamedTemporaryFile("w", delete=False, suffix=".txt") as f:
-            for mp4 in mp4_list:
-                f.write(f"file '{os.path.abspath(mp4)}'\n")
-            list_path = f.name
-        cmd = f"ffmpeg -y -f concat -safe 0 -i {list_path} -c copy {out_path}"
-        try:
-            subprocess.check_call(shlex.split(cmd))
-        finally:
-            os.remove(list_path)
-
+            
     def _save_and_log_video(self, pixel_tensor, base_filename, fps, temp_dir, results_dir, used_seed, progress_callback=None):
         output_path = os.path.join(temp_dir, f"{base_filename}_{used_seed}.mp4")
         video_encode_tool_singleton.save_video_from_tensor(
@@ -295,71 +285,78 @@ class VideoService:
             "output_type": "latent", "conditioning_items": conditioning_items, "guidance_scale": float(guidance_scale),
             **(self.config.get("first_pass", {}))
         }
-        with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device == 'cuda'):
-            latents = self.pipeline(**first_pass_kwargs).images
-            pixel_tensor = vae_manager_singleton.decode(latents.clone(), decode_timestep=float(self.config.get("decode_timestep", 0.05)))
-            video_path = self._save_and_log_video(pixel_tensor, "low_res_video", FPS, temp_dir, results_dir, used_seed)
-            latents_cpu = latents.detach().to("cpu")
-            tensor_path = os.path.join(results_dir, f"latents_low_res_{used_seed}.pt")
-            torch.save(latents_cpu, tensor_path)
-        return video_path, tensor_path, used_seed
+        try: 
+            with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device == 'cuda'):
+                latents = self.pipeline(**first_pass_kwargs).images
+                pixel_tensor = vae_manager_singleton.decode(latents.clone(), decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+                video_path = self._save_and_log_video(pixel_tensor, "low_res_video", FPS, temp_dir, results_dir, used_seed)
+                latents_cpu = latents.detach().to("cpu")
+                tensor_path = os.path.join(results_dir, f"latents_low_res_{used_seed}.pt")
+                torch.save(latents_cpu, tensor_path)
+            return video_path, tensor_path, used_seed
+        
+        except Exception as e:
+            pass
         finally:
             torch.cuda.empty_cache()
             torch.cuda.ipc_collect()
             self.finalize(keep_paths=[])
-
+            
     def generate_upscale_denoise(self, latents_path, prompt, negative_prompt, guidance_scale, seed):
         used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
         seed_everething(used_seed)
         temp_dir = tempfile.mkdtemp(prefix="ltxv_up_"); self._register_tmp_dir(temp_dir)
         results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
         latents_low = torch.load(latents_path).to(self.device)
-        with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device == 'cuda'):
-            upsampled_latents = self._upsample_latents_internal(latents_low)
-            upsampled_latents = adain_filter_latent(latents=upsampled_latents, reference_latents=latents_low)
-            del latents_low; torch.cuda.empty_cache()
+        try:
+            with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device == 'cuda'):
+                upsampled_latents = self._upsample_latents_internal(latents_low)
+                upsampled_latents = adain_filter_latent(latents=upsampled_latents, reference_latents=latents_low)
+                del latents_low; torch.cuda.empty_cache()
             
-            # --- LÓGICA DE DIVISÃO SIMPLES COM OVERLAP ---
-            total_frames = upsampled_latents.shape[2]
-            # Garante que mid_point seja pelo menos 1 para evitar um segundo chunk vazio se houver poucos frames
-            mid_point = max(1, total_frames // 2) 
-            chunk1 = upsampled_latents[:, :, :mid_point, :, :]
-            # O segundo chunk começa um frame antes para criar o overlap
-            chunk2 = upsampled_latents[:, :, mid_point - 1:, :, :]
+                # --- LÓGICA DE DIVISÃO SIMPLES COM OVERLAP ---
+                total_frames = upsampled_latents.shape[2]
+                # Garante que mid_point seja pelo menos 1 para evitar um segundo chunk vazio se houver poucos frames
+                mid_point = max(1, total_frames // 2) 
+                chunk1 = upsampled_latents[:, :, :mid_point, :, :]
+                # O segundo chunk começa um frame antes para criar o overlap
+                chunk2 = upsampled_latents[:, :, mid_point - 1:, :, :]
             
-            final_latents_list = []
-            for i, chunk in enumerate([chunk1, chunk2]):
-                if chunk.shape[2] <= 1: continue # Pula chunks inválidos ou vazios
-                second_pass_height = chunk.shape[3] * self.pipeline.vae_scale_factor
-                second_pass_width = chunk.shape[4] * self.pipeline.vae_scale_factor
-                second_pass_kwargs = {
-                    "prompt": prompt, "negative_prompt": negative_prompt, "height": second_pass_height, "width": second_pass_width,
-                    "num_frames": chunk.shape[2], "latents": chunk, "guidance_scale": float(guidance_scale),
-                    "output_type": "latent", "generator": torch.Generator(device=self.device).manual_seed(used_seed),
-                    **(self.config.get("second_pass", {}))
-                }
-                refined_chunk = self.pipeline(**second_pass_kwargs).images
-                # Remove o overlap do primeiro chunk refinado antes de juntar
-                if i == 0:
-                    final_latents_list.append(refined_chunk[:, :, :-1, :, :])
-                else:
-                    final_latents_list.append(refined_chunk)
+                final_latents_list = []
+                for i, chunk in enumerate([chunk1, chunk2]):
+                   if chunk.shape[2] <= 1: continue # Pula chunks inválidos ou vazios
+                      second_pass_height = chunk.shape[3] * self.pipeline.vae_scale_factor
+                      second_pass_width = chunk.shape[4] * self.pipeline.vae_scale_factor
+                      second_pass_kwargs = {
+                         "prompt": prompt, "negative_prompt": negative_prompt, "height": second_pass_height, "width": second_pass_width,
+                         "num_frames": chunk.shape[2], "latents": chunk, "guidance_scale": float(guidance_scale),
+                         "output_type": "latent", "generator": torch.Generator(device=self.device).manual_seed(used_seed),
+                          **(self.config.get("second_pass", {}))
+                      }
+                      refined_chunk = self.pipeline(**second_pass_kwargs).images
+                      # Remove o overlap do primeiro chunk refinado antes de juntar
+                    if i == 0:
+                        final_latents_list.append(refined_chunk[:, :, :-1, :, :])
+                    else:
+                        final_latents_list.append(refined_chunk)
 
-            final_latents = torch.cat(final_latents_list, dim=2)
-            log_tensor_info(final_latents, "Latentes Upscaled/Refinados Finais")
+                final_latents = torch.cat(final_latents_list, dim=2)
+                log_tensor_info(final_latents, "Latentes Upscaled/Refinados Finais")
 
             latents_cpu = final_latents.detach().to("cpu")
             tensor_path = os.path.join(results_dir, f"latents_refined_{used_seed}.pt")
             torch.save(latents_cpu, tensor_path)
             pixel_tensor = vae_manager_singleton.decode(final_latents, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
             video_path = self._save_and_log_video(pixel_tensor, "refined_video", 24.0, temp_dir, results_dir, used_seed)
-        return video_path, tensor_path
+            return video_path, tensor_path
+        except Exception as e:
+            pass
         finally:
             torch.cuda.empty_cache()
             torch.cuda.ipc_collect()
             self.finalize(keep_paths=[])
 
-    def encode_mp4(self, latents_path: str, fps: int = 24):
+def encode_mp4(self, latents_path: str, fps: int = 24):
         latents = torch.load(latents_path)
         seed = random.randint(0, 99999)
         temp_dir = tempfile.mkdtemp(prefix="ltxv_enc_"); self._register_tmp_dir(temp_dir)